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

> Discover which AI assistants like Codex Claude Code Cursor and Copilot can leverage code-review-graph tools for efficient code review context using the Model Context Protocol.

- Repository: [Tirth Kanani/code-review-graph](https://github.com/tirth8205/code-review-graph)
- Tags: deep-dive
- Published: 2026-08-13

---

**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`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/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:

```bash

# 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`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/graph.py) to access node and edge data structures, delegating complex traversal logic to [`code_review_graph/tools/query.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/tools/query.py).

### Example Tool Calls via Python

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

```python
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:

```bash

# 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:

```text
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`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/main.py) and interface with [`code_review_graph/graph.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/graph.py) and [`code_review_graph/tools/query.py`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/main.py), delegates to `get_impact_radius` in [`code_review_graph/tools/query.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/tools/query.py). This function traverses the knowledge graph stored in [`code_review_graph/graph.py`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/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`](https://github.com/tirth8205/code-review-graph/blob/main/README.md) (lines 71-85) and detailed usage instructions appear in [`docs/USAGE.md`](https://github.com/tirth8205/code-review-graph/blob/main/docs/USAGE.md).