# Complete Guide to MCP Tools in code-review-graph: 30 AI-Powered Code Analysis Instruments

> Explore 30 AI-powered MCP tools in the code-review-graph repository for code analysis refactoring and architectural insights. Enhance your code reviews now.

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

---

**The `tirth8205/code-review-graph` repository provides approximately 30 Model-Centric Programming (MCP) tools organized into three categories—Core Tools for graph construction and querying, Flow Tools for execution path analysis, and Community Tools for architectural subsystem insights—enabling comprehensive AI-assisted code review and refactoring.**

The `tirth8205/code-review-graph` project ships a comprehensive suite of **MCP (Model-Centric Programming) tools** designed to power AI-assisted code analysis workflows. These tools enable automated graph navigation, impact analysis, and intelligent refactoring by exposing the codebase structure through a structured Model Context Protocol interface. According to the source code in [`code_review_graph/skills.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/skills.py) and the command reference in [`docs/COMMANDS.md`](https://github.com/tirth8205/code-review-graph/blob/main/docs/COMMANDS.md), the tools are logically grouped into three distinct categories that cover the full graph lifecycle.

## Core Tools: Graph Construction and Analysis

**Core Tools** form the foundation for any AI-driven workflow, providing capabilities to build, query, and retrieve information from the knowledge graph. These instruments handle raw graph data, impact analysis, and minimal context extraction.

The 12 primary Core Tools include:

- **`build_or_update_graph_tool`** – Constructs or incrementally updates the knowledge graph from source code.
- **`run_postprocess_tool`** – Executes post-processing operations on the graph to enrich relationships and metadata.
- **`get_minimal_context_tool`** – Extracts the smallest viable context necessary for specific queries, optimizing token usage.
- **`get_impact_radius_tool`** – Analyzes the blast radius of proposed changes by tracing dependencies and affected nodes.
- **`query_graph_tool`** – Executes structured queries against the graph database using flexible search parameters.
- **`get_review_context_tool`** – Gathers comprehensive context specifically formatted for automated code review scenarios.
- **`traverse_graph_tool`** – Navigates graph paths to discover connections between functions, classes, and modules.
- **`semantic_search_nodes_tool`** – Performs vector-based semantic searches across graph nodes to find conceptually related code.
- **`embed_graph_tool`** – Generates and manages vector embeddings for graph entities to enable similarity comparisons.
- **`list_graph_stats_tool`** – Reports statistical metrics about graph size, density, and node distribution.
- **`find_large_functions_tool`** – Identifies functions exceeding complexity or line-count thresholds for refactoring targets.
- **`get_docs_section_tool`** – Retrieves specific documentation sections associated with code entities.

## Flow Tools: Execution Path Analysis

**Flow Tools** operate on *flows*—high-level execution paths extracted from the graph, such as request-handling pipelines or build pipelines. These three tools let you list, inspect, and fetch the flows most critical for a given change.

- **`list_flows_tool`** – Enumerates available execution flows within the codebase, sortable by criticality or complexity.
- **`get_flow_tool`** – Retrieves detailed information about a specific execution flow, including constituent nodes and edges.
- **`get_affected_flows_tool`** – Identifies which execution paths intersect with modified files or functions, highlighting critical test paths.

## Community Tools: Architecture and Subsystem Insights

**Community Tools** work with *communities*—clusters of related nodes (functions, classes, tests) that form logical subsystems. These eight tools help explore cohesion, size, and membership of architectural communities.

- **`list_communities_tool`** – Displays all detected communities within the graph, showing size and cohesion metrics.
- **`get_community_tool`** – Provides detailed membership and boundary information for a specific community.
- **`get_architecture_overview_tool`** – Generates high-level architectural summaries, available in varying detail levels from minimal to comprehensive.
- **`get_hub_nodes_tool`** – Identifies central hub nodes that connect multiple communities or have high centrality scores.
- **`get_bridge_nodes_tool`** – Finds bridge nodes that link otherwise disconnected communities, highlighting critical integration points.
- **`get_knowledge_gaps_tool`** – Detects areas of the codebase with sparse documentation or test coverage within communities.
- **`get_surprising_connections_tool`** – Reveals unexpected dependencies or couplings between seemingly unrelated components.
- **`get_suggested_questions_tool`** – Generates intelligent questions about the architecture to guide human reviewers or LLM analysis.

## Practical Implementation Examples

The MCP server (`code-review-graph serve`) expects JSON payloads containing the tool name and arguments. Below are implementation patterns for each category.

### Core Tool: Impact Radius Analysis

Invoke `get_impact_radius_tool` to assess change impact before committing:

```python
import json
import subprocess

payload = {
    "tool": "get_impact_radius_tool",
    "args": {
        "changed_files": None,  # auto-detect from VCS

        "max_depth": 3,
        "detail_level": "standard"
    }
}

result = subprocess.run(
    ["code-review-graph", "mcp"],
    input=json.dumps(payload).encode(),
    capture_output=True,
    text=True
)

impact_data = json.loads(result.stdout)
print(f"Affected nodes: {len(impact_data['nodes'])}")

```

### Flow Tool: Critical Flow Enumeration

Retrieve the ten most critical execution paths using `list_flows_tool`:

```python
payload = {
    "tool": "list_flows_tool",
    "args": {
        "sort_by": "criticality",
        "limit": 10
    }
}

# Execute via subprocess or direct MCP client connection

```

### Community Tool: Architecture Overview

Generate a minimal architecture summary with `get_architecture_overview_tool`:

```python
payload = {
    "tool": "get_architecture_overview_tool",
    "args": {
        "detail_level": "minimal"
    }
}

```

## Source Code Reference

The MCP tool implementations and signatures are defined across these key files:

- **[`docs/COMMANDS.md`](https://github.com/tirth8205/code-review-graph/blob/main/docs/COMMANDS.md)** – Central catalog documenting all 30+ MCP tools with complete signatures, default parameters, and usage notes.
- **[`code_review_graph/skills.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/skills.py)** – Python skill wrappers that expose the tools to the LLM server and handle argument validation.
- **[`tests/test_tools.py`](https://github.com/tirth8205/code-review-graph/blob/main/tests/test_tools.py)** – Comprehensive test suite validating each tool's argument handling, output format, and error conditions.
- **[`README.md`](https://github.com/tirth8205/code-review-graph/blob/main/README.md)** – High-level project overview including server startup and MCP protocol configuration.

## Summary

- The **code-review-graph** repository organizes approximately 30 MCP tools into three functional groups: Core, Flow, and Community.
- **Core Tools** handle graph construction, semantic search, and impact analysis through instruments like `build_or_update_graph_tool` and `get_impact_radius_tool`.
- **Flow Tools** focus on execution path analysis via `list_flows_tool`, `get_flow_tool`, and `get_affected_flows_tool`.
- **Community Tools** expose architectural insights through `get_architecture_overview_tool`, `get_hub_nodes_tool`, and `get_knowledge_gaps_tool`.
- All tools are implemented in [`code_review_graph/skills.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/skills.py) and documented in [`docs/COMMANDS.md`](https://github.com/tirth8205/code-review-graph/blob/main/docs/COMMANDS.md), accepting JSON payloads via the MCP server interface.

## Frequently Asked Questions

### What are MCP tools in the context of code-review-graph?

**MCP tools** (Model-Centric Programming tools) in the `tirth8205/code-review-graph` repository are specialized functions that expose code analysis capabilities through the Model Context Protocol. They allow AI systems and automated agents to query knowledge graphs, analyze execution flows, and inspect architectural communities without directly manipulating the underlying graph database.

### How do I invoke these MCP tools programmatically?

You can invoke MCP tools by sending JSON payloads to the MCP server via the CLI command `code-review-graph mcp` or through direct integration with the Python skills defined in [`code_review_graph/skills.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/skills.py). Each payload must specify the `tool` name and an `args` dictionary containing the required parameters for that specific instrument.

### What is the difference between Flow Tools and Community Tools?

**Flow Tools** analyze *execution paths*—dynamic sequences of function calls that represent runtime behavior, such as API request handling. **Community Tools** analyze *static clusters*—groups of related code entities that form logical subsystems or modules. Flows show how code runs; communities show how code is organized.

### Where are the MCP tool implementations defined in the source code?

The concrete implementations are located in [`code_review_graph/skills.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/skills.py), while the command specifications and parameter schemas are documented in [`docs/COMMANDS.md`](https://github.com/tirth8205/code-review-graph/blob/main/docs/COMMANDS.md). The test suite in [`tests/test_tools.py`](https://github.com/tirth8205/code-review-graph/blob/main/tests/test_tools.py) provides additional examples of expected inputs and outputs for each tool category.