LIBRAIN

Why this exists

Most RAG and AI-agent tutorials are written in Python. Production engineering organizations that run on .NET — banks, insurers, government — hear the message that "AI requires Python" and weaken the case for adopting LLM-driven features in their existing stack. LIBRAIN is a deliberate counter-example: a complete multi-agent retrieval pipeline built end-to-end in .NET 10 on Microsoft-blessed primitives (Semantic Kernel, Application Insights), Anthropic Claude, OpenAI embeddings, and a managed vector store.

It's also a portfolio artifact aligned with the Microsoft AI-200 (Azure AI Cloud Developer) certification syllabus — the production deployment target is Azure Cosmos DB for NoSQL with DiskANN vector indexing, deferred to Phase 3 once the dev pipeline is proven against local Qdrant.

Architecture

Three logical agents plus a cross-cutting audit logger. Every step emits a structured event with a correlation ID so any output is fully traceable from query back to source chunks.

Tech stack

Locked stack — chosen up-front, no swaps mid-build. Each pick has a stated rationale documented in the project plan.

API surface

The Reader Agent track exposes three endpoints today. Synthesis (POST /api/query) and the audit-trail endpoint (GET /api/audit/{id}) ship in Phase 2.

Pipeline walkthrough

Inside the chunker

The recursive chunker is the foundation of citation tracking — every chunk's offset and length must be deterministic so the synthesis layer can map a hypothesis citation back to a verifiable source span. The fallback ladder ensures size limits are respected without ever splitting mid-sentence when a paragraph break is reachable.

private static int ChooseEnd(string text, int start)
{
    int remaining = text.Length - start;
    if (remaining <= MaxChars)
    {
        return text.Length;
    }

    int targetEnd = start + TargetChars;
    int maxEnd = start + MaxChars;

    // Prefer paragraph boundary in [target, max]
    int paraEnd = LatestMatchIndex(ParagraphBreakRegex(), text, targetEnd, maxEnd);
    if (paraEnd > start) return paraEnd;

    // Fall back to sentence boundary
    int sentEnd = LatestMatchIndex(SentenceBreakRegex(), text, targetEnd, maxEnd);
    if (sentEnd > start) return sentEnd;

    // Hard cut as last resort
    return maxEnd;
}

From LIBRAIN/Reading/RecursiveChunker.cs. Constants are TargetChars = 2000, MaxChars = 4000. Each emitted chunk also rewinds OverlapChars = 300 backward to preserve context across boundaries — the 15% overlap target from the original RAG paper.

Results

Smoke-tested end-to-end on five real arXiv papers covering RAG, agentic AI surveys, and scientific-discovery pipelines.

Papers ingested in the smoke test

Five papers chosen for representativeness — the foundational RAG paper, two recent agentic-AI surveys, and two longer-form scientific-discovery papers — covering both the pipeline's depth (long surveys with many chunks) and topical relevance (RAG, agents, retrieval-grounded generation).

Vector search smoke test: query "How does retrieval augmented generation work?" returned all 5 top hits from 2005.11401 — distinct chunks from pages 1, 2, 8, and 9, with cosine similarities 0.52–0.61. Semantic recall validated end-to-end against the corpus that planted RAG itself.

What I learned

What's next

Phase 1 (Reader Agent track) shipped — ingest, chunk, embed, vector-search end-to-end. The next two phases are scoped, time-boxed, and documented in the repo's PROJECT_PLAN.md.

Get in touch

Open to senior .NET / AI-engineering roles in the EU (Netherlands, Germany, Ireland) with visa sponsorship.