codebase-memory-mcp: Code Intelligence for AI Agents
DeusData/codebase-memory-mcpcodebase-memory-mcp is a code intelligence MCP server, written in C, that indexes a codebase into a persistent knowledge graph of functions, classes, and call chains. Once indexed, your coding agent runs structural queries — trace this call path, find dead code, show the architecture — instead of grepping file by file. The README reports full-indexing an average repo in milliseconds and the Linux kernel in about three minutes, with sub-millisecond graph queries.
Reach for codebase-memory-mcp if your AI agent keeps burning tokens grepping a large codebase and you want it to query structure — call graphs, dead code, architecture — from a local graph instead. The token savings are real when one graph query replaces dozens of read/grep cycles. Skip it if your repo is small enough that plain file reads are fine, or if you're wary of a marketing-heavy README whose headline numbers (99% fewer tokens, 158 languages) you can't independently verify yet. It ships as one static binary with no runtime deps, so trying it is cheap.
The problem it solves
AI coding agents explore unfamiliar code the slow way: read a file, grep for a symbol, read another file, repeat. On a large repo that burns thousands of tokens and still misses cross-file call chains. The agent has no persistent model of how the code fits together, so every session re-discovers the same structure from scratch.
What is it?
codebase-memory-mcp is an open-source (MIT) code intelligence MCP server that turns a codebase into a queryable knowledge graph for AI coding agents. Written in C and shipped as a single static binary, it uses tree-sitter to parse code across many languages — the README claims 158 — plus a 'Hybrid LSP' type-resolution layer for about a dozen, including Python, TypeScript, Go, Java, and Rust. It stores the graph in SQLite and exposes 14 MCP tools for search, call tracing, impact analysis, and Cypher-like queries. There's no built-in LLM — your MCP client (Claude Code, Cursor, and others) is the intelligence layer.
Why it's getting attention
Giving AI agents a cheap, structural view of a codebase is an active problem, and this one attacks it with an unusual stack: pure C, vendored tree-sitter grammars, in-memory SQLite, and bundled embeddings compiled into the binary — no Docker, no API keys, no Ollama. The README pairs that with an arXiv preprint and aggressive benchmark numbers, and it auto-configures across 11 coding agents from one install command, which lowers the bar to trying it.
Key features
- ✓Persistent knowledge graph: indexes functions, classes, call chains, HTTP routes, and cross-service links into SQLite that survives across sessions
- ✓14 MCP tools including call-path tracing, dead-code detection, impact analysis on git diffs, and Cypher-like graph queries
- ✓tree-sitter parsing the README puts at 158 languages, with a Hybrid LSP type-resolution layer for about 12 including Python, TypeScript, Go, Java, and Rust
- ✓Semantic search over the graph via bundled nomic-embed-code embeddings compiled into the binary — no API key or external model server
- ✓Single static binary for macOS, Linux, and Windows with zero runtime dependencies; one install command auto-configures 11 coding agents
- ✓Team-shared graph artifact: a zstd-compressed graph.db.zst you can commit so teammates skip the full reindex
- ✓Optional 3D graph visualization UI at localhost:9749 in a separate build variant
Best use cases
- •Letting a coding agent trace who calls a function across files before you change it
- •Finding dead code — functions with zero callers — across a large repo
- •Mapping the blast radius of an uncommitted git diff to the symbols it affects
- •Giving an agent an architecture overview (languages, entry points, routes, hotspots) in one call instead of many file reads
- •Cutting token spend on repeated codebase exploration in long agent sessions
How to install / try
codebase-memory-mcp ships as a single static binary. On macOS or Linux the README's one-line install is `curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash` (add `-s -- --ui` for the graph UI). On Windows you download `install.ps1`, `Unblock-File` it, and run it. It's also on npm, PyPI, Homebrew, Scoop, Winget, Chocolatey, and the AUR. The `install` command auto-detects your coding agents and writes their MCP config, so after a restart you just say 'Index this project'.
How to use
After install, restart your agent and index the repo — the README's example is telling the agent 'Index this project.' From then on the agent calls the MCP tools: `trace_path` to follow a call chain, `search_graph` for structural name patterns, `get_architecture` for an overview, or `detect_changes` to map a git diff. There's also a CLI mode, e.g. `codebase-memory-mcp cli search_graph '{"project":"my-project","name_pattern":".*Handler.*"}'`, and an opt-in `auto_index` so new projects index on first connection.
Strengths
- ✓One static binary, no Docker, no API keys, no runtime deps — genuinely low setup friction
- ✓Runs 100% locally and the README states it collects no telemetry, so code never leaves your machine
- ✓Replaces many grep/read cycles with a single graph query, which is where the token savings come from
- ✓One install command configures MCP entries and hooks across 11 agents, so you're not hand-editing configs
- ✓MIT-licensed, and the design is backed by an arXiv preprint the README links
Limitations & risks
- △The README is heavy on marketing, and its headline numbers (99% fewer tokens, 83% answer quality, 158 languages) come from the authors' own preprint — treat them as vendor benchmarks, not independent results
- △Written in C and distributed as prebuilt binaries; on Windows SmartScreen flags it as unsigned, so you're trusting the signed checksums and antivirus scans the README points to
- △No built-in LLM by design — it's only as good as the MCP client driving it, and a weak agent won't ask the right graph queries
- △It writes to your agent config files and pre-tool hooks during install, which is more invasive than a plain MCP server registration
- △Hybrid LSP type resolution covers only about 12 languages; the other 140-plus rely on tree-sitter parsing alone, so cross-file resolution is weaker there
Alternatives
Who should try it — and who should skip
Developers who run AI coding agents against large or unfamiliar repositories and watch them burn tokens re-exploring the same structure. If you work in a monorepo or a codebase big enough that file-by-file grep is painful, a queryable graph earns its keep. If your project is small, or you'd rather not run a prebuilt binary that edits your agent config, the payoff is thinner.
Frequently asked questions
codebase-memory-mcp is a code intelligence MCP server written in C that indexes a codebase into a persistent knowledge graph. AI coding agents then query that graph — call paths, dead code, architecture — instead of reading files one by one.
The README states it runs 100% locally and collects no telemetry, so your code, queries, and usage stay on your machine. The graph is stored in SQLite under your cache directory.
The README puts tree-sitter parsing at 158 languages, with a deeper Hybrid LSP type-resolution layer for about 12 — including Python, TypeScript/JavaScript, Go, C, C++, Java, Kotlin, Rust, PHP, C#, and Perl.
File access makes the agent grep and read repeatedly; the README reports five structural graph queries used about 3,400 tokens versus roughly 412,000 for file-by-file search. The graph also resolves cross-file call chains that grep misses.
No. It has no built-in LLM and bundles its embeddings into the binary, so there's no API key, Ollama, or Docker to configure — your MCP client is the intelligence layer.