JULY 2026
COELHO Nexus
Kubernetes-native multi-agent AI platform hosting three production features — documentation distillation, YouTube GraphRAG search, and autonomous research digests — on one shared LLM rotator, six data stores, and full GitOps observability, architected and operated solo.
Executive summary
COELHO Nexus is a Kubernetes-native platform hosting three independent, production-grade AI applications behind one shared foundation: one LLM router, six data stores, one observability stack, one Terraform-provisioned cluster. It’s designed, built, and operated end-to-end by one engineer — infrastructure, backend, agent pipelines, and delivery, held to the same rigor a platform team would bring to production.
- Docs Distiller — turns any framework’s scattered documentation into a structured, chapter-by-chapter study guide.
- YouTube Content Search — hybrid semantic + graph + full-text search over YouTube transcripts, with adaptive multi-hop RAG.
- Research Radar — an autonomous agent that scans arXiv, Semantic Scholar, HuggingFace, and Hacker News and ships a ranked, implementable-ideas digest.
Every LLM call across all three routes through a single free-tier bandit rotator, so the whole platform — three agentic pipelines, six data stores, a full LGTM + LangFuse observability stack — runs at $0 in inference cost.
See it deployed
The platform runs on a local k3d Kubernetes cluster provisioned entirely by Terraform — not something you can casually spin up. These 80 slides are the verifiable record: real frameworks ingested, real YouTube transcripts searched and cited, a real arXiv scan ranked and digested, plus live screenshots of Rancher, Grafana, ArgoCD, Neo4j, Qdrant, Elasticsearch, MinIO, and LangFuse actually running the system. Navigate with arrows or open fullscreen for the full read.
Three apps, one platform
| App | What it does | Proven on |
|---|---|---|
| Docs Distiller | A five-tier ingestion cascade (llms_full.txt → llms_txt → sitemap → httpx-crawl-with-Playwright-fallback → GitHub README) pulls in a framework’s documentation; a LangGraph Planner → Synth pipeline turns it into a structured study guide, chapter by chapter. | 107 frameworks catalogued — Celery (493 pages), Pydantic (308 pages), Claude Code (195 pages), Skaffold (80 pages) already ingested and synthesized |
| YouTube Content Search | Playwright-driven transcript scraping feeds a hybrid retrieval pipeline — Qdrant dense vectors, Elasticsearch full-text, and a Neo4j entity graph — behind an adaptive RAG loop (retrieve → grade → generate → verify) across four query-depth modes. | A real channel ingestion (Andrej Karpathy’s catalog) answering cross-video questions with a structured, inline-cited answer — not a generic summary |
| Research Radar | An 8-phase DeepAgents orchestrator fans out across four discovery sources, scores every candidate on an 8-term weighted signal, deep-reads the top papers, and synthesizes a ranked digest with cross-paper themes. | A live scan surfacing and ranking real arXiv and Hacker News papers, each with an LLM-extracted commercial “money angle” |
Architecture
Three microservices carry the whole platform:
- FastAPI — the ML/agent backend. Owns all three pipelines plus Celery-orchestrated background task queues, one isolated queue per feature.
- FastHTML — the frontend. Server-rendered, HTMX-reactive, no JS build step, Cytoscape.js graph visualizations, SSE for live pipeline progress.
- FastMCP — an internal Model Context Protocol gateway exposing the four research-discovery tools (arXiv, Semantic Scholar, HuggingFace, Hacker News) that Research Radar calls into, with rate-limited token buckets and BYOK credential injection.
Six data stores, each earning its place:
| Store | Role |
|---|---|
| PostgreSQL | Relational state — conversations, LangGraph checkpoints, LangFuse, ArgoCD |
| Neo4j | Knowledge graphs — YCS entity/relationship extraction, Research Radar’s paper network |
| Qdrant | Vector search — transcript embeddings, paper dedup and relevance scoring (2048-dim, hybrid dense + sparse) |
| Elasticsearch | Full-text / BM25 search over transcripts and ingested docs |
| MinIO | S3-compatible object storage — page bodies, planner/synth artifacts, encrypted BYOK credentials |
| Redis | Celery broker/result backend, bandit state, caching |
Infrastructure as code: 18 Terraform modules, composed with Terragrunt across a six-layer
dependency graph — bootstrap → platform → data → observability → apps → edge — onto a local
k3d cluster. Two independent delivery paths run the same Helm chart: Skaffold for the
hot-reload dev loop, and ArgoCD GitOps — Image Updater watching the registry for new digests —
for a production-like deploy. A separate homelab production cluster runs the same GitOps model
against an in-cluster GitLab instance instead of GitHub directly.
Inside the pipelines
Each pipeline is a distinct agentic pattern, not a single-prompt wrapper:
- Docs Distiller’s Planner is a nine-node LangGraph: embed the corpus (NVIDIA NIM, 2048-dim) → filter off-topic pages with a bandit-routed LLM judge → distill each document → propose chapters with universal self-consistency voting → assign documents to chapters (confidence score plus lexical fallback, so nothing silently drops) → greedy-select for full corpus coverage → order chapters by bandit-ranked, Borda-aggregated pedagogical sequencing.
- Docs Distiller’s Synth writes each chapter with a best-of-N writer-critic loop, derives business-relevant code examples via analogical prompting when source material is thin, and gates every section on a multi-criteria quality checklist before a self-refinement replan loop fires. The techniques are grounded in published research, not ad hoc prompting — the writer-critic pattern follows MAMM-Refine (arXiv:2503.15272), code derivation follows Analogical Prompting (arXiv:2310.01714), and the audit pass checks CoCoA alignment (arXiv:2410.03131).
- YCS’s retrieval fuses three signals per query — Qdrant dense vectors, Elasticsearch BM25, and Neo4j graph traversal — then runs an adaptive RAG loop that grades its own retrieval and retries with rewritten queries before answering, instead of stuffing top-k into a prompt and hoping. A dedicated Query tab exposes all three backends directly: write or AI-generate Cypher, an Elasticsearch filter, or a Qdrant filter, and render the result as a graph, table, or raw JSON.
- Research Radar’s DeepAgents orchestrator runs four parallel discovery subagents (arXiv, Semantic Scholar, HuggingFace, Hacker News) plus triage, deep-read, graph-build, and synthesis as eight distinct phases, each with its own subagent and isolated context — not one long-running prompt trying to do everything at once.
The free-tier LLM rotator
Every LLM call across all three features — one router for the whole platform, not one per app — routes through a rotator that picks the best of 20+ free-tier models across seven providers (NVIDIA NIM, Groq, Cerebras, Mistral, Google Gemini, DeepSeek, SambaNova) using a variance-aware Thompson-sampling contextual bandit (FGTS-VA). Each call is encoded as a 24-dimension context vector — task type, corpus size, time of day, live per-provider error rates — and every response updates that model’s posterior with a composite reward blending success, schema validity, latency, and recall, so one lucky or unlucky response never over- or under-corrects the routing. BYOK: bring your own provider keys via the Settings UI, Fernet-encrypted at rest in MinIO, never sent back to the browser.
Observability: two panes of glass
Every pipeline run, LLM call, and cross-service request is traced twice, correlated by a shared
trace_id:
- Grafana LGTM stack — OpenTelemetry, dual-exported through Grafana Alloy to Loki (logs), Mimir (metrics), and Tempo (traces). Dedicated dashboards per domain (DD Pipeline, YCS Ask, Research Radar, LLM Rotator, Service Topology) plus a cross-cutting Investigations view, all shipped as code inside the app’s own Helm chart.
- LangFuse — LLM-specific tracing: prompts, token usage, cost, per-session grouping, and automated grader scores (terminology consistency, citation coverage, code density) dual-written from each pipeline’s own evaluation logic.
Both panes agree on the same story: hundreds of thousands of tokens processed across a dozen models, and every one of them free.
Built on three earlier prototypes
Nexus isn’t a from-scratch bet — it’s the production consolidation of three earlier projects. YouTube Content Search proved the GraphRAG retrieval pattern; COELHO Agents proved that distinct agent patterns — memory, self-correcting retry loops, graph retrieval — can share one LangGraph foundation; COELHO GenAI proved multi-provider LLM routing. Nexus takes all three and rebuilds them to production standard: hybrid retrieval instead of graph-only, a self-learning bandit instead of a manual toggle, DeepAgents orchestration instead of a single chain — on infrastructure a platform team would recognize.
What this project proves
- End-to-end platform ownership — Terraform modules, three microservices, three agentic pipelines, GitOps delivery, and dual observability, all designed, built, and operated by one engineer.
- Production discipline over framework-of-the-week — every pipeline grounds its technique in published research and gates its output on measurable criteria, not “the LLM said so.”
- Cost-aware architecture at zero marginal cost — a self-learning bandit router turns “free tier” from a constraint into a legitimate production strategy, verified in the deployment record above, not claimed on faith.