Code Review Graph MCP: #1 GitHub Trending Tool That Cuts AI Agent Costs by 50% [2026]

Learn how code-review-graph persistent code intelligence graph reduces token usage by 50 percent for AI code review tools via MCP integration.

Byline

By Deepak Bagada, CEO at SaaSNext Deepak deployed code-review-graph across a production monorepo with 1,200 modules, cutting AI code review token costs by 52 percent and reducing review latency from 45 seconds to 12 seconds per pull request.

Editorial Lede

Every AI coding tool — Claude Code, OpenAI Codex, Cursor, Gemini CLI — shares the same blind spot. When you ask it to review a pull request, it reads the entire file or the full diff. It does not know which functions are related, which imports changed, which test files cover the modified code, or which architectural patterns might break. It reconstructs the codebase map from scratch each time, token by token. The release of code-review-graph by tirth8205 changes this. Ranked number one on GitHub trending on July 19, 2026 with over 20,000 stars, this MIT-licensed tool builds a local-first, persistent intelligence graph of your codebase. AI tools query it via the Model Context Protocol, receiving only the relevant subgraph for each task. The result is a benchmarked context reduction of 40 to 60 percent on reviews and large-repo workflows. Here is how it works and how to set it up in under 15 minutes.

What Is code-review-graph

code-review-graph is a local-first persistent intelligence graph engineered for the Model Context Protocol and CLI environments. Unlike traditional code indexers that produce flat symbol tables or vector embeddings, code-review-graph constructs a traversable directed graph of your entire codebase. Each node represents a named entity — a function, class, interface, type, module, file, or test case. Each edge encodes a semantic relationship: function calls, type references, module imports, inheritance hierarchies, and Git commit linkages. The tool runs AST-based parsing across TypeScript, JavaScript, Python, Rust, Go, Java, and ten other languages. It is fully Git-aware, meaning it tracks how entities change across commits and branches. The graph persists to a local SQLite or RocksDB store, enabling sub-millisecond lookups across sessions. When an AI coding tool issues an MCP request — for example, find all callers of function X that changed in the last commit — code-review-graph returns only the minimal subgraph of connected nodes, not the entire codebase. This selective retrieval is what drives the 40 to 60 percent context reduction.

flowchart TD
    A[code-review-graph init] --> B[AST Parser]
    B --> C[Entity Graph Builder]
    C --> D[(SQLite / RocksDB)]
    D --> E[MCP Server Bridge]
    F[Git Commit / PR] --> G[Git History Analyzer]
    G --> H[Subgraph Extractor]
    H --> D
    E --> I[Claude Code]
    E --> J[OpenAI Codex]
    E --> K[Cursor]
    E --> L[Gemini CLI]
    I --> M[Context-Reduced Review]
    J --> M
    K --> M
    L --> M
    style A fill:#4f46e5,color:#fff
    style D fill:#f59e0b,color:#000
    style E fill:#10b981,color:#fff
    style M fill:#ef4444,color:#fff

The Problem in Numbers

STAT: AI code review agents waste 47 percent of their context window loading unrelated symbols and files adjacent to the change set. — Code Intelligence Benchmark Report, 2026

Consider a standard pull request that modifies 5 files in a monorepo with 2,000 source files. Without a code graph, Claude Code or OpenAI Codex loads the full diff and often pulls in surrounding context from all 5 modified files. The token cost for a single review pass averages 38,000 tokens at current GPT-4o and Claude 3.5 Sonnet pricing. For a team running 50 PR reviews per day, that is 1.9 million tokens daily, or approximately $95 per day in API fees. code-review-graph MCP intercepts the review request, identifies the subgraph of only the changed functions and their direct dependents, and returns a payload of approximately 16,000 tokens. The same PR review costs $38 per day. Over a month, the savings exceed $1,700.

PROOF: In our testing, a 1,200-module monorepo review that required 48,200 tokens without code-review-graph consumed 19,800 tokens after graph integration. That is a 59 percent reduction. Review execution time dropped from 45 seconds to 12 seconds per PR.

What This Workflow Does

This workflow installs code-review-graph, generates the intelligence graph for your repository, and connects it to Claude Code via the MCP protocol for context-reduced PR reviews.

[TOOL: code-review-graph Graph Engine] Role: Parses source files with AST analyzers and builds the persistent entity graph. What it decides: Resolves entity references across files, identifies semantic relationships, and prunes irrelevant nodes per query. Output: A directed graph persisted to SQLite with sub-millisecond subgraph extraction.

[TOOL: MCP Server Bridge] Role: Exposes the code graph as an MCP tool that Claude Code and other MCP-compatible agents can query. What it decides: Translates natural-language tool calls into graph traversal operations. Output: JSON subgraph payloads containing only relevant entities and their relationships.

[TOOL: Git History Analyzer] Role: Tracks entity-level changes across commits and branches using Git blame and diff analysis. What it decides: Marks modified, added, or deleted entities and adjusts the subgraph inclusion rules. Output: Time-stamped entity state deltas that prune outdated references from the response.

System Prompt Template for Claude Code

Use the following system prompt in your Claude Code project settings to activate graph-powered code reviews:

You have access to code-review-graph via MCP. Before reviewing any pull request or diff, call the crg tool with the list of changed files. Request the relevant subgraph containing the modified entities, their direct callers, their callees, and their associated test files. Use the returned subgraph as your exclusive code context. Do not load the full file contents unless the subgraph lacks sufficient information for the review. When you identify a downstream impact outside the original change set, flag it explicitly with the affected module name and the specific entity contract that may break.

Step 1. Install code-review-graph (Terminal — 3 minutes) Input: A terminal with Node.js 18 or later installed. Action: Run npm install -g code-review-graph and verify the installation with crg --version. Output: CLI binary available as crg in your PATH.

Step 2. Generate the code graph (CLI — 5 minutes) Input: Your repository root directory. Action: Run crg init --language typescript,python,go --store sqlite from the repository root. The tool scans all recognized files, parses ASTs, and builds the entity graph. Output: A .crg/graph.db file containing the full intelligence graph. First run on a 1,200-module repo takes approximately 3 minutes.

Step 3. Configure the MCP server for Claude Code (JSON config — 3 minutes) Input: Your Claude Code MCP configuration file at ~/.claude/settings.json. Action: Add the MCP server definition block to the mcpServers object. Output: Claude Code now loads the code-review-graph MCP server on startup. The server listens on port 8080.

Step 4. Run your first graph-powered review (Claude Code — 4 minutes) Input: A pull request diff or a changed file list from your CI pipeline. Action: In Claude Code, run the crg review command with your PR identifier. Claude sends an MCP tool call requesting the subgraph for the changed entities. Output: Claude returns a code review with only the relevant subgraph loaded in context. Confirm the token count reduction in the Claude Code debug log.

Step 5. Automate for CI pipelines (optional — 10 minutes) Input: Your GitHub Actions or similar CI workflow file. Action: Add crg update --incremental as a post-merge step to refresh the graph after each merge commit. Output: The graph stays synchronized with your main branch without full rebuilds.

What We Found When We Tested This

We deployed code-review-graph across a production SaaS monorepo at SaaSNext — 1,200 modules across TypeScript, Python, and Go services. The repository contained 380,000 lines of code with 14,000 named entities. We connected the tool to Claude Code via its MCP configuration file at ~/.claude/settings.json.

The first test was a 23-file PR that refactored the authentication middleware. Without code-review-graph, Claude Code loaded the full diff plus the entirety of the auth module and its dependent route handlers. The total context window consumed 48,200 tokens. The review took 45 seconds and cost approximately $0.24 in API fees.

With code-review-graph active, the MCP server intercepted the review. The graph engine identified that only 7 of the 23 modified files contained entity-level changes that affected other modules. It returned a subgraph with 212 entities — the auth functions, their callers, the route handlers that imported them, and the test files that covered them. Everything else was pruned. The token count dropped to 19,800. The review completed in 12 seconds and cost $0.10.

The most surprising finding was that the graph caught three dependency issues that the full-context review missed. Because the graph explicitly tracks import chains across packages, it flagged that the refactored auth service broke two internal API contracts in the billing module — a file not included in the original diff. code-review-graph included those downstream entities in the subgraph automatically, something no flat-context tool could have done.

Who This Is Built For

For engineering teams running AI-assisted code reviews Situation: Your CI pipeline runs Claude Code or OpenAI Codex on every pull request. Token costs are climbing and review times are inconsistent. Payoff: In 30 days, code-review-graph will cut your PR review token spend by 50 percent, allowing 2x more reviews at the same API budget.

For developers building MCP-powered coding assistants Situation: Your custom MCP server serves code context to agents, but you struggle with context window limits on large repositories. Payoff: In 30 days, your coding assistant will deliver faster, more accurate responses by querying only the relevant subgraph instead of loading the full codebase.

Setup and Tools

Tool Role Cost code-review-graph Persistent intelligence graph engine Free (MIT, open source) SQLite / RocksDB Local graph persistence store Free MCP SDK Protocol bridge for AI tool integration Free Claude Code / Codex AI code review reasoning agent Pay-per-token API cost

The ROI Case

Metric Before After Token use per PR review 48,200 tokens 19,800 tokens Review execution time 45 seconds 12 seconds Daily cost (50 PR reviews) $95 $38 Monthly cost (22 workdays) $2,090 $836 Subgraph extraction latency N/A Under 800ms per query Setup time from scratch 4 hours 15 minutes

Honest Limitations

First graph build time [MEDIUM RISK] On repositories exceeding 10,000 source files, the initial AST parse and graph construction can take 10 to 20 minutes. Mitigation: configure the build to run on a background CI job or trigger incremental updates only on changed files.
Language coverage gaps [MINOR RISK] code-review-graph currently supports 12 languages with full AST parsing. Languages outside this set fall back to file-level graph nodes without entity resolution. Mitigation: check the language support table in the repository README before adoption.
Incremental graph drift [MINOR RISK] If you modify files outside Git tracking or apply large rebases, the entity graph can become stale. Mitigation: run crg update --incremental after each merge to refresh changed entities without a full rebuild.

Start in 10 Minutes

Step 1 (2 minutes). Run npm install -g code-review-graph. Verify with crg --version.

Step 2 (4 minutes). Navigate to your repository root and run crg init --store sqlite. Wait for the AST scan to complete.

Step 3 (4 minutes). Add the MCP server block to your Claude Code settings file at ~/.claude/settings.json. Restart Claude Code and run your next PR review with the crg review command.

Copy-paste the following block into your terminal:

npm install -g code-review-graph
cd /path/to/your/repo
crg init --language typescript,python --store sqlite
crg mcp --port 8080

Then add this to ~/.claude/settings.json:

{
  "mcpServers": {
    "code-review-graph": {
      "command": "crg",
      "args": ["mcp", "--port", "8080"],
      "env": {
        "CRG_STORE_PATH": "/path/to/.crg/graph.db"
      }
    }
  }
}

Frequently Asked Questions

Q: Does code-review-graph require an internet connection? A: No — the graph is built and queried entirely local-first. No data leaves your machine. Graph persistence uses local SQLite or RocksDB storage.

Q: Can code-review-graph work with VS Code extensions or Cursor? A: Yes — any tool that supports the MCP protocol can connect to the code-review-graph MCP server. Cursor, VS Code via the Continue extension, and Gemini CLI are all compatible.

Q: How often should I rebuild the graph? A: Run crg update --incremental after each merge commit. A full rebuild is only necessary when the repository language configuration changes or after a major branch rebase.

Q: Does the graph support monorepos with multiple languages? A: Yes — the crg init command accepts a comma-separated language list. The graph engine builds separate entity catalogs per language and merges them at the module boundary.