Domain-grounded MCP servers for verticals where the answer has to be right.
Generic LLMs guess about your domain. Bolt-on RAG hallucinates retrieval. We build Model Context Protocol servers with curated, deterministic tools over your real source data — the high-trust pattern, productionised, with the repo handed to you on day one.
LLMs guess. Generic RAG hallucinates. Neither is acceptable in a high-trust domain.
Plausible-sounding answers, no traceable source
Ask a foundation model about your domain and you get fluent prose generated from training-data fragments — no citation, no provenance, no way for a domain expert to verify the claim. In legal, medical, scientific, or theological work, this is a non-starter.
Retrieval over an unstructured pile is its own hallucination
Stuffing your docs into a vector store and praying the top-k is relevant trades model hallucination for retrieval hallucination. There is no domain-aware tool surface, no deterministic lookup, and no clean way for an expert to audit what the model actually saw.
A domain MCP server exposes deterministic, source-grounded tools — not freeform retrieval — to any MCP-compatible client. The LLM stops guessing and starts calling the right tool against the real data. We build that server, end to end, against your corpus.
Curated tools over real source data, exposed over the open MCP standard.
Anthropic's Model Context Protocol is the open standard for giving LLM clients tools. We design a domain-specific tool surface, build the indexing and retrieval to back it, and ship a stateless MCP server that any MCP-compatible client can call.
Tool surface design
We work with your domain experts to define the small, sharp set of operations the LLM should be able to perform — get_passage_text, get_cross_references, search_module_content, get_dictionary_entry and so on in the reference server. Not a generic search box; a curated API the model can reason about.
Source-grounded ingestion
We ingest your authoritative corpus with domain experts in the loop — SWORD modules and CCEL volumes in the reference server, FHIR in medical, statutes and case law in legal. Cross-references and lexicons are indexed in PostgreSQL, semantic vectors in pgvector or Redis, and a graph layer (Neo4j) where the domain is genuinely relational.
Stateless MCP server
A NestJS server speaks the MCP protocol over stdio, exposing each tool as a deterministic, side-effect-free function over your data. No LLM runs in-process — the server is a tool provider, scales horizontally, and plugs into Claude Desktop, Claude Code, or any custom client via the MCP SDK.
get_patristic_references against the reference server. The MCP layer queries indexed CCEL data and returns Tertullian's On Baptism on the washing from sin[1], Cyprian on grace given in full measure regardless of age[2], and Augustine tying the practice to original sin[3] — every result a real citation from a real volume, returned in under 100ms from the indexed store. Source integrity is structural, not a layer you bolt on.
A competitor can spin up a vector store in an afternoon. Building a deterministic tool surface over a curated corpus with domain experts in the loop is a different exercise — and it is the entire bet.
Source-grounded, deterministic tools
Every tool call resolves to a real row in a real source — not an LLM's guess and not a fuzzy retrieval over an unstructured pile. The model writes from evidence.
Domain experts in the ingestion loop
Data quality beats model cleverness. We pair our engineers with your subject-matter experts during ingestion so the indexed corpus reflects the domain's actual structure, vocabulary, and citation conventions.
Stateless by design
The server holds no per-conversation state. It scales horizontally, composes cleanly with other MCP servers, and never becomes the bottleneck in your LLM application.
Production-tested reference implementation
Pastoral Research MCP runs in production behind ElderAgent — 11 tools, 1.05M cross-references, 16K patristic citations, 1,874+ unit tests. Buyers see exactly what they would get.
Runs in any MCP-compatible client
The same server plugs into Claude Desktop, Claude Code, or an in-house Claude/OpenAI app via the MCP SDK. No vendor lock-in to a single LLM provider or chat surface.
You leave with the repo
Fixed price, fixed timeline, source-code handoff. No per-call SaaS pricing, no opaque hosting layer, no vendor-managed black box you cannot inspect or extend.
Four engagement tiers — from a one-week scope to an ongoing build.
Every engagement is fixed-price against a written scope. We start small on purpose: a Discovery week usually pays for itself in scope clarity before a line of server code is written.
- 1–2 weeks of joint work with your domain experts
- Tool-surface specification (4–10 tools)
- Corpus inventory and ingestion plan
- Written architecture brief and price quote for the build
- 6–10 week build against the Discovery spec
- 4–6 production tools over one curated corpus
- PostgreSQL + Redis + (pgvector when warranted)
- Deployable to a single host or your container platform
- Eval harness with a domain-expert-curated test set
- 10+ tools across multiple curated corpora
- Full ingestion pipeline with domain-expert review gates
- PostgreSQL + Redis + pgvector + Neo4j when the domain is relational
- Observability, structured logs, eval harness, backup/restore
- Reference-implementation feature parity with Pastoral Research MCP
- Ongoing corpus updates and re-ingestion
- New tool development against the existing surface
- Eval-driven quality work and regression fixes
- On-call response window for production incidents
The canonical stack we ship — proven in the reference implementation.
stdio transport. No LLM runs in-process — the server is a stateless tool provider that any MCP-compatible client can drive. 1,049,029 citations indexed here. @huggingface/transformers runs in-process for embedding. Cypher from a dedicated service layer. nginx, or containerised for your cloud. Stateless API plus Redis-shared session state means horizontal scaling is a config change, not a rewrite. @modelcontextprotocol/sdk. The protocol is the integration. Single-host Docker deployment behind nginx, horizontally scalable thanks to a stateless tool provider and Redis-shared cache. The MCP server speaks stdio to its client — no HTTP boundary, no auth surface to attack — so the security model collapses to filesystem and process boundaries the host already enforces.
Five fixed phases from a scoping call to a production handoff.
Every build runs through the same gates. Earlier phases are de-risked by the Discovery week; the handoff is non-negotiable — you leave with the repo, the data pipeline, the eval harness, and the deploy story.
Joint scoping with your domain experts. We leave Discovery with a written tool-surface spec, a corpus inventory, success metrics, and a fixed quote for the build.
Data model, index strategy, tool contracts, and eval-harness design — all signed off before a production line is written. Reference: the architecture review that hardened Pastoral Research MCP v2.
Ingestion pipeline, indexing, tool implementations, stateless MCP server, and the eval harness — built test-first against the Discovery spec. The reference implementation reached 1,874+ unit tests through this loop.
Repository transfer, deployment runbook, ingestion runbook, eval harness, and an architecture walkthrough with your engineers. You own the codebase; we owe you no ongoing licence fee.
Retainer engagement for corpus updates, new tools, eval-driven quality work, and on-call response. Engaged only if you want us — the codebase runs without us.
Anywhere "plausible but wrong" is unacceptable.
Pastoral Research MCP is one instance of a generalisable pattern. The same architecture — domain-curated tools over real source data, exposed via MCP — applies wherever the cost of a hallucinated answer is high.
Need an MCP server for your domain?
We build domain-grounded MCP servers for high-trust verticals — fixed price, fixed timeline, source-code handoff. Start with a Discovery week; leave with a written spec, an architecture brief, and a quote. If you build, you own the repo.