Kurrent.Kontext.AspNetCore 0.0.0-alpha.0.43

Kurrent.Kontext

Agent memory and RAG library powered by KurrentDB. Built with .NET 10.

Gives AI agents two capabilities:

• Agent Memory — retain synthesized knowledge across sessions and recall it later. Facts are stored as events in KurrentDB and indexed for fast retrieval.
• Retrieval-Augmented Generation (RAG) — search and read raw event streams directly as grounding context. When retained facts are missing, outdated, or need verification, agents go straight to the source of truth.

KurrentDB as the backend means every fact and event is durably stored, fully auditable, and replayable — agents can always trace back to the source. Lucene.NET handles full-text search, USearch handles vector similarity, and all indexing runs on CPU with lightweight ONNX models — no LLM calls or GPUs needed for preprocessing.

How It Works

                        Data Import
Agent ──import_events──> KurrentDB (event streams) ──subscription──> Lucene + USearch (events index)

                        Agent Memory
Agent ──retain_facts───> KurrentDB (memory stream) ──subscription──> Lucene + USearch (memory index)
Agent ──recall_facts───> Lucene + USearch (memory index) ──hydrate──> KurrentDB

                        RAG
Agent ──query_events───> Lucene + USearch (events index) ──hydrate──> KurrentDB

• Import: Agent translates external data (CSV, API responses, logs, etc.) into events and writes them to KurrentDB. The subscription indexes them automatically.
• Retain (Memory): Agent stores synthesized facts as events in KurrentDB. The subscription indexes them into a separate memory index.
• Recall (Memory): Agent searches the memory index for previously retained facts. Results are hydrated from KurrentDB.
• Search (RAG): Agent searches the events index for raw KurrentDB events as grounding context. Separate from memory — no cross-contamination.

Retained facts may become outdated. Raw events are always the source of truth.

Project Structure

Kurrent.Kontext                  — Core library: memory, RAG, search, indexing, MCP tools
Kurrent.Kontext.AspNetCore       — ASP.NET Core endpoint extensions (bulk import HTTP endpoint)
Kurrent.Kontext.ExternalClient   — gRPC-backed IKontextClient for standalone use
Kurrent.Kontext.Models           — Embedded INT8 quantized ONNX models (auto-downloaded on first build)

Usage

With the external KurrentDB client

// Register gRPC-backed client + all Kontext services
services.AddKontextWithExternalClient(configuration);

// Add MCP tools (chain a transport)
services.AddKontextMcp().WithStdioServerTransport();

Custom client implementation

Implement IKontextClient for your own backend:

services.AddSingleton<IKontextClient, MyCustomClient>();
services.AddKontext(configuration);

DI API

MCP Tools

Agent Memory

Data Import

RAG (Event Retrieval)

System

How Search Works

Both agent memory and RAG share the same hybrid search pipeline:

1. Indexing — Subscribes to KurrentDB's $all stream. Each event's type name is split by naming convention (OrderPlaced → "order placed") and combined with recursively flattened data values. Noun phrases are extracted, a 384-dim embedding is generated, and the event is indexed into Lucene.NET (full-text, BM25) and USearch (vector similarity, cosine).

2. Search — Extracts noun phrases from the query, generates an embedding, runs BM25 text matching (Lucene.NET) and k-NN vector similarity (USearch) in parallel. Results are fused via Reciprocal Rank Fusion (RRF, k=60), diversified with Maximal Marginal Relevance (MMR, lambda=0.7), and optionally re-ranked with a cross-encoder.

3. Index separation — Retained facts are routed to a separate memory index using the fact text as the search key. Raw events go to the events index. Same search pipeline, separate indexes — no cross-contamination.

ML Models

Embedded in the Kurrent.Kontext.Models assembly (downloaded automatically on first build):

Two INT8 quantized embedding models are shipped — model_quint8_avx2.onnx (universal x86) and model_qint8_avx512.onnx (AVX-512 capable CPUs). The best model is selected at runtime based on CPU capabilities. Dynamic token length (no fixed padding) further reduces inference time.

Testing

dotnet test --solution Kurrent.Kontext.slnx