# MCP Tools for Querying Code Relationships in code-review-graph

> Discover MCP tools in code-review-graph for querying callers, callees, and tests. Explore FastMCP-based query_graph for efficient code relationship analysis.

- Repository: [Tirth Kanani/code-review-graph](https://github.com/tirth8205/code-review-graph)
- Tags: how-to-guide
- Published: 2026-07-29

---

**The code-review-graph repository provides FastMCP-based `query_graph` and supporting tools that expose graph-based queries to find function callers, callees, and associated tests through specific pattern arguments.**

The code-review-graph project implements a Model Context Protocol (MCP) server that surfaces the entire codebase as a queryable graph. For developers tracing execution flow or identifying test coverage, the repository ships specialized MCP tools for querying code relationships that resolve symbols and traverse the underlying `GraphStore` without manual navigation.

## Core MCP Tool: query_graph

The primary interface for relationship exploration is the **`query_graph`** tool defined in [`code_review_graph/tools/query.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/tools/query.py). This tool accepts a **pattern** argument that determines which relationship to inspect, along with a **target** symbol that can be specified as a qualified name, file path, or Java-style FQN.

According to the source code, the supported relationship patterns are declared in the `_QUERY_PATTERNS` dictionary (lines 25-33) and include:

- **`callers_of`** – Returns all functions that invoke the target function
- **`callees_of`** – Returns all functions called by the target function  
- **`tests_for`** – Returns test nodes (direct or indirect) that exercise the target symbol

The `query_graph` implementation validates the pattern against `_QUERY_PATTERNS`, resolves the target symbol, walks the `GraphStore`, and returns a structured response containing matching nodes, a summary string, and pagination metadata (lines 28-46).

## Supporting MCP Tools for Code Analysis

Beyond `query_graph`, the repository exposes complementary MCP tools in [`code_review_graph/tools/query.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/tools/query.py):

### get_impact_radius

The **`get_impact_radius`** tool analyzes the blast radius of changed files by traversing caller/callee relationships up to a specified depth. This is essential for understanding indirect effects after code modifications (lines 6-14).

### semantic_search_nodes

The **`semantic_search_nodes`** tool performs fuzzy or semantic lookup of nodes by name or keyword. Results can be piped into `query_graph` for precise relationship queries when you need to resolve ambiguous symbol names (lines 94-102).

### traverse_graph_func

For free-form exploration, **`traverse_graph_func`** executes BFS or DFS traversals starting from a node discovered via semantic search, allowing custom path exploration beyond predefined patterns (lines 165-173).

### list_graph_stats and find_large_functions

Additional utilities include **`list_graph_stats`** for high-level graph metrics like node counts and language breakdown (lines 75-82), and **`find_large_functions`** for identifying refactoring candidates based on code size (lines 38-45).

## Practical Code Examples

These examples demonstrate how to invoke the MCP tools directly from Python. In production workflows, you would typically invoke these through a FastMCP client over stdio or HTTP; the functions are also importable for unit testing.

### Find Callers of a Function

```python
from code_review_graph.tools.query import query_graph

result = query_graph(
    pattern="callers_of",
    target="utils.py::process_data",
    detail_level="standard",
    max_results=20,
)

print(result["summary"])
for node in result["results"]:
    print(f"Caller: {node['qualified_name']} ({node['file_path']})")

```

### Find Callees of a Function

```python
from code_review_graph.tools.query import query_graph

result = query_graph(
    pattern="callees_of",
    target="services/order_service.py::create_order",
    detail_level="standard",
)

print(result["summary"])
for node in result["results"]:
    print(f"Callee: {node['qualified_name']} ({node['file_path']})")

```

### List Tests for a Symbol

```python
from code_review_graph.tools.query import query_graph

result = query_graph(
    pattern="tests_for",
    target="models/user.py::User",
    detail_level="standard",
)

print(result["summary"])
for test in result["results"]:
    kind = "Indirect" if test.get("indirect") else "Direct"
    print(f"{kind} test: {test['qualified_name']} ({test['file_path']})")

```

### Combine Semantic Search with Relationship Queries

```python
from code_review_graph.tools.query import semantic_search_nodes, query_graph

# Resolve ambiguous symbol names first

search = semantic_search_nodes(query="order", kind="Function")
best = search["results"][0]
qualified = best["qualified_name"]

# Then query relationships

callers = query_graph(pattern="callers_of", target=qualified)
print(callers["summary"])

```

### Calculate Change Impact Radius

```python
from code_review_graph.tools.query import get_impact_radius

impact = get_impact_radius(
    changed_files=["services/payment.py"],
    max_depth=3,
    detail_level="standard",
)

print(impact["summary"])

```

## Key Implementation Files

The MCP tool surface is implemented across these source files:

- **[`code_review_graph/tools/query.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/tools/query.py)** – Core tool definitions including `query_graph`, `get_impact_radius`, `semantic_search_nodes`, and `traverse_graph_func`
- **[`code_review_graph/main.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/main.py)** – FastMCP server entry point that registers all tools for stdio/HTTP access
- **[`code_review_graph/graph.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/graph.py)** – Low-level `GraphNode` and `GraphStore` implementations powering relationship traversals
- **[`code_review_graph/tools/_common.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/tools/_common.py)** – Shared helpers for builtin call resolution and store management
- **[`code_review_graph/tools/analysis_tools.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/tools/analysis_tools.py)** – Additional analysis-oriented MCP tools

## Summary

- The **`query_graph`** MCP tool is the primary interface for querying code relationships, supporting `callers_of`, `callees_of`, and `tests_for` patterns defined in [`code_review_graph/tools/query.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/tools/query.py).
- **Target resolution** handles qualified names, file paths, and Java-style FQNs automatically.
- **`get_impact_radius`** provides blast-radius analysis for changed files by traversing relationship depths.
- **`semantic_search_nodes`** enables fuzzy symbol resolution before precise relationship queries.
- All tools are registered with the FastMCP server in [`code_review_graph/main.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/main.py) and available via stdio or HTTP transports.

## Frequently Asked Questions

### How do I query all functions that call a specific method in code-review-graph?

Use the `query_graph` MCP tool with the **`callers_of`** pattern. Pass the target function as a qualified name (e.g., `module.py::function_name`) or file path. The tool resolves the symbol against the `GraphStore` and returns all incoming call relationships.

### What is the difference between `query_graph` and `get_impact_radius`?

**`query_graph`** answers specific relationship questions (who calls X, what does X call, what tests cover X) for a single target symbol. **`get_impact_radius`** analyzes the downstream and upstream effects of multiple changed files, calculating indirect impact through caller/callee chains up to a configurable depth.

### Can I search for symbols by partial name before querying relationships?

Yes. Use the **`semantic_search_nodes`** tool to perform fuzzy or semantic lookup by keyword, then extract the `qualified_name` from the results to use as the target parameter in `query_graph`. This workflow handles ambiguous symbol names gracefully.

### Where are the MCP tool definitions registered for client access?

All MCP tools are registered in **[`code_review_graph/main.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/main.py)**, which initializes the FastMCP server. This makes the tools available to any MCP client including CLI tools, VS Code extensions, or custom scripts communicating over stdio or HTTP.