agent-components

A curated monorepo of composable components for building AI applications. Each component is a small, focused package you can pull into most AI projects; they share a thin core (common models, logging) so they compose cleanly.

Status: early. agentic-router and memory-store exist; the rest of the taxonomy is planned (see Roadmap).

Layout

agent-components/
  pyproject.toml                # uv workspace root
  core/                        # shared: models, logging (Message, SessionState, ...)
  components/
    agentic-router/            # route tasks to lower/higher model + agentic loop
    memory-store/              # pluggable session + vector memory
    model-gateway/             # OpenAI-compatible façade + advanced vLLM routing
    toolkit/                   # sandboxed, validated tool registry
    retriever/                 # RAG: chunk → embed → search → rerank
    guardrails/                # PII, injection, length, schema
    tracing/                   # spans + cost/latency accounting
    eval-harness/              # dataset-driven evaluation
    prompt-registry/           # versioned prompts
    agent-ui/                  # metadata-driven UI bridge
    distillation/              # synthetic data + LLM distillation
    doc-processing/            # OCR → extraction → validation (IDP)
    context-manager/           # budgeted context-window assembly + compaction + checkpointing
  platform/                    # enterprise engineering layer (ADF/AML/patterns)
  projects/                    # real deployments on the chassis (e.g. frenchcase)
  scripts/
    demo_all_components.py     # end-to-end verification of every component

Install

Requires Python 3.10+ and uv.

uv sync                         # installs all workspace members + dev deps
uv run pytest                   # runs every component's tests

Use one component in another project (it's a normal package once published):

pip install agentic-router memory-store

Components

agentic-router

A high-level orchestrator that routes each task between a lower (fast) and higher (capable) model — heuristic scorer + LLM-as-judge fallback — then runs a ReAct loop (tools, multi-step planning, streaming, session memory) against the chosen model. Works against two OpenAI-compatible vLLM instances.

See components/agentic-router/README.md.

memory-store

Pluggable memory for agents:

• Short-term SessionStore — conversation + plan keyed by session id, with in-memory and Redis backends. Drop-in replacement for ad-hoc session dicts; the router injects whichever backend you build.
• Long-term VectorMemory — store MemoryRecords and recall by cosine similarity, with a pluggable Embedder (OpenAI-compatible endpoint, or a deterministic HashingEmbedder for tests).

from memory_store import build_session_store, build_vector_memory
from memory_store.embeddings import HashingEmbedder

sessions = build_session_store()                       # in-memory; backend="redis" for Redis
vm = build_vector_memory(embedder=HashingEmbedder())    # or OpenAIEmbedder(...)
await vm.add([MemoryRecord(content="...")])
hits = await vm.search(MemoryQuery(query="...", top_k=4))

Roadmap

The full curated taxonomy (in priority order). All 13 modular components and the enterprise Platform Engineering layer are completed.

#	Component	Role	Status
1	agentic-router	Orchestration: routing + agentic loop + tools	✅ Done
2	memory-store	Session + vector memory	✅ Done
3	model-gateway	OpenAI-compatible façade over vLLM/TGI/Ollama/cloud with LB, fallback, rate limits	✅ Done
4	toolkit	Sandboxed, validated, permissioned tool registry	✅ Done
5	retriever	RAG: ingest → chunk → embed → vector store → hybrid search → rerank	✅ Done
6	guardrails	Input/output filtering, PII redaction, injection detection, schema validation	✅ Done
7	tracing	Structured spans + cost/latency accounting	✅ Done
8	eval-harness	Dataset-driven eval + LLM-judge metrics	✅ Done
9	prompt-registry	Versioned, templated prompts + hot-reload	✅ Done
10	agent-ui	Universal metadata-driven UI bridge (FastAPI + Fluent UI + SSE + Grafana + Power Automate)	✅ Done
11	distillation	Synthetic data generation + LLM distillation: teacher CoT mining, quality/safety curation, Foundry fine-tuning, teacher↔student parity matrix	✅ Done
13	context-manager	Context window as a budget: output reserved first, eviction by priority, content dedup, source caps, per-segment ceiling, four compaction strategies with an auditable decision trail per segment. Also owns checkpointing: durable resumable run state across 4 backends, with unknown-side-effect reporting	✅ Done
12	doc-processing	Intelligent document processing: OCR/layout ingestion (Azure Document Intelligence + text-layer + stub), provenance-tracked field extraction, and layered validation (per-field, cross-field, document-level)	✅ Done
—	platform	Layer (not a component): Enterprise Platform Engineering — ADF & AML orchestrator, 8 design patterns, Medallion Lakehouse	✅ Done

License

MIT