CodeGraph: A Local MCP Server That Cuts Claude Code Tool Calls by 94%

Why CodeGraph Is Surging Right Now

CodeGraph crossed 7,800 GitHub stars on May 20, 2026, picking up roughly 1,900 of those in a single day. That is a meaningful signal. When a developer tool spikes that fast, it usually means it is solving something that a lot of people have already noticed but have not had a clean solution for.

The problem CodeGraph is solving is one anyone who has used Claude Code or Cursor on a mid-size codebase will recognize immediately: AI coding agents are slow and expensive on large projects because they issue dozens of sequential file reads and symbol lookups to build context before they can do any useful work. CodeGraph short-circuits that pattern by pre-indexing your codebase into a local SQLite knowledge graph and exposing it as an MCP server that agents can query in a single tool call.

The repo's headline numbers - 94% fewer tool calls and 77% faster exploration - come from benchmarks the author ran on six real-world codebases, including the VS Code TypeScript source and the Swift compiler (25,874 files). These are not toy demos.

What CodeGraph Does

CodeGraph is a semantic code indexer. You run it once against your project, and it builds a graph of every symbol, function, class, import, and route in your codebase, stored locally in SQLite using the FTS5 full-text search engine. A file watcher keeps the index current as you edit.

The index is exposed over MCP using a set of focused tools:

• codegraph_search - find symbols by name
• codegraph_context - build task-relevant code context from a plain-English description
• codegraph_callers / codegraph_callees - trace call flow through the graph
• codegraph_impact - identify which files and tests a change would affect
• codegraph_node - fetch a symbol's full source and metadata
• codegraph_files - return the indexed file tree

When an agent asks "find where authentication is handled," CodeGraph returns entry points, related symbols, and code snippets in one response instead of requiring the agent to walk the filesystem manually across fifteen tool calls. The benchmark numbers reflect that. On the VS Code repo, a typical exploration that took 52 tool calls and 1 minute 37 seconds collapsed to 3 calls and 17 seconds with CodeGraph attached.

The project supports 19 languages - TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Swift, Kotlin, Dart, Svelte, Liquid, and Pascal/Delphi - and it recognizes routing patterns across 13 web frameworks, so it is not a language-specific niche tool.

Everything runs locally. No data leaves your machine. The only dependency is SQLite, with an optional better-sqlite3 binding for native performance. If that is not available, it falls back to a WASM build.

Install and Try It

CodeGraph supports Claude Code, Cursor, Codex CLI, and OpenCode. The fastest path for Claude Code users is the interactive installer:

npx @colbymchenry/codegraph

The installer auto-detects which agent you are using, puts codegraph on your PATH, and writes the MCP server config. For Claude Code, it adds the MCP entry to ~/.claude.json:

{
  "mcpServers": {
    "codegraph": {
      "type": "stdio",
      "command": "codegraph",
      "args": ["serve", "--mcp"]
    }
  }
}

Then initialize your project:

cd your-project
codegraph init -i

The -i flag runs interactive setup to configure which languages to index and which paths to exclude. After that, initial indexing runs automatically. For subsequent updates you can run codegraph sync for incremental updates, or let the watcher handle it automatically.

You need Node.js 18 or higher. The installer works on Windows, macOS, and Linux.

Who Should Use This

Claude Code and Cursor users working on large codebases. If you are on a fresh repo with 20 files, the overhead of maintaining an index is not worth it. But if you are working on anything with a meaningful symbol surface - a monorepo, a production backend, an open-source project with multiple modules - CodeGraph changes the economics of agentic sessions. Fewer tool calls means lower API costs and shorter wait times before the agent starts producing useful output.

Teams running agentic CI pipelines. CodeGraph's impact analysis (codegraph_impact) is particularly valuable here. Before a refactor, you can ask the agent to identify which tests are affected by a change to a specific function. That is the kind of targeted context that normally requires either a human's intuition or an agent burning dozens of tool calls to build up a picture manually.

Developers who care about privacy. The "100% local" constraint is not a limitation - it is a design decision. Your source code stays on your machine, which matters for proprietary codebases, client work, or anything you would not want passing through a third-party API.

Polyglot projects. Nineteen languages with framework-aware route detection means you do not need a different indexer for each tech stack in a mixed-language repo.

Relation to the DevDigest Ecosystem

CodeGraph fits cleanly into the MCP-native workflow that has been a recurring theme in the DevDigest content library. The MCP directory at mcp.developersdigest.tech tracks the tools that are actually changing how agents interact with codebases, and a local knowledge graph server with documented benchmarks is exactly that category of tool.

The broader pattern CodeGraph represents is worth naming: agent performance is a function of context quality, not just model capability. A well-configured MCP layer that returns precise, pre-structured context will outperform a more powerful model operating on raw filesystem access. CodeGraph is a concrete implementation of that principle, and the benchmark data backs it up.

This also connects to the skills and hooks patterns covered in the DevDigest Claude Code content. A well-indexed codebase changes what is feasible in a single agentic session - you can ask for more ambitious refactors, broader impact analysis, and cross-cutting changes without hitting context or cost walls.

Honest Assessment

The benchmark results are compelling, but the methodology matters. The author tested six codebases, which is a reasonable sample but not a comprehensive one. Results will vary based on codebase structure, language mix, and the nature of the task. Exploratory symbol search benefits most; tasks that require reading full file contents may see smaller gains.

The initial indexing step adds setup friction. For teams or solo devs who jump between many short-lived projects, maintaining the index per project could feel like overhead. The file watcher mitigates this for active projects, but cold-start cost is real.

The project is relatively new. At roughly 7,800 stars it has community traction, but the MCP tooling surface is still evolving - the tool names and parameters may change as the project matures. Worth pinning a version if you are integrating this into a CI pipeline.

On balance, this is one of the more practically motivated MCP tools to emerge recently. The problem is real, the approach is principled, and the numbers are verifiable against real repositories. Worth adding to a Claude Code setup and running for a week before making a firm judgment.

References

• CodeGraph GitHub Repository
• npm package: @colbymchenry/codegraph
• MCP (Model Context Protocol) specification
• DevDigest MCP directory
• GitHub Trending - May 20, 2026