# MCP Tools in Codebase-Memory-MCP: 15+ Graph-Based Utilities for LLM Coding Assistants

> Explore 15+ graph-based MCP tools for LLM agents. Perform structural queries, impact analysis, and semantic search on your codebase with this versatile toolkit.

- Repository: [Martin Vogel/codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp)
- Tags: deep-dive
- Published: 2026-07-15

---

**The DeusData/codebase-memory-mcp server exposes 15+ JSON-RPC MCP tools that enable LLM agents to perform structural code queries, impact analysis, and semantic search over a persistent SQLite-backed knowledge graph.**

The DeusData/codebase-memory-mcp repository implements a specialized MCP (Model Context Protocol) server that transforms codebases into queryable knowledge graphs. These MCP tools provide LLM-powered coding assistants with programmatic access to call graphs, architecture summaries, and semantic code relationships through a standardized JSON-RPC interface defined in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c).

## Structural Query MCP Tools

### search_graph: Pattern-Based Symbol Discovery

The `search_graph` tool performs structural queries over the knowledge graph using regex name patterns, label filters, degree limits, and file scoping. According to the source implementation in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c), this tool indexes every function, class, and module as nodes with typed relationships.

**Typical applications:**
- Find all functions matching naming conventions like `.*Handler.*`
- Locate definitions of specific classes across language boundaries
- Enumerate public APIs by filtering for EXPORT edges

```bash
codebase-memory-mcp cli search_graph '{"project":"my-project","label":"Function","name_pattern":".*Handler.*"}'

```

### trace_call_path and trace_path: Execution Flow Analysis

These tools walk the **CALLS** or **IMPORTS** edge sets forward or backward with configurable depth limits. The implementation traverses the graph stored in the SQLite backend to reconstruct execution chains.

**Typical applications:**
- Track execution flow from an entry point to downstream functions
- Debug call-chain regressions by identifying which services invoke a given endpoint
- Verify reachability between components

```bash
codebase-memory-mcp cli trace_call_path '{"qualified_name":"cmd.Root.Execute","direction":"both","depth":5}'

```

### get_architecture: System Composition Overview

The `get_architecture` tool returns a high-level summary including languages, packages, modules, routes, and clusters in a single JSON payload. This aggregates data from the graph's metadata nodes built during the tree-sitter AST parsing phase.

**Typical applications:**
- Produce architecture diagrams programmatically
- Identify technology stack composition across polyglot repositories
- Detect boundaries between monolithic and micro-service components

```bash
codebase-memory-mcp cli get_architecture '{"project":"my-project"}'

```

## Advanced Query and Retrieval MCP Tools

### query_graph: Cypher-Like Traversal

The `query_graph` tool exposes a Cypher-like query language using `MATCH … RETURN …` syntax for arbitrary graph traversals. This provides flexible access to the underlying graph structure beyond the pre-defined tool interfaces.

**Typical applications:**
- Write custom analytics queries (e.g., "all functions that call a deprecated API")
- Explore cross-repository relationships
- Generate custom metrics for code quality dashboards

### get_code_snippet: Source Text Retrieval

This tool retrieves source text for qualified symbols (functions, classes, methods) with optional context lines. It maps graph nodes back to their original file offsets in the indexed repository.

**Typical applications:**
- Show exact implementations when an LLM asks "how is X implemented?"
- Embed verified code snippets in documentation
- Create on-demand examples for refactoring discussions

```bash
codebase-memory-mcp cli get_code_snippet '{"qualified_name":"handlers.UserService.Create","context_lines":5}'

```

### search_code: Full-Text Search with Graph Filters

The `search_code` tool combines BM25 full-text search over indexed files with graph-augmented filters. Unlike `search_graph`, this operates on literal source text rather than structural symbols.

**Typical applications:**
- Locate configuration values across multiple files
- Perform grep-like searches that respect module boundaries
- Find string literals and comments

### semantic_query: Vector Similarity Search

Using **Nomic embeddings**, `semantic_query` performs vector-based similarity search over the embedded code vocabulary. This enables finding conceptually related code across different languages and naming conventions.

**Typical applications:**
- Find semantically related functions across languages
- Suggest refactoring candidates by identifying duplicated logic
- Discover similar prompt helpers or utility patterns

```bash
codebase-memory-mcp cli semantic_query '["duplicate","clone","copy"]'

```

## Change Management and Impact Analysis MCP Tools

### detect_changes: Git Diff Impact Mapping

The `detect_changes` tool maps uncommitted or staged Git diffs onto affected symbols, annotating risk levels (high/medium/low) based on call-graph distance from entry points. This is implemented by correlating line-based diffs with the graph's source-location indexing.

**Typical applications:**
- Perform impact analysis before submitting pull requests
- Auto-suggest test suites based on affected symbol reachability
- Highlight potentially breaking changes for reviewer prioritization

```bash
codebase-memory-mcp cli detect_changes '' | jq -r '.impacted_symbols[] | .qualified_name'

```

### manage_adr: Architecture Decision Records

This CRUD tool manages Architecture Decision Records (ADRs) stored as nodes in the graph. It keeps design rationale synchronized with the code structure by linking ADRs to relevant modules and services.

**Typical applications:**
- Record decisions directly from agent conversations
- Retrieve contextual ADRs when modifying affected code
- Update status of technical debt items

```bash
codebase-memory-mcp cli manage_adr '{"action":"create","id":"ADR-007","title":"Migrate to GRPC","body":"..."}'

```

## Specialized Analysis MCP Tools

### detect_dead_code: Orphan Symbol Identification

Exposed via `search_graph` with zero **CALLS** edge constraints, this utility finds symbols with no incoming call edges (excluding known entry points). The [`scripts/smoke-invariants.sh`](https://github.com/DeusData/codebase-memory-mcp/blob/main/scripts/smoke-invariants.sh) test harness validates this against the canonical tool list.

**Typical applications:**
- Clean up unused utility functions
- Shrink binary size by identifying unreachable code
- Enforce "no-orphan" policies in CI pipelines

### cross_service_http_link: API Contract Verification

Accessible via `search_graph` with edge type `HTTP_CALLS`, this tool links HTTP route definitions to their call-sites across service boundaries.

**Typical applications:**
- Verify that every endpoint is exercised by at least one client
- Map client-server contracts for API documentation generation
- Identify orphaned API routes

### get_louvain_communities: Module Detection

Implemented internally and exposed via `query_graph`, this tool runs community detection algorithms on **CALLS** edges to surface functional modules using the Louvain method.

**Typical applications:**
- Suggest micro-service extraction boundaries
- Identify cohesion clusters for refactoring targets
- Visualize code organization beyond file structure

## Implementation Architecture

All MCP methods share a **common JSON-RPC 2.0 transport** handled by the request dispatch logic in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c). The server registers exactly 14 tools in the `TOOLS[]` array at line 503, though the full capability set exceeds 15 tools when including parameter variations and query-based access patterns.

The server builds a **persistent SQLite-backed graph** during indexing (converting tree-sitter AST output into nodes and edges), then serves these tools without any external runtime dependencies. Because every tool operates on the same canonical graph, agents can compose them in sequences: running `detect_changes` → `trace_call_path` on impacted symbols → `get_code_snippet` to propose updated implementations, all within a single conversational turn.

Documentation for these tools appears in the repository's [`README.md`](https://github.com/DeusData/codebase-memory-mcp/blob/main/README.md), with additional evaluation scenarios detailed in [`docs/EVALUATION_PLAN.md`](https://github.com/DeusData/codebase-memory-mcp/blob/main/docs/EVALUATION_PLAN.md) and npm-specific CLI documentation in [`pkg/npm/README.md`](https://github.com/DeusData/codebase-memory-mcp/blob/main/pkg/npm/README.md).

## Summary

- **15+ graph-based MCP tools** are implemented in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c) using JSON-RPC 2.0 transport
- Core capabilities include **structural search** (`search_graph`), **execution tracing** (`trace_call_path`), and **architecture overview** (`get_architecture`)
- **Change detection** (`detect_changes`) maps Git diffs to affected symbols with risk classification
- **Semantic search** (`semantic_query`) uses Nomic embeddings for conceptual code discovery
- All tools operate on a **SQLite-backed knowledge graph** built from tree-sitter AST parsing, requiring no external databases
- Tools compose together enabling complex workflows like impact analysis followed by source retrieval

## Frequently Asked Questions

### What transport protocol do these MCP tools use?

The codebase-memory-mcp server implements **JSON-RPC 2.0** as defined in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c). All tools register in a central `TOOLS[]` array that handles request dispatch and response formatting.

### How many MCP tools are available in the codebase?

The source defines **14 core tools** in the `TOOLS[]` array, though the complete capability set includes **15+ tools** when counting specialized query patterns (such as dead code detection via `search_graph` filters) and community detection algorithms exposed through `query_graph`.

### Do these MCP tools require an external database or cloud service?

No. The server builds a **persistent SQLite-backed graph** during the indexing phase using tree-sitter AST analysis. Once indexed, all MCP tools operate locally against this graph without network dependencies, making the system suitable for air-gapped environments.

### Can developers use these MCP tools outside of LLM agents?

Yes. While designed for LLM integration, every MCP tool is accessible via the bundled CLI. The [`pkg/npm/README.md`](https://github.com/DeusData/codebase-memory-mcp/blob/main/pkg/npm/README.md) documents the command-line interface, allowing developers to invoke `codebase-memory-mcp cli <tool_name>` directly in shell scripts or CI pipelines.