Which AI Assistants Can Leverage code-review-graph's Tools: Complete Platform Guide

Any AI assistant that supports the Model Context Protocol (MCP)—including Codex, Claude Code, Cursor, and GitHub Copilot—can leverage code-review-graph's tools to query the internal knowledge graph for token-efficient code review context.

The tirth8205/code-review-graph repository exposes its codebase analysis capabilities through a standardized MCP (Model-Context-Protocol) interface. This protocol allows AI coding assistants to invoke specialized tools that traverse the internal knowledge graph, returning concise, contextually relevant information without consuming excessive token budgets. Because MCP operates as a JSON-RPC style standard, any assistant capable of making tool calls through native plugins, HTTP APIs, or command-line wrappers can immediately access the graph's analytical power.

Understanding the MCP Foundation

MCP (Model-Context-Protocol) represents an open standard for connecting AI assistants to external data sources and tools. Rather than embedding entire codebases into prompts, assistants can call specific functions that return only the necessary context.

In code-review-graph, the MCP server maps incoming tool invocations to Python functions defined in code_review_graph/main.py. When an assistant requests the impact radius of a modified file, the server executes the corresponding function, queries the graph structures in code_review_graph/graph.py, and returns a compressed, token-optimized response. This architecture ensures that AI assistants can leverage code-review-graph tools without requiring custom integration code for each platform.

Supported AI Assistants and Installation

The project ships out-of-the-box integrations for thirteen major AI coding assistants. Each platform receives a tailored MCP configuration through a unified installation command.

Officially Supported Platforms

According to the repository's README.md (lines 71-85), the following assistants are supported:

• Codex – OpenAI's autonomous coding agent
• Claude Code – Anthropic's terminal-based assistant
• CodeBuddy Code – AI pair programming platform
• Cursor – AI-first code editor
• Windsurf – AI-powered IDE
• Zed – High-performance collaborative editor
• Continue – Open-source AI coding assistant
• OpenCode – AI development assistant
• Qwen – Alibaba's large language model assistant
• Qoder – Specialized coding AI
• Kiro – AI development environment
• GitHub Copilot (VS Code) – Microsoft's editor-integrated AI
• GitHub Copilot CLI – Command-line interface for Copilot

How Platform Integration Works

Each assistant receives a specific MCP-compatible JSONC configuration file generated by the CLI:

# Install for Claude Code

code-review-graph install --platform claude-code

# Install for Cursor

code-review-graph install --platform cursor

# Install for GitHub Copilot VS Code

code-review-graph install --platform copilot

These commands write platform-specific schemas that map the assistant's tool invocation mechanism (such as get_impact_radius_tool) to the corresponding Python function in code_review_graph/main.py. The assistant then communicates via the MCP server's JSON-RPC endpoint to execute queries against code_review_graph/tools/query.py.

How Assistants Invoke code-review-graph Tools

AI assistants interact with the knowledge graph through three primary invocation patterns, all utilizing the MCP protocol's standardized request format.

Tool Definitions and Routing

The core tool definitions reside in code_review_graph/main.py, which handles routing from MCP calls to internal implementations. Available tools include:

• get_impact_radius_tool – Calculates the blast radius of code changes
• get_review_context_tool – Retrieves relevant review context for specific files
• get_flow_tool – Analyzes control flow through the codebase

These functions interface with code_review_graph/graph.py to access node and edge data structures, delegating complex traversal logic to code_review_graph/tools/query.py.

Example Tool Calls via Python

An assistant implementation can directly call the MCP endpoint using standard HTTP requests:

import json
import requests

# Query the impact radius for a modified file

payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "get_impact_radius_tool",
    "params": {"path": "src/my_module.py"}
}

response = requests.post("http://localhost:8000/mcp", json=payload)
result = json.loads(response.text)["result"]
print(f"Impact radius: {result}")

CLI-Based Invocation

Assistants can also invoke tools indirectly through the command-line interface:

# Get impact radius via CLI wrapper

code-review-graph tool get_impact_radius_tool --path src/my_module.py

This approach allows shell-based assistants or scripts to access graph capabilities without implementing full MCP client libraries.

Embedded Tool Tags

Some assistants support XML-style tool tags within prompts that the host environment intercepts and routes to the MCP server:

The function `login_user` was modified.
<tool name="get_impact_radius_tool" path="src/auth.py"/>

When the assistant encounters this tag, it automatically sends the MCP request, receives the dependency graph data, and incorporates the results into its response.

Core Tools Available to AI Assistants

The code-review-graph ecosystem exposes several specialized tools that assist AI systems in performing comprehensive code reviews:

• get_impact_radius_tool – Traverses the dependency graph to identify all functions, tests, and modules affected by changes to a specific file. Implementation resides in code_review_graph/tools/query.py.
• get_review_context_tool – Extracts relevant historical review data and code patterns to inform the assistant's analysis.
• get_flow_tool – Maps execution paths and data flow through the codebase, helping assistants understand complex interactions.

These tools return token-efficient responses—structured data rather than raw code—allowing assistants to maintain large context windows while still understanding deep codebase relationships.

Why MCP Compatibility Matters

The standardized nature of MCP ensures that code-review-graph remains future-proof. As new AI assistants emerge, they can immediately leverage the existing toolset without requiring changes to the core graph implementation. Any assistant that speaks the JSON-RPC protocol can invoke get_impact_radius_tool or get_review_context_tool, query the graph structures defined in code_review_graph/graph.py, and receive optimized context. This universality makes code-review-graph function as a universal backend for AI-powered code reviews, decoupled from any single assistant's proprietary API.

Summary

• AI assistants can leverage code-review-graph through its MCP (Model-Context-Protocol) interface, which exposes graph querying tools via JSON-RPC.
• Thirteen platforms are officially supported, including Codex, Claude Code, Cursor, Windsurf, Zed, Continue, and GitHub Copilot, each configurable via code-review-graph install --platform <name>.
• Core tools like get_impact_radius_tool, get_review_context_tool, and get_flow_tool reside in code_review_graph/main.py and interface with code_review_graph/graph.py and code_review_graph/tools/query.py.
• Assistants can invoke tools through HTTP API calls, CLI commands, or embedded XML tags, receiving token-efficient responses that preserve context window space.
• The MCP standard ensures compatibility with future AI assistants without requiring codebase modifications.

Frequently Asked Questions

What is MCP and why does code-review-graph use it?

MCP (Model-Context-Protocol) is an open standard for connecting AI assistants to external tools and data sources. code-review-graph uses MCP because it provides a unified, language-agnostic interface that any assistant can consume. Instead of building custom integrations for each AI platform, the project implements a single MCP server in code_review_graph/main.py that handles all tool routing, making the codebase immediately accessible to any MCP-compatible assistant.

Can custom AI assistants integrate with code-review-graph?

Yes. Any AI assistant capable of making JSON-RPC 2.0 requests can leverage the tools. Custom assistants simply need to POST to the MCP endpoint (typically http://localhost:8000/mcp) with properly formatted requests containing the tool name (such as get_impact_radius_tool) and parameters. Because the protocol is standardized, no modifications to code-review-graph are required to support new assistants.

How does the get_impact_radius_tool work internally?

The get_impact_radius_tool function, defined in code_review_graph/main.py, delegates to get_impact_radius in code_review_graph/tools/query.py. This function traverses the knowledge graph stored in code_review_graph/graph.py, following dependency edges from a modified file to identify all downstream functions, tests, and modules that could be affected. The result is a condensed list of impacted nodes rather than the entire codebase, optimizing token usage.

Where are the MCP tool definitions located in the repository?

All MCP tool definitions and routing logic reside in code_review_graph/main.py. This file contains the mapping between MCP method names (like get_impact_radius_tool) and their corresponding Python implementations. Platform-specific installation configurations are documented in README.md (lines 71-85) and detailed usage instructions appear in docs/USAGE.md.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}