CodeGraph: The Code Knowledge Graph That Cuts AI Agent Token Costs by 35%

A Code Index That Pays for Itself in Tokens

If you use Claude Code or Cursor on a large project, you have probably watched an agent burn through thousands of tokens doing nothing but grep-ing for a function name or find-ing an import path. That redundant file scanning is invisible overhead - you pay for it on every task, every session, every day.

CodeGraph, created by Colby McHenry, addresses this directly. It appeared on GitHub's daily trending list today and has been on the weekly chart all week, sitting at roughly 12,000 stars. The repo describes itself as "pre-indexed code knowledge graph for Claude Code, Codex, Cursor, and OpenCode - fewer tokens, fewer tool calls, 100% local." Those are marketing-friendly words, but the project backs them up with benchmark numbers across seven real-world open-source codebases, which is unusual enough to be worth a close look.

What CodeGraph Actually Does

At its core, CodeGraph parses your project with tree-sitter, builds an abstract syntax tree for every file, and stores the resulting symbol graph in a local SQLite database at .codegraph/codegraph.db. The database tracks functions, classes, imports, call sites, and inheritance relationships. A full-text search layer via SQLite's FTS5 extension sits on top.

When an AI agent needs to understand your codebase - say, "find every caller of UserService.authenticate" - instead of dispatching a chain of shell tools, it queries the SQLite graph directly through a set of MCP tools that CodeGraph exposes. The graph already knows the answers.

The four-stage pipeline is:

1. Extraction - tree-sitter parses source files and language-specific queries identify nodes (functions, classes) and edges (calls, imports, inheritance).
2. Storage - results populate the local SQLite database with FTS5 for full-text search.
3. Resolution - references are resolved to definitions: a call site maps to the function body, an import maps to the source file.
4. Auto-sync - native OS file watchers (FSEvents on macOS, inotify on Linux, ReadDirectoryChangesW on Windows) detect file changes and incrementally update the graph with a 2-second debounce.

CodeGraph supports 19 languages (TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Swift, Kotlin, Scala, Dart, Svelte, Vue, Liquid, and Pascal/Delphi) and is framework-aware for 13 routing systems including Django, FastAPI, Express, NestJS, Rails, and Spring.

The MCP server exposes seven tools: codegraph_search, codegraph_context, codegraph_callers, codegraph_callees, codegraph_impact, codegraph_node, and codegraph_files. These replace most of the exploratory grep/find/read chains that inflate agent costs.

Install and Try It

The fastest path is the interactive installer, which auto-configures whichever agent you use:

npx @colbymchenry/codegraph

That command detects Claude Code, Cursor, Codex CLI, and opencode and writes the MCP configuration for you. If you prefer a global install:

npm install -g @colbymchenry/codegraph

Then initialize your project:

cd your-project
codegraph init -i

The -i flag runs interactive mode and lets you pick languages and exclusion patterns. After init, the first codegraph index pass builds the full graph. Subsequent syncs are incremental. Check the status with:

codegraph status

For Claude Code specifically, the installer writes to your .claude/mcp.json so the seven graph tools are available immediately in your next session. You can also drive the graph from Node.js directly - the library API exposes init, indexAll, searchNodes, getCallers, buildContext, and watch.

Who Should Use It

Developers on large TypeScript or Python monorepos get the biggest return. The VS Code benchmark (10,000+ files) showed 73% fewer tokens and 72% fewer tool calls versus unassisted Claude Code. At that scale, the graph pays for its own initialization time within the first few agent tasks.

Teams with tight AI API budgets benefit from the 35% average cost reduction across the seven tested codebases. On a project where Claude Code runs dozens of tasks per day, that compounds fast.

Rust and Go developers see even steeper savings - the Tokio (Rust, ~700 files) benchmark showed 52% cheaper and 81% fewer tokens, likely because the call graph is denser and harder for an agent to reconstruct from scratch on each query.

Developers who care about data privacy will appreciate that the entire system is local. No telemetry, no cloud upload, no API key. The SQLite file stays on your machine.

Less useful for: small projects under a few hundred files (the overhead of initialization may outweigh the savings), or projects with a single dominant language that agents already handle efficiently with their built-in file tools.

How This Fits the DevDigest Ecosystem

DevDigest has covered the MCP ecosystem extensively. CodeGraph is a clean example of the pattern where a local MCP server - rather than a hosted API - augments an agent's native capabilities without adding network latency or privacy risk.

If you use the Claude Code skills and hooks documented at clis.developersdigest.tech, CodeGraph slots in naturally alongside them. The MCP tools it exposes (codegraph_impact, codegraph_context) are particularly useful in pre-task hooks that gather codebase context before an agent begins work - a pattern that reduces hallucinated file paths and phantom function names.

The project also connects to the broader "agent-native tooling" category: rather than wrapping an existing GUI tool in a shim, it was designed from the start for agents as the primary consumer. The CLI commands exist for humans, but the MCP server is the first-class interface.

Honest Assessment

The benchmark numbers are credible because they come from real open-source projects with known file counts and are reproducible. The methodology is not fully peer-reviewed, but the author published per-project breakdowns rather than cherry-picking a best case.

Genuine strengths: zero-dependency local setup, broad language support, framework-aware routing, and an MIT license with no usage restrictions.

Real limitations worth knowing before you adopt it:

• The native SQLite bindings (better-sqlite3) are optional. Without them, a WASM fallback activates that runs 5-10x slower and can cause database locks during concurrent indexing and MCP queries.
• Files over 1MB are silently skipped during indexing (configurable via maxFileSize).
• The project is young - 12,000 stars is impressive velocity, but the API surface may shift before a stable 1.0 release.
• Dynamic or generated code (build outputs, migration files) can pollute the graph if exclusion patterns are not set carefully.

If you are already running Claude Code on a mid-to-large project and paying real token costs, CodeGraph is a low-risk experiment. The npx path takes under two minutes to evaluate, and the graph stays local if you decide not to keep it.

References

• CodeGraph GitHub repository: https://github.com/colbymchenry/codegraph
• tree-sitter parsing library: https://tree-sitter.github.io/tree-sitter/
• SQLite FTS5 documentation: https://www.sqlite.org/fts5.html
• Claude Code MCP integration docs: https://docs.anthropic.com/en/docs/claude-code/mcp
• npm package: https://www.npmjs.com/package/@colbymchenry/codegraph