If you've spent real time pairing with Claude Code, Cursor, or Codex on a mid-to-large repository, you've probably hit the same wall I did: the agent keeps re-reading files it already saw an hour ago, burns half your context window on a routine PR review, and still misses the one caller three modules away that actually breaks. That's not a prompting problem - it's an architecture problem. LLMs are stateless, and grep-based exploration doesn't scale past a few hundred files.
Over the last few months, a new category of tooling has emerged to fix exactly this: local, persistent code knowledge graphs exposed over the Model Context Protocol (MCP). Instead of your AI assistant re-reading the whole repo on every task, these tools parse your codebase once with Tree-sitter (and sometimes LSP-grade type resolution), store it as a queryable graph, and hand your agent a structural map - callers, dependents, blast radius, architecture - in a single tool call.
I dug into three of the most relevant open-source projects in this space: code-review-graph, Graphify, and codebase-memory-mcp - GitHub stars, architecture differences, benchmark numbers, and which one actually fits your stack.
Why This Matters
Every one of these tools solves the same underlying problem in a slightly different way: an AI coding agent asked "what calls ProcessOrder?" or "what's the blast radius of this change?" shouldn't have to grep-and-read its way through your entire repository. A pre-built graph of functions, classes, imports, and call chains answers that in a single, cheap query instead of dozens of expensive file reads.
The payoff shows up directly in your API bill and your context budget - for a React/Node monorepo doing daily PR reviews, that's the difference between a review that costs a few thousand tokens and one that quietly eats your whole context window.
Quick Comparison
| code-review-graph | Graphify | codebase-memory-mcp | |
|---|---|---|---|
| GitHub Stars | ~16k ⭐ | ~75.2k ⭐ | ~22k ⭐ |
| Forks | 1.8k | 7.5k | 1.6k |
| Primary Language | Python | Python | C (pure, zero deps) |
| License | MIT | MIT | MIT |
| Install | pip install code-review-graph |
uv tool install graphifyy |
Single static binary (curl installer) |
| Language Coverage | 24 languages + Jupyter | 36 tree-sitter grammars + docs/PDF/images/video | 158 languages (vendored grammars) |
| Core Differentiator | Blast-radius analysis for PR review | Multi-modal graph (code + docs + papers + meetings) | Hybrid LSP-grade type resolution, extreme indexing speed |
| Token Reduction (claimed) | 8.2x average (up to 49x on monorepos) | ~71.5x reported by third-party benchmark | ~120x (99.2% reduction) |
| MCP Tools Exposed | 28 | Served via python -m graphify.serve
|
14 |
| Backed By | Independent maintainer | Y Combinator (S26 batch) | DeusData |
(Star counts move fast in this category - check each repo live before you quote them elsewhere.)
code-review-graph
GitHub: tirth8205/code-review-graph - ~16k ⭐, 1.8k forks, MIT
The most review-focused of the three. It builds a structural map of your code with Tree-sitter, storing nodes (functions, classes, imports) and edges (calls, inheritance, test coverage) in a local SQLite database under .code-review-graph/. Its signature feature is blast-radius analysis: when a file changes, the graph traces every caller, dependent, and test that could be affected, so your AI assistant reviews only the files that actually matter instead of the whole diff's neighborhood.
For React/Node developers specifically:
- One command (
code-review-graph install) auto-detects and configures Claude Code, Cursor, Codex, Windsurf, Zed, GitHub Copilot, and more. - Covers the full JS/TS stack - JavaScript, TypeScript, TSX, Vue, Svelte - alongside Python, Go, Rust, Java, and 24 languages total.
- On a 27,700+ file Next.js monorepo, the graph funneled review context down to roughly 15 files.
- Ships 28 MCP tools, including hub/bridge detection (architectural chokepoints) and auto-generated review questions - useful for onboarding onto an unfamiliar codebase, not just reviewing diffs.
Worth knowing before install: the project's own benchmarks are honest about limits - small single-file changes can see structural metadata exceed a raw file read, and flow detection currently favors Python frameworks over JS/Go.
pip install code-review-graph
code-review-graph install
code-review-graph build
Graphify
GitHub: safishamsi/graphify — ~75.2k ⭐, 7.5k forks, MIT, Y Combinator S26
The biggest project of the three by a wide margin, and it plays a different game. Where the other two are scoped to "index my code," Graphify's pitch is any input, one graph: point it at a folder and it pulls source code (36 tree-sitter grammars), SQL schemas, Terraform/HCL, Markdown, PDFs, Office docs, and even video/meeting transcripts into a single queryable NetworkX graph with Leiden community clustering.
What stands out:
- Invoked as a slash command (
/graphify .) inside 20+ AI coding assistants — Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Kilo Code, Aider — rather than requiring a persistent server. - Output is genuinely inspectable:
graph.html(interactive visualization),GRAPH_REPORT.md(god-nodes, cross-module connections, suggested questions), andgraph.json. - Supports pushing to Neo4j or FalkorDB, exporting Obsidian vaults, and a global cross-project graph for multi-repo orgs.
- Also exposes an MCP server for teams who want persistent tool-call access instead of the slash-command flow.
Trade-off: the sheer surface area means non-code extraction depends on an LLM API call for semantic relationships — code-only graphs are fully local and free, but docs/PDFs/images route through your assistant's model API unless you point it at a local Ollama backend.
uv tool install graphifyy
graphify install
# then inside your AI assistant:
/graphify .
codebase-memory-mcp
GitHub: DeusData/codebase-memory-mcp — ~22k ⭐, 1.6k forks, MIT
The odd one out architecturally, in a good way: written in pure C, ships as a single static binary with zero runtime dependencies, and built for raw indexing speed. The headline number is stark - it indexed the Linux kernel (28M LOC, 75,000 files) in about 3 minutes, producing 4.81M nodes and 7.72M edges, with sub-millisecond query latency afterward.
What sets it apart:
- 158 vendored tree-sitter grammars compiled directly into the binary - nothing to install, nothing that breaks on a fresh machine.
- Hybrid LSP semantic type resolution for Python, TypeScript/JavaScript/JSX/TSX, PHP, C#, Go, C/C++, Java, Kotlin, and Rust - refines call edges with actual type information rather than stopping at syntax.
- Documented in a research preprint (arXiv:2603.27277), evaluated across 31 real-world repositories: 83% answer quality, 10x fewer tokens, 2.1x fewer tool calls versus file-by-file exploration.
- Cross-service linking for backend/microservices teams - detects HTTP, gRPC, GraphQL, tRPC call sites, and pub-sub patterns across 8 languages.
- A team-shared graph artifact can be committed to the repo so teammates skip a full reindex on clone.
- Every release is SLSA Level 3 attested and Sigstore-signed - a level of supply-chain rigor the other two don't advertise.
Trade-off: no built-in LLM - it's a structural backend that relies entirely on your MCP client to translate natural language into graph queries, and Windows support currently needs WSL2 for building from source.
curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash
# then in your agent:
"Index this project"
Head-to-Head
Token efficiency: all three publish impressive numbers, but they're measuring slightly different things. code-review-graph's 8.2x is an average including worst cases (small diffs can dip below 1x); Graphify's ~71.5x and codebase-memory-mcp's ~120x are best-case structural queries against an already-built graph. Treat them as directionally useful, not directly comparable.
Language coverage: if your stack is primarily JavaScript/TypeScript/React/Node, all three cover it well, but codebase-memory-mcp's Hybrid LSP layer gives noticeably richer type resolution for TS/JSX than pure Tree-sitter parsing alone. Graphify wins if your repo also includes Terraform, SQL schemas, or architecture docs you want in the same graph as the code.
Architecture philosophy: code-review-graph optimizes for the PR review loop specifically. Graphify optimizes for breadth of input (code + everything else). codebase-memory-mcp optimizes for raw performance and correctness at scale.
Best of the Best - Which One Should You Actually Install
- Heavy PR review on a React/Node/TypeScript monorepo → code-review-graph. The blast-radius model and monorepo funnel are purpose-built for this, and install auto-detects Cursor/Claude Code/Copilot with no manual config.
- One graph spanning code, architecture docs, RFCs, and meeting notes → Graphify. Multi-modal ingestion and Obsidian/Neo4j export are unmatched among the three.
- Large, polyglot, performance-sensitive codebase (microservices, enterprise monorepo) → codebase-memory-mcp. Zero dependencies, sub-millisecond queries, and Hybrid LSP-grade accuracy make it the most "production infrastructure" feeling of the three.
They're not mutually exclusive - several teams run code-review-graph for the PR workflow and codebase-memory-mcp as the always-on structural backend, since neither one gatekeeps the other's MCP tools.
Other Similar Tools Worth Knowing About
- Sourcegraph Cody - commercial code-intelligence and search platform, more IDE/enterprise-oriented than a pure MCP server.
- Aider's repo map - a lighter-weight, built-in Tree-sitter-based repo summarization feature inside the Aider CLI.
- Cursor's built-in codebase indexing - proprietary, cloud-assisted embedding index baked into the Cursor IDE, convenient but not portable across other agents.
- GitHub Copilot workspace context - GitHub's own evolving context system for Copilot, tightly coupled to the GitHub ecosystem.
FAQ
Are these tools free and open-source?
Yes - all three are MIT-licensed. Graphify's parent, graphifylabs.ai, layers an optional paid enterprise tier (unlimited scale, team graphs, SSO) on top of the open-source core; the other two have no paid tier as of writing.
Do these tools send my code to the cloud?
All three are local-first for code parsing - Tree-sitter/AST extraction runs on your machine, no API calls. Graphify's non-code ingestion (docs, PDFs, images, video) does route through your configured LLM backend unless you point it at a local Ollama instance.
Which works best with Claude Code specifically?
All three ship first-class Claude Code integration. code-review-graph and codebase-memory-mcp both install hooks that nudge Claude Code toward graph queries instead of Grep/Glob; Graphify uses a /graphify slash-command plus an optional MCP server.
Do I need to pick just one?
No - they expose different MCP tool names and don't conflict.
Final Verdict
If you're optimizing an AI-assisted workflow around a JavaScript/React/Node stack, my honest recommendation is to start with code-review-graph for the PR review loop, and evaluate codebase-memory-mcp if you outgrow it on a larger, more polyglot codebase where indexing speed and type-aware resolution start to matter. Graphify earns its spot if your team's real pain point is scattered documentation and tribal knowledge, not just source code.
All three are moving fast, all three are MIT-licensed, and all three solve something generic RAG and grep-based context can't: giving your AI coding agent a persistent, structural memory of your codebase instead of making it rediscover your architecture every session.
Checkout Full Blog - https://www.saurabhsharma.dev/blogs/code-graph-mcp-tools-comparison
Top comments (0)