Open source projects

Personal projects

gradion-ai/group-genie		Enables single-user AI agents to participate in group chat conversations without modification by combining Group Sense's pattern detection with a flexible agent integration layer. Supports agents from any technology stack through a simple agent interface, with default implementations provided for Pydantic AI and OpenAI Agents SDK.
gradion-ai/group-sense		Detects patterns in group chat message streams and transforms multi-party dialogue into self-contained queries that single-user AI assistants can process. Acts as a non-invasive adapter layer that enables existing AI systems to handle group conversations through natural language engagement criteria without requiring model modification or retraining.
gradion-ai/hybrid-groups		Integrates Group Genie into Slack and GitHub, enabling existing single-user AI agents to participate in group chat conversations without requiring modification to the agents themselves. Monitors group chats, detects conversation patterns, and reformulates multi-party exchanges into self-contained queries that AI agents can process.
gradion-ai/freeact		`freeact` is a lightweight AI agent library using Python as the common language to define executable actions and tool interfaces. This is in contrast to traditional approaches where actions and tools are described with JSON. A unified code-based approach enables `freeact` agents to reuse actions from earlier steps as tools or skills in later steps. This design allows agents to build on their previous work and compose more complex actions from simpler ones.
gradion-ai/ipybox		`ipybox` is a lightweight and secure Python code execution sandbox based on IPython and Docker. Designed for AI agents that interact with their environment through code execution, like `freeact` agents, it is also well-suited for many other secure code execution use cases.
krasserm/bot-with-plan		The bot-with-plan project is experimental work on separating planning from function calling in ReAct-style LLM agents, allowing for better utilization of smaller LLMs and easier generation of synthetic datasets for planner fine-tuning. It provides 7B LLMs fine-tuned on synthetic agent trajectories that reach GPT-4 level planning performance. The implementation makes heavy use of schema-guided generation for reliable communication between agent modules.
krasserm/bayesian-machine-learning		A collection of notebooks about Bayesian methods for machine learning, like Bayesian regression, Gaussian processes, Bayesian optimization, variational inference in Bayesian neural networks, ..., etc. Each notebook covers a single topic and combines an introduction, mathematical basics and a simple implementation.
krasserm/perceiver-io		The perceiver-io library is a modular implementation of Perceiver, Perceiver IO, and Perceiver AR in PyTorch, with a PyTorch Lightning integration for distributed training and a Hugging Face integration for inference. The project provides both ported official models and custom models used in training examples.
krasserm/super-resolution		This project provides a Tensorflow 2.x based implementation of three popular single image super-resolution models: EDSR, WDSR and SRGAN. Pre-trained weights, training and inference examples as well as a data loader for the DIV2K dataset are included.
krasserm/fairseq-image-captioning		Implements an Image Captioning Transformer with the fairseq sequence modelling toolkit by combining ideas from Self-critical Sequence Training for Image Captioning and Bottom-Up and Top-Down Attention for Image Captioning and Visual Question Answering with the Transformer architecture.
krasserm/face-recognition		Demonstrates how to build a face recognition system with Keras, Dlib and OpenCV. The process involves preprocessing images for face alignment, generating 128-dimensional face embeddings with a convolutional neural network (CNN), training classifiers on labeled embeddings and predicting identities of new inputs.
krasserm/streamz		Streamz is a combinator library designed to integrate Functional Streams for Scala (FS2), Akka Streams, and Apache Camel endpoints, allowing seamless interoperability between these technologies. Camel endpoints can be integrated into FS2 applications with the Camel DSL for FS2 and into Akka Streams applications with the Camel DSL for Akka Streams.
krasserm/akka-stream-eventsourcing		This project brings to Akka Streams what Akka Persistence brings to Akka Actors: persistence via event sourcing. In the same way as persistent actors in Akka Persistence, stateful request processors in akka-stream-eventsourcing form a consistency boundary around internal state but additionally provide type safety and end-to-end back-pressure for the whole event sourcing message flow.
krasserm/grails-jaxrs		grails-jaxrs is a Grails plugin that supports the development of RESTful web services based on the Java API for RESTful Web Services (JSR 311: JAX-RS). It is targeted at developers who want to structure the web service layer of an application in a JSR 311 compatible way but still want to continue to use Grails' powerful features such as GORM, automated XML and JSON marshalling, Grails services, Grails filters and so on. This plugin is an alternative to Grails' built-in mechanism for implementing RESTful web services.

Project contributions

BerriAI/litellm Contributions		LiteLLM is a library that provides a unified, OpenAI-compatible interface to access, manage, and switch between over 100 large language models (LLMs) across multiple providers, with features for cost tracking, rate limiting, fallback logic, and consistent output formatting.
langchain-ai/langchain Contributions		LangChain is a framework for developing applications powered by large language models (LLMs). It provides chains, agents, and retrieval strategies that make up an application's cognitive architecture. Third party integrations provide access to provider-specific components like LLMs, vector stores, retrievers and many more.
ggerganov/llama.cpp Contributions		llama.cpp enables large language model (LLM) inference in C/C++, with minimal setup and state-of-the-art performance on a wide variety of hardware. It also supports integer quantization from 1.5-bit to 8-bit, which significantly enhances the speed of inference while reducing memory requirements.
rom1504/clip-retrieval Contributions		This project enables users to easily compute CLIP embeddings and build efficient retrieval systems for text and image data. It offers a comprehensive suite of tools for inference, indexing, filtering, and serving, allowing users to create semantic search systems that can scale to billions of samples with high performance.
rbmhtechnology/eventuate¹⁾ Contributions		Eventuate is a toolkit for building applications composed of event-driven and event-sourced services that communicate via causally ordered event streams. Services can either be co-located on a single node or distributed up to global scale. Service state can be replicated with causal consistency guarantees and remains available for concurrent writes during network partitions.
akka/akka Contributions		Akka is an open-source toolkit for building highly concurrent, distributed, and resilient message-driven applications, implementing the Actor Model on the JVM. It provides developers with tools to create systems that scale efficiently, self-heal, maintain responsiveness during failures, and handle high-performance scenarios, all while offering features like distributed data management, reactive streaming, and elastic deployment. My main contribution to Akka is the Akka Persistence module.
akka/alpakka Contributions		The Alpakka project is an initiative for implementing reactive and stream-aware integration pipelines based on Akka Streams. It provides a domain-specific language (DSL) for reactive and stream-oriented programming, with built-in support for end-to-end backpressure. It supports a variety of integrations and ensures interoperability with other Reactive Streams implementations.
akka/akka-persistence-cassandra¹⁾ Contributions		This project provides a persistence plugin for Akka Persistence that uses Apache Cassandra as storage backend. Akka Persistence enables stateful Akka actors to persist their state via event sourcing, using persistence plugins that implement a common interface for storage backends.
eligosource/eventsourced¹⁾ Contributions		Eventsourced is a library for building reliable, scalable, and distributed event-sourced applications. It adds scalable actor state persistence and at-least-once message delivery guarantees to Akka, allowing stateful actors to persist received messages to append-only storage and to recover state by replaying received messages. It is now superseded by the Akka Persistence module of the Akka project.
oehf/ipf¹⁾ Contributions²⁾		The Open eHealth Integration Platform (IPF) offers a comprehensive set of tools for creating healthcare-related integration solutions. It is built on top of Apache Camel and provides a custom domain-specific language (DSL) for implementing enterprise integration patterns in healthcare-specific integration solutions, based on HL7 and IHE standards.
apache/camel Contributions		Apache Camel is an integration framework that simplifies the integration of different systems by supporting numerous enterprise integration patterns and data formats. It can be used standalone or embedded in other applications, making it deployable to various environments including cloud-based services.
safr¹⁾ Contributions		The Security Annotation Framework (SAF) is a framework for instance-level access control and field-level encryption. Access-control decisions at class-instance-level and crypto operations at field-level are enforced using Java 5 annotations.

¹⁾ I’m the project founder, sponsored by a customer or employer
²⁾ Commits tracked since 2008-11-29, after migrating checkpoint from previous CVS