briefd
briefd is an MCP server that turns a git-backed team knowledge base into token-budgeted, source-attributed context bundles for coding agents, and lets agents file reviewable knowledge updates.
compile_bundle— compile everything the knowledge base says about a task into one deduplicated, cached context block ordered domain → conventions → project; hardmax_tokensbudget, optionalscopesand codepathsto surface governing rules first, and a deterministicbundle_id.search_context— ranked, budget-capped section search for looking things up or inspecting what exists (supportsscopes,paths,top_k).get_document— fetch a full document (title, tags, complete source with front matter,content_hash, links and backlinks), optionally guarded to a scope.list_scopes— discover available scopes (domain,conventions,projects/<name>) with document, section and token counts.propose_update— submit a complete new document version as a git branch (plus PR when a forge is configured) for human review; refuses stale edits (viabase_content_hash) or dropped front matter, and never changes what is served.report_usage— record which bundle sections helped, or an empty list to flag the question as a knowledge gap.suggest_links— find missing links (documents mentioned but not linked) and broken links, so an agent can tidy the knowledge base viapropose_update.
All read tools are read-only and idempotent; retrieval is hybrid (BM25 + multilingual embeddings) with every result bounded by an explicit token budget.
Allows creating reviewable knowledge update proposals as pull requests on GitHub and triggers index synchronization via GitHub-style webhooks.
Teams that build many projects in one domain keep the same knowledge in their heads and in
scattered CLAUDE.md / AGENTS.md files: terminology, business rules, architecture decisions,
conventions. Loading all of it into every session burns thousands of tokens on every turn, and
whatever doesn't fit gets left out.
briefd inverts the model: context on demand, not up front. Your knowledge lives as Markdown in a git repository. briefd indexes it and answers one question from your coding agent — "what do I need to know for this task?" — with a compiled, deduplicated bundle that never exceeds the token budget you set.
Why
On the sample knowledge repo in this repository (44 documents, 47 realistic developer tasks),
compile_bundle spends 86% fewer tokens per task than pasting everything into CLAUDE.md
while still containing the section that answers the task 96% of the time (98% with the
English-only all-MiniLM-L6-v2 model, the figure the explainer video quotes). The realistic
middle ground — a hand-curated CLAUDE.md with just conventions and the glossary — costs
2.8× more than a bundle and has the answer less than half the time.
Reproduce it with make bench; the method is in internal/eval/bench.go.
That is what the tokenizer says. Inside real Claude Code sessions
(eval/session/, Sonnet, 10 tasks, same prompts) briefd cut the context
carried per turn by 35% and the cost per task by 40% with identical answers — at the price of
3–4 extra tool-call round trips per task. The saving grows with the size of your knowledge repo;
a static CLAUDE.md cannot.
Not another agent memory
Memory tools (agentmemory, Mem0, claude-mem) record what an agent observed in its sessions, automatically, per user. briefd serves what the team decided, written by people and reviewed like code. They answer different questions and run side by side.
Agent memory | briefd | |
Source of truth | A database the agent writes to | Markdown in a git repository |
Who writes | The agent, automatically | People; agents open pull requests |
Scope | One agent / one user | The whole team, every project in the domain |
Review | None | Every change has a diff, a reviewer and a name |
Staleness | Unknown | Dates on every section; drift against the code it governs |
What it can't answer | Silently absent | Listed on the dashboard as a backlog |
Footprint | Runtime + engine + several ports | One static binary, one SQLite file, one port (or stdio) |
Tool surface | Dozens of tools, thousands of tokens per session | 7 tools, ~2.8k tokens per session (+2 each if Jira or Confluence is configured) |
Use a memory tool so your agent remembers what it tried last week. Use briefd so every agent on the team applies the same rules — and so someone notices when a rule falls behind the code.
Related MCP server: flaiwheel
How it works
Git is the source of truth. The index is a disposable cache rebuilt from a clone.
Agents never write to the index.
propose_updateopens a reviewable branch/PR; what briefd serves changes only when a human merges.Hybrid retrieval, no external services. SQLite FTS5 (BM25) + multilingual embeddings (
multilingual-e5-small, 100+ languages) computed by a pure-Go encoder, fused with reciprocal rank fusion. No Postgres, no vector database, no ONNX runtime, no CGO.Hard token budgets. Every API that returns context takes
max_tokensand never exceeds it.
Quickstart
Try it in 30 seconds — no repository needed:
briefd demo # serves the built-in sample knowledge base on http://127.0.0.1:7788Then open the dashboard, or point an agent at it: claude mcp add --transport http briefd http://127.0.0.1:7788/mcp.
The first run downloads the embedding model (about 470 MB); briefd demo --embeddings none skips it.
With your own knowledge:
# 1. build (Go >= 1.26) or grab a binary from the releases page
git clone https://github.com/ismailperim/briefd && cd briefd && make build
# 2. serve the sample knowledge repo (downloads the 470 MB multilingual embedding model once)
./bin/briefd serve --source testdata/knowledge --db /tmp/briefd.db --token dev-token
# 3. connect Claude Code
claude mcp add --transport http briefd http://localhost:7788/mcp \
--header "Authorization: Bearer dev-token"Open http://localhost:7788/ for the dashboard, then ask Claude Code something the sample
corpus knows — "what's our retry policy for acquirer calls?" or "ters ibraz nedir?" — and
watch search_context / compile_bundle show up in the request log.
Any MCP client that speaks streamable HTTP works. For a project-level .mcp.json:
{
"mcpServers": {
"briefd": {
"type": "http",
"url": "http://localhost:7788/mcp",
"headers": { "Authorization": "Bearer dev-token" }
}
}
}Let the agent install it. Hand your coding agent one instruction:
Retrieve and follow the instructions at: https://raw.githubusercontent.com/ismailperim/briefd/main/INSTALL_FOR_AGENTS.md
Teach the agent when to ask. Tools an agent does not call save nothing. The
skills/briefd skill tells Claude Code (and any agent that reads
SKILL.md) when to compile a bundle, how to treat a stale section and when to propose an
update; the same guidance as a CLAUDE.md paragraph is in deploy/local/CLAUDE.md.
npx skills add ismailperim/briefdSingle-user, no server? briefd mcp speaks MCP over stdio — the same tools, the same
index, no port and no token. Claude Desktop, Cursor's stdio config and MCP directory
inspectors launch it directly:
{
"mcpServers": {
"briefd": {
"command": "briefd",
"args": ["mcp", "--source", "/path/to/knowledge", "--db", "~/.briefd/knowledge.db"]
}
}
}Every instance also serves /setup: a public page (no token needed, none shown) with
copy-ready, per-tool steps for Claude Code, GitHub Copilot (VS Code, CLI, JetBrains, Visual
Studio), Cursor, Codex, OpenCode, Gemini CLI, Windsurf / Devin and Claude Desktop, filled in
with the server's own URL. Send your team the link instead of a wiki page.
Use serve when a team shares one instance (dashboard, metrics, webhook, REST); use mcp
when the agent runs on the machine that holds the checkout.
Tools
Tool | What it does |
| One deduplicated context block within the budget, ordered domain → conventions → project, with a source line per section and a |
| Ranked sections that fit the budget, for inspection. |
| One document in full: readable content, plus the complete source file and its |
| Scopes with document/section counts. |
| Creates branch |
| Optional feedback: which sections helped. An empty list marks the question as a knowledge gap. |
| Links the knowledge base is missing (a document names another without linking it) and broken links — for an agent tidying the knowledge base via |
| Optional. Live Confluence Cloud search and page reads, converted to compact Markdown within the budget. Listed only when Confluence is configured; see below. |
| Optional. Live Jira Cloud issue search and issue reads (description, acceptance criteria, related issues, linked Confluence pages, comments) within the budget. Listed only when Jira is configured; see below. |
The same operations are available over REST (/api/search, POST /api/bundle, /api/docs/{path},
/api/scopes, POST /api/proposals, POST /api/proposals/{id}/close, POST /api/usage, /api/gaps, /api/health, /api/stats)
behind the same bearer token.
Your knowledge repo
briefd expects a git repository (or directory) of Markdown with three kinds of folders
(briefd init <dir> scaffolds it with example documents):
knowledge-repo/
├── domain/ # shared: terminology, business rules, ADRs
├── conventions/ # shared: coding standards, infra patterns
└── projects/
├── ledger-service/ # visible only when scope "projects/ledger-service" is requested
└── merchant-portal/Documents are split on ##/### headings into sections of roughly 200–800 tokens with stable
ids, so a section can be quoted on its own. Optional front matter adds metadata:
---
title: Retry policy # defaults to the first H1
tags: [payments, resilience]
refs: ["services/payment/**"] # code paths this doc governs
---testdata/knowledge/ is a complete example (a fictional payments
platform) and doubles as the evaluation corpus.
Obsidian vaults and links
A knowledge repository can be an Obsidian vault. briefd reads [[wikilinks]] in the text and in front-matter properties such as related: (including
[[note|alias]] and [[note#heading]]) and relative Markdown links, resolves them the way
Obsidian does (by path, or by file name anywhere in the repository), and builds a link graph:
the dashboard draws it, get_document returns each document's links and backlinks so an agent
can follow them, and orphans (nothing links here) and broken links (the target does not exist)
are listed as maintenance signals next to gaps and coverage. Folder scopes still apply —
domain/, conventions/, projects/<name>/ — so keep the vault's top level in that shape.
Running it for real
export BRIEFD_GIT_TOKEN=ghp_... # only for private HTTPS remotes
./bin/briefd serve --source https://github.com/your-org/knowledge.git --token "$(openssl rand -hex 16)"briefd clones the repository, follows the branch with fetch + hard reset every sync.interval
(default 60 s), or immediately when your forge calls POST /webhook/git with a GitHub-style
HMAC signature. Only changed files are re-parsed and re-embedded.
Languages. The default embedding model, multilingual-e5-small, covers 100+ languages,
so a Turkish, German or Japanese knowledge repo — or English docs queried in another language —
works out of the box. English-only teams can set embeddings.model: all-MiniLM-L6-v2 (87 MB,
~2.5× faster indexing). briefd model pull pre-fetches a model for offline or image-build use;
--embeddings none gives BM25-only mode; Ollama and OpenAI-compatible services are alternative
providers.
Docker
cd deploy
BRIEFD_SOURCE=https://github.com/your-org/knowledge.git BRIEFD_API_TOKEN=... docker compose upThe image is distroless and pure Go (~34 MB, linux/amd64 + arm64). Database, checkout and model
live in the briefd-data volume. Mount a directory and set BRIEFD_SOURCE=/knowledge to serve
local files instead.
Deployment guide: deploy/README.md covers Compose and systemd
setups, git forges (GitHub, GitLab, Azure DevOps, Bitbucket, SSH), installing the embedding model
offline, proxies and private CAs, exposure/security, upgrades and monitoring. For a laptop-only
setup see deploy/local/.
Configuration — briefd.yaml (see deploy/briefd.example.yaml)
or BRIEFD_* environment variables; flags override both. The ones you will actually touch:
Setting | Env | Default | Notes |
|
| — | git URL or directory |
|
| (none) | empty = unauthenticated (only on trusted networks) |
|
|
| |
|
|
|
|
|
| — | enables |
|
| — | HTTPS remotes; |
|
| — |
|
|
|
|
|
|
|
| or |
|
|
| |
|
|
| feeds the knowledge-gap report; |
| — | (none) | code repositories (URL or path) compared against documents' |
|
| (off) | live Confluence Cloud search tools; see below |
|
| (off) | live Jira Cloud tools and issue bundles; see below |
briefd model pull pre-fetches the embedding model for offline or image-build use.
Jira and Confluence (optional, live). Agents can read the team's Atlassian Cloud site through the same MCP endpoint: Confluence pages (ADR-0009) and Jira issues (ADR-0010). Configure either or both:
confluence:
base_url: https://your-site.atlassian.net # BRIEFD_CONFLUENCE_BASE_URL
spaces: [ENG, PAY] # BRIEFD_CONFLUENCE_SPACES; empty = every space the account sees
email: "" # BRIEFD_CONFLUENCE_EMAIL ┐ optional service account
token: "" # BRIEFD_CONFLUENCE_TOKEN ┘ (Atlassian API token)
user_credentials: true # callers may send their own account in headers
jira:
base_url: https://your-site.atlassian.net # BRIEFD_JIRA_BASE_URL
projects: [PAY] # BRIEFD_JIRA_PROJECTS; empty = every project the account sees
fields: [customfield_10035] # BRIEFD_JIRA_FIELDS; extra fields to include, e.g. acceptance criteria
# email / token: optional service account; empty = the Confluence one (same Atlassian account)
# scoped_token: true marks the service-account token as scoped (BRIEFD_JIRA_SCOPED_TOKEN)
atlassian:
cloud_id: "" # BRIEFD_ATLASSIAN_CLOUD_ID; only for scoped tokens, empty = looked upEach person can use their own Atlassian account, so they only see what Jira and Confluence let them see. One Atlassian API token works for both:
claude mcp add --transport http briefd https://briefd.example.com/mcp \
--header "Authorization: Bearer $BRIEFD_API_TOKEN" \
--header "X-Atlassian-Email: you@example.com" --header "X-Atlassian-Token: $ATLASSIAN_TOKEN"(The X-Confluence-Email / X-Confluence-Token headers from v0.7 still work, for Jira too.)
Scoped API tokens. Atlassian's API tokens with scopes are made for one product, so send one per
product instead of X-Atlassian-Token:
--header "X-Atlassian-Jira-Token: $ATLASSIAN_JIRA_TOKEN" --header "X-Atlassian-Confluence-Token: $ATLASSIAN_CONFLUENCE_TOKEN"
(with X-Atlassian-Email). briefd sends them through the Atlassian API gateway. Read-only scopes:
read:jira-work for Jira; search:confluence, read:page:confluence and read:space:confluence
for Confluence (ADR-0012). The dashboard's Instance page
shows each product's health: requests, failures, the last error and whether the site answers.
With Jira configured, an agent can start a ticket with one call: compile_bundle(issue: "PAY-123")
returns the issue (cut to at most a third of the budget) followed by the team rules its summary and
description retrieve, within the same max_tokens. Find a custom field's id (such as
"Acceptance criteria") in Jira under Settings → Issues → Custom fields, or from
/rest/api/3/field.
Results are read live with GET requests and never indexed or stored; the bundle cache and query log keep only the issue key. The reviewed knowledge base stays the source briefd compiles rules from. Data Center / Server are not supported yet.
Dashboard and metrics
GET / is a dashboard embedded in the binary (no build step, no external assets):
Overview — requests, tokens served and saved, index and sync; the knowledge graph with the documents agents were served in the last 24 hours stamped on it; the circulation list; and Needs attention, one line per maintenance signal, worst first.
Graph — every document and link, zoom and pan (mouse or keyboard), search. Documents are coloured and clustered by area — each folder under
domain/orconventions/(e.g.domain/payments,domain/lending), plus one for projects — with a filter per area (Alt-click to show only one) and a switch between all links, links within areas and links between them. Select a document to see its links, backlinks and how often it was served (#graph=<doc path>links straight to it).Maintenance — proposals awaiting review, knowledge gaps, documents behind the code, the oldest documents, links to fix (broken, over-linked — more than 12 outgoing links, usually a catch-all
related:list — missing, orphans) and code coverage.Activity — latency and volume per tool, the index by scope and the request log; counters persist across restarts and can be reset.
Instance — the running configuration (secrets shown only as set/unset), with Sync now and Rebuild index.
GET /metrics exposes the counters in Prometheus text format; GET /api/stats as JSON.
Knowledge gaps. Every search_context / compile_bundle call is logged with its retrieval
confidence (query_log, 30-day retention). The dashboard lists the questions of the last seven
days that the knowledge base did not answer — nothing matched, or the agent's report_usage said
no section helped — grouped by question and ranked by how often they were asked, plus the answered
questions whose top result barely stood out from the rest. That list is the backlog for whoever
maintains the repository; GET /api/gaps?days=7&limit=20 returns it as JSON.
Document age. Every section in a bundle carries the date its document last changed
(## path — heading (updated 2026-03-04), from git history, or the file mtime for a plain
directory), so an agent can weigh a rule by its age. The dashboard lists the documents that
changed longest ago — the ones to re-read first.
Behind the code. Give a document refs: ["services/payment/**"] in its front matter and
list the code repositories in code.repos; briefd follows their history (bare clones, never the
files) and counts the commits that touched a governed path after the document last changed.
The attribution line then reads (updated 2026-03-01; code changed since: 3 commits, last 2026-06-01), the dashboard lists the documents most behind, and briefd_documents_behind_code
is exported. The agent reading a stale rule is often the right one to fix it with
propose_update. Design in ADR-0007.
The same refs work the other way round: pass paths (the files the task touches) to
compile_bundle and the rules that govern them lead the bundle, and the dashboard's
Coverage panel lists the directories of each code repository that no document claims —
the knowledge base's blind spots (ADR-0008).
briefd does not index code itself; your agent's grep and LSP do that better.
Retrieval quality
Retrieval is measured, not assumed. make eval scores 47 English golden queries (keyword,
paraphrase, typo, mixed-language) over the sample corpus and 30 Turkish queries over a
Turkish corpus; CI fails if hybrid retrieval drops below eval/thresholds.yaml
or eval/thresholds-tr.yaml:
Mode | English R@5 | English R@10 | English MRR | Turkish R@5 | Turkish R@10 | Turkish MRR |
BM25 only | 0.681 | 0.755 | 0.591 | 0.733 | 0.767 | 0.602 |
Vector only | 0.830 | 0.936 | 0.771 | 0.950 | 1.000 | 0.832 |
Hybrid (default) | 0.830 | 0.926 | 0.746 | 0.933 | 1.000 | 0.847 |
On public BEIR datasets briefd's vector-only mode reproduces the published quality of both
embedding models and hybrid mode beats BM25 and vector-only on each — SciFact nDCG@10 0.714
vs 0.665 for the BEIR BM25 baseline; see eval/beir/ to reproduce.
Every change to chunking, embeddings or fusion ships with before/after numbers (ADR-0004 is an example).
CLI
briefd demo # serve the built-in sample knowledge base — try it in 30 seconds
briefd init # scaffold a knowledge repo (domain/, conventions/, projects/)
briefd serve # MCP over HTTP + REST + dashboard, for a shared instance
briefd mcp # MCP over stdio, for one agent on this machine (Claude Desktop, Cursor)
briefd index # index a directory into the database (--rebuild to start over)
briefd search # query like search_context does (--mode bm25|vector|hybrid, --json)
briefd model list # local embedding models and whether they are downloaded
briefd model pull # download a model (--model all-MiniLM-L6-v2 for the English one)
briefd eval # retrieval quality against the golden set
briefd bench # tokens per task: static CLAUDE.md vs compile_bundleStatus and roadmap
v0.1 is feature-complete; expect rough edges before 1.0. Planned next:
usage-driven relevance tuning from
report_usagecontradiction detection for proposals
a light Turkish stemmer for the BM25 side and glossary-alias query expansion
multiple knowledge repositories per instance
Read docs/ARCHITECTURE.md for a guided tour with diagrams. The full
specification is in SPEC.md; decisions are recorded in docs/adr/.
Contributing
Issues and pull requests are welcome — see CONTRIBUTING.md for the development setup, testing rules and conventions. Security issues: SECURITY.md.
License
Available Tools
7 toolscompile_bundleARead-onlyIdempotent
Compile what the team's knowledge base says about a task into one context block within a token budget. Call it once at the start of a task, before code that rules, conventions or past decisions could govern; describe the task in a sentence, not keywords. Sections are deduplicated, ordered domain → conventions → project, each with a source line (path, heading, last-updated date, and a note when the code it governs changed later). Read-only, deterministic, cached: same task, scopes and budget give the same bundle_id and content. Never exceeds max_tokens; a too-small budget truncates the top section with a marker. Afterwards, report which sections helped via report_usage.
Inputs: task_description (required), paths, scopes, max_tokens. Returns: budget, cached, scopes, tokens, +4 more
get_documentARead-onlyIdempotent
Return one knowledge document in full (title, tags, the complete source file with front matter, its content_hash, last-updated date, and the documents it links to and is linked from) by the doc_path given in search or bundle results. Use it when a section is not enough, to follow a link, or before proposing an update: to edit a document, change source and pass the full result to propose_update with base_content_hash = content_hash. Read-only; not-found for unknown paths, forbidden outside the requested scopes.
Inputs: doc_path (required), scopes. Returns: path, tags, links, scope, +7 more
list_scopesARead-onlyIdempotent
List the knowledge scopes this server holds — the shared 'domain' and 'conventions' scopes plus one 'projects/' per project — with document, section and token counts. Read-only, no input. Use it to discover the project scope to pass to search_context or compile_bundle; by default those search only the shared scopes.
Returns: scopes
propose_updateA
Propose a change to a knowledge document — fix an outdated rule, add a missing decision, create a document — for humans to review. Commits the complete new file to a git branch briefd/proposal- (and opens a pull request when a forge is configured); returns branch, commit and PR URL. Never changes what briefd serves until a human merges. Use it for knowledge that is wrong, stale ('code changed since' in bundles) or missing, not for scratch notes. To edit an existing document, call get_document, change its source and send the whole result with base_content_hash set to its content_hash; the call is refused if the file changed in the meantime or if the new content drops the front matter. Fails without a writable git source.
Inputs: doc_path (required), new_content (required), change_description (required), base_content_hash. Returns: branch, commit, pr_url, pushed, +1 more
report_usageAIdempotent
Record which sections of a compile_bundle result were actually useful for the task, by chunk_id. Optional, best called once after the task is done. An empty useful_chunk_ids list is meaningful: it marks the question as a knowledge gap for the people who maintain the repository. Stores feedback only; it does not change the current bundle or the ranking of this session.
Inputs: bundle_id (required), useful_chunk_ids (required). Returns: recorded
search_contextARead-onlyIdempotent
Search the team's knowledge base (domain rules, conventions, decisions, project notes) and return the most relevant sections, ranked, within a token budget. Use it to look something up or see what exists; use compile_bundle when you want one context block for a task. Read-only. Each section carries its path, heading, scope, score and last-updated date; results never exceed max_tokens and say how many sections the budget omitted.
Inputs: query (required), paths, top_k, scopes, +1 more. Returns: budget, chunks, scopes, omitted, +1 more
suggest_linksARead-onlyIdempotent
List links the knowledge base is missing: documents that mention another document by name without linking to it, and links whose target does not exist. Read-only. Use it when asked to tidy or connect the knowledge base, then fix the documents with propose_update (add [[wikilinks]] in the text or in a related: front-matter list). Suggestions a maintainer dismissed are left out.
Inputs: limit, doc_path. Returns: broken, missing
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Each tool has a clearly distinct role: discovery (list_scopes), lookup (search_context), full read (get_document), task-scoped context (compile_bundle), write (propose_update), hygiene (suggest_links) and feedback (report_usage). The only potentially adjacent pair, search_context vs compile_bundle, is explicitly separated as 'look something up' versus 'one context block for a task', and descriptions reinforce each other.
All seven names follow a consistent snake_case verb_noun pattern (report_usage, get_document, propose_update, compile_bundle, list_scopes, search_context, suggest_links). Verbs are distinct and meaningful, with no camelCase or noun-only outliers.
Seven tools is well-scoped for a knowledge-base server, covering the read/discover/write/feedback lifecycle without redundancy. Each tool earns its place and none feels like filler.
The surface covers the core lifecycle: scope discovery, search, full document read, bundle compilation, proposed edits/creation, link cleanup, and usage feedback. Minor gaps remain: no way to delete or archive a document, and no explicit list/browse of documents within a scope (only counts), so agents must go through search to enumerate content.
Maintenance
Related MCP Connectors
A shared, governed brain for AI agents: versioned context with approvals, local or hosted.
The context platform for AI agents: code search, team decisions, and grounded project context.
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
Git-backed platform for skills, tools, and context for AI agents
Related MCP Servers
- AlicenseNot gradedqualityDmaintenancePersistent codebase knowledge layer for AI agents. Pre-digests codebases into structured knowledge (symbols, dependency graphs, co-change patterns, architectural decisions) and serves via MCP. 28 languages, 14 tools, ~85% token reduction.22 npm10MIT
- AlicenseAqualityBmaintenanceSelf-hosted memory and governance layer for AI coding agents. 28 MCP tools with hybrid search, structured knowledge capture, behavioral nudges, and git-native storage. Zero cloud dependencies.306Business Source 1.1
- AlicenseNot gradedqualityBmaintenanceSelf-hosted AI Agent Memory + Code Intelligence Platform providing persistent memory, AST-aware code search, and quality enforcement via a single MCP endpoint.105MIT
- FlicenseNot gradedqualityBmaintenanceMCP server for Agent Context OS that compiles engineering docs into a knowledge graph, detects code drift, and serves token-budgeted context packs to AI coding agents via MCP.-