How do I use MCP Context Graph?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Context Graph find who calls the function 'calculate_tax'" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

MCP Context Graph

by padobrik

Overview Schema Related Servers Score Discussions

Python

Local

MCP Context Graph

A lightweight, in-memory code graph for AI agents — no Neo4j, no vector database, no infrastructure.

MCP Context Graph is a minimal, self-contained alternative to heavyweight code-graph stacks. Where larger open-source solutions bring a graph database, an embedding pipeline, and a fleet of services, this project brings three things: tree-sitter parsing, a NetworkX graph, and token-level source maps — all in a single Python process that starts in under a second and speaks the Model Context Protocol.

uvx mcp-context-graph /path/to/your/project

That's the entire deployment.

The Problem

AI coding agents burn most of their context window on finding code, not reasoning about it. The standard failure modes:

Read whole files — expensive, and most of each file is irrelevant to the question
Grep for text — finds strings, not semantics; every match means reading another file
Lose the call graph — "who calls this?" degenerates into reading the entire repository

MCP Context Graph parses your codebase once, builds a semantic graph (definitions, calls, imports, containment), and lets the agent query it through six MCP tools. The agent gets compact signatures and relationships by default, and can expand any symbol to its exact original source when it actually needs the implementation.

Related MCP server: kg-memory-mcp

Proof of Work: Measured Token Reduction

This is not a hand-wavy claim — the repository ships a reproducible, offline benchmark (mcp-context-graph benchmark <path>) that replays three real agent workflows against any codebase and counts tokens with tiktoken (o200k_base). No API keys required.

Results of the benchmark run against this repository itself (50 files → 963 nodes, 2,138 edges, indexed in ~200 ms):

Agent workflow	Reading files	Using the graph	Reduction
repo_map — build a mental map of the repo	85,129 tok	22,496 tok	3.8x (73.6%)
find_callers — "who calls X?" (top-5 hottest symbols)	174,685 tok	26,253 tok	6.7x (85.0%)
understand — "show me X and its context"	155,720 tok	27,525 tok	5.7x (82.3%)

Baselines are what a file-mediated agent actually does: repo_map reads every source file; find_callers greps for the name and reads every matching file; understand reads the symbol's file plus the files of its direct callers/callees. The graph side is the literal JSON tool responses — overhead included.

Estimated input-token cost per 1,000 agent queries on this repo (prices per 1M input tokens, adjust to current provider pricing):

Model	Reading files	Using graph	Savings
claude-sonnet-4.5	$99.12	$16.13	$82.99
gpt-5.2	$82.60	$13.44	$69.16
gpt-4o-mini	$4.96	$0.81	$4.15
gemini-2.5-pro	$115.64	$18.82	$96.82

Query latency is effectively free: find_definition ~0.4 µs, find_callers ~28 µs, get_context(depth=2) ~360 µs.

Run it on your own project:

uvx mcp-context-graph benchmark /path/to/project            # human-readable
uvx mcp-context-graph benchmark /path/to/project --markdown # README-ready
uvx mcp-context-graph benchmark /path/to/project --json     # machine-readable

Honest caveat: savings scale with repository size. On a two-file toy project the JSON envelope of a tool response can cost more than just reading both files. The graph pays off from roughly "a few dozen files" upward — exactly where agents start struggling.

How It Works

                ┌──────────────────────────────────────────────┐
                │              mcp-context-graph               │
   your repo    │                                              │     AI agent
  ┌─────────┐   │  tree-sitter ──► normalizer ──► minifier     │   ┌──────────┐
  │ *.py    │──►│   (parse)       (defs/calls/    (signatures  │◄──│ find_    │
  │ *.ts    │   │                  imports)        + source    │──►│ callers  │
  │ *.js    │   │                                  maps)       │   │ get_     │
  └─────────┘   │                      │                       │◄──│ context  │
                │                      ▼                       │──►│ expand_  │
                │            NetworkX MultiDiGraph             │   │ source   │
                │     CONTAINS / CALLS / IMPORTS edges         │   └──────────┘
                └──────────────────────────────────────────────┘

Parse — tree-sitter grammars for Python, TypeScript, and JavaScript extract definitions, call expressions, and import statements.
Minify — each definition is reduced to its signature (def calculate_tax(amount: float) -> float: ...) with a character-accurate source map back to the original file.
Link — a two-pass resolver turns call sites and imports into CALLS and IMPORTS edges across files, so "who calls this?" is a graph lookup, not a text search.
Serve — six MCP tools over stdio. The graph auto-indexes on the first query and transparently re-ingests modified, deleted, and newly created files before every query (check-on-read; no file watcher, no daemon).

Design Constraints (Why It Stays Small)

Constraint	Consequence
In-memory only	No database to install, corrupt, or migrate. Restart = reindex (~200 ms for 50 files).
Name-based call resolution	No full type inference. Same-file definitions win ties; ambiguities resolve deterministically.
Signatures by default, source on demand	The context window holds structure, not bodies. `expand_source` recovers exact bodies via source maps.
stdio transport, one project per server	No ports, no auth, no multi-tenancy complexity.

Installation

No installation needed with uv:

uvx mcp-context-graph /path/to/project

Or install it:

uv pip install mcp-context-graph   # or: pip install mcp-context-graph

Requires Python 3.12+.

Connecting an MCP Client

Claude Code

claude mcp add context-graph -- uvx mcp-context-graph /absolute/path/to/project

Claude Desktop (`claude_desktop_config.json`)

{
  "mcpServers": {
    "context-graph": {
      "command": "uvx",
      "args": ["mcp-context-graph", "/absolute/path/to/your/project"]
    }
  }
}

Claude Desktop requires an absolute path; relative paths like . resolve against the desktop app's working directory, not your project.

Cline / Cursor / other MCP clients

{
  "mcpServers": {
    "context-graph": {
      "command": "uvx",
      "args": ["mcp-context-graph", "."]
    }
  }
}

Clients that launch servers from the workspace directory (like Cline) can use ..

Set MCP_CONTEXT_GRAPH_LOG_LEVEL=DEBUG in the server environment for verbose stderr logging.

MCP Tools

Tool	Question it answers	Typical cost
`index_project`	"(Re)build the graph" — returns stats and the context-footprint reduction	one-off
`find_symbol`	"Where is `calculate_tax` defined?"	~100 tokens
`find_callers`	"Who calls `calculate_tax`?" — resolved through the call graph	~100–500 tokens
`get_context`	"What surrounds `calculate_tax`?" — center signature + neighbor references + relationships	~200–1,000 tokens
`expand_source`	"Show me the full implementation" — source-map-accurate original code	proportional to the body
`debug_dump_graph`	"Visualize the graph" — Mermaid / JSON / DOT	debug only

Indexing is automatic: the first query triggers a full ingest, and every subsequent query performs a fast staleness check (modified/deleted/new files are re-ingested and re-linked). index_project is only needed for a forced rebuild (force: true) or to inspect stats.

A Typical Agent Session

agent> find_symbol {"name": "calculate_tax"}
       → 1 definition: billing/tax.py:12, "def calculate_tax(amount: float, rate: float) -> float: ..."

agent> find_callers {"name": "calculate_tax"}
       → 3 callers: checkout.process_order, invoices.finalize, tests.test_tax_rounding

agent> get_context {"name": "calculate_tax", "depth": 1}
       → center signature + 5 connected symbols + relationships
         ("process_order --calls--> calculate_tax", ...)

agent> expand_source {"name": "calculate_tax"}
       → exact original source of the function body

Four queries, a few hundred tokens — instead of reading three files.

Token-Level Source Maps

Most code indexers store either full source (expensive) or bare symbol names (lossy). This project stores minified signatures plus character-accurate source maps:

# Original file (billing/tax.py)
def calculate_tax(amount: float, rate: float) -> float:
    """Calculate tax for the given amount."""
    return amount * rate

# Stored in the graph (what queries return)
def calculate_tax(amount: float, rate: float) -> float: ...

# Source map (per definition)
Segment(minified=[0,56)  → original=[0,56))    # signature, preserved exactly
Segment(minified=[57,60) → original=[57,131))  # "..." ↔ the real body

expand_source walks the map back to the original file and returns the exact bytes of the implementation — the graph never becomes a stale copy of your code.

Supported Languages

Language	Extensions	Extraction
Python	`.py`, `.pyw`	functions, classes, methods, calls, imports (incl. relative)
TypeScript	`.ts`, `.tsx`	functions, arrow/function expressions, classes, methods, interfaces, type aliases, calls, imports
JavaScript	`.js`, `.jsx`, `.mjs`, `.cjs`	functions, generators, arrow/function expressions, classes, methods, calls, imports

Each language is a self-contained config (grammar + .scm query files); adding a language means adding one config class and three query files.

.gitignore is respected, and node_modules, .venv, __pycache__, build artifacts, and friends are always excluded.

CLI Reference

mcp-context-graph [PATH]                 # serve MCP over stdio (default)
mcp-context-graph serve [PATH]           # same, explicit
mcp-context-graph index PATH             # one-shot index, print stats JSON
mcp-context-graph benchmark PATH         # token-reduction report
mcp-context-graph benchmark PATH --json --top 10
mcp-context-graph --version

Development

git clone https://github.com/padobrik/mcp-context-graph.git
cd mcp-context-graph
uv sync --dev

make check        # lint (ruff) + typecheck (mypy --strict) + tests (pytest)
make test         # 265 tests: unit, property-based (hypothesis), integration
make format       # ruff --fix + black

Project Structure

src/mcp_context_graph/
  core/           # Graph data structures (GraphNode, GraphEdge, ContextGraph)
  ingest/         # Pipeline: tree-sitter parser → normalizer → minifier → ingestor
  languages/      # Per-language grammar configs and .scm query files
  provenance/     # Source maps: segments + O(log n) bidirectional offset lookup
  mcp/            # MCP server (stdio) and tool implementations
  benchmark.py    # Token-reduction proof-of-work

Architecture Notes

Two-pass reference resolution. Files are parsed independently; call sites and imports queue as pending references, then resolve against the complete graph. Cross-file edges work regardless of file order, and incremental refreshes re-resolve idempotently (edges are keyed by (source, target, type) in a MultiDiGraph).
Check-on-read freshness. Every tool call compares mtimes for tracked files and rescans for new files. No watcher process, no events to miss.
Protocol hygiene. stdout is reserved for JSON-RPC; all logging goes to stderr (MCP_CONTEXT_GRAPH_LOG_LEVEL controls verbosity).
Graceful degradation. If tree-sitter fails on a file, a regex fallback still extracts top-level definitions rather than dropping the file.

License

MIT License. See LICENSE for details.

Available Tools

6 tools

debug_dump_graphA

DEBUG: Dump the entire graph structure for visualization. Returns the graph in Mermaid diagram, JSON, or Graphviz DOT format. Useful for debugging and understanding the graph structure.

ParametersJSON Schema

Name	Required	Description	Default
`format`	No	Output format: 'mermaid' for Mermaid flowchart diagram, 'json' for raw structure with all node/edge data, 'dot' for Graphviz DOT format.	mermaid
`show_edges`	No	Include edge relationships in output.
`limit_nodes`	No	Maximum nodes to include in output (for large graphs). Set to null/None to include all nodes.

TDQS

A3.7/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavior. It claims to 'Dump the entire graph structure' but the schema reveals a default limit of 50 nodes (limit_nodes), contradicting the 'entire' claim. Additionally, it does not note potential performance issues or truncation behavior for large graphs.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the DEBUG prefix and a clear action. Every word earns its place, and it effectively communicates the purpose without unnecessary filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description mentions return formats, which is helpful given no output schema. However, it fails to explain the default node limit that contradicts the 'entire graph' phrase, which is critical for understanding potential truncation. This omission makes it incomplete for a tool with a configurable limit.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema descriptions cover 100% of the parameters with detailed explanations (e.g., format, show_edges, limit_nodes). The description adds minimal semantic value beyond repeating the output formats ('Mermaid diagram, JSON, or Graphviz DOT format'), so the baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Dump the entire graph structure for visualization.' The verb 'dump' and resource 'graph structure' are specific, and the DEBUG prefix distinguishes it from sibling tools like find_symbol or get_context, which focus on focused code navigation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context with 'Useful for debugging and understanding the graph structure,' indicating when to use this tool. However, it does not explicitly exclude any alternatives or mention sibling tools, so it falls short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

expand_sourceA

Expand a symbol's compact signature to its full original source code using token-level source maps. Use this when the signature is not enough and you need the implementation.

ParametersJSON Schema

Name	Required	Description
`name`	No	The symbol name to expand. Use either symbol_id or name, not both.
`symbol_id`	No	The unique ID of the symbol to expand. Use either symbol_id or name, not both.
`end_offset`	No	Ending byte offset in minified text (optional). If not provided, expands to the end of the symbol.
`start_offset`	No	Starting byte offset in minified text (optional). If not provided, expands the full original source.

TDQS

A3.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden for behavioral disclosure. It reveals the method ('using token-level source maps') but does not state whether the operation is read-only, what happens on missing symbols, error handling, or return format. This is a significant gap for a tool with no annotation safety net.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise sentences with zero waste. The first sentence states what and how; the second gives usage guidance. Every phrase earns its place, and the structure is front-loaded with the core purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no output schema, the tool is relatively simple and the description adequately explains its purpose and usage. The return value (full source code) is implied by the action. However, it could be slightly more complete by explicitly stating the output type or error behavior, but for the complexity level it is sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for all four parameters, so the baseline is 3. The description does not add any parameter-specific meaning beyond the schema; it only mentions 'symbol' generically. The schema itself clearly explains parameter usage (e.g., 'Use either symbol_id or name, not both.'), but the description contributes nothing extra.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Expand a symbol's compact signature to its full original source code using token-level source maps.' It uses a specific verb ('expand') and resource ('symbol's compact signature'), and distinguishes it from siblings like find_symbol and get_context by focusing on source expansion rather than lookup or context retrieval.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit conditions for use: 'Use this when the signature is not enough and you need the implementation.' This gives clear context, but it does not mention alternatives or when not to use it, missing the 'when-not' or alternative tool guidance found in higher scores.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

find_callersA

Find all functions/methods that call a given function, resolved through the call graph (not text search). Useful for impact analysis before changing a function.

ParametersJSON Schema

Name	Required	Description	Default
`name`	Yes	The function or method name to find callers for. Returns all locations in the codebase that call this function.

TDQS

A4.2/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It does disclose a key behavioral trait (call-graph resolution rather than text search) and implies read-only operation via 'find'. However, it omits potential prerequisites (e.g., indexing) and details about output format or limitations, leaving gaps in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences: the first front-loads the core purpose and method, the second adds a practical use case. There is no redundancy or filler, every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter tool with no output schema, the description covers purpose, method, and use case. It lacks explicit prerequisites or output structure, but these are minimal for this tool and can be reasonably inferred from the call-graph context and sibling tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the parameter description already explains what 'name' is. The tool description adds the crucial context that resolution is via the call graph, enriching the parameter semantics beyond the schema's generic explanation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses specific verb 'find' with a clear resource ('functions/methods that call a given function') and explicitly distinguishes itself from text search by stating it is 'resolved through the call graph (not text search)'. This differentiates it from sibling tools like find_symbol and makes the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides a clear use case ('Useful for impact analysis before changing a function') and implies when not to use it by saying 'not text search'. However, it does not explicitly name alternative tools or state exclusions, so it lacks the full explicitness of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

find_symbolA

Find function, class, or method definitions by name. Returns all matching definitions with their locations and compact signatures - far cheaper than reading files. Optionally filter by language or include call sites.

ParametersJSON Schema

Name	Required	Description
`name`	Yes	The symbol name to search for (e.g., 'calculate_tax', 'MyClass'). Searches function, class, and method definitions.
`language`	No	Filter results to specific language (e.g., 'python', 'typescript', 'javascript'). Leave empty to search all languages.
`include_calls`	No	Include all call sites where this symbol is used. When true, returns both definitions and call locations.

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It discloses cost ('cheaper'), output ('locations and compact signatures'), and optional parameters. It does not detail matching semantics (case sensitivity, exact match), result limits, or side effects, though it appears to be read-only.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences, each serving a distinct purpose: purpose, output/benefit, and options. No filler or redundancy. It is front-loaded with the main action and efficiently conveys all necessary context.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only lookup tool with 3 well-documented parameters, the description gives a solid overview of expected output (locations and signatures) and performance characteristics. Without an output schema, it does not specify result structure details, but it is sufficient for common use cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and each parameter already has a clear description. The description adds reference to 'filter by language or include call sites' which maps to the parameters, but does not provide additional semantic detail beyond the schema, warranting the baseline 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action ('Find') on a specific resource ('function, class, or method definitions') by name. It clearly distinguishes itself from sibling tools like find_callers by focusing on definitions and locations rather than call sites.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use it: 'far cheaper than reading files' suggests using this for symbol lookups instead of reading entire files. However, it does not explicitly mention alternatives or when-not-to-use scenarios, which keeps it from a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_contextA

Get the contextual neighborhood around a symbol: the symbol plus connected nodes (callers, callees, imports, containers) within a given depth, and the relationships between them. The compact alternative to reading whole files for context.

ParametersJSON Schema

Name	Required	Description	Default
`name`	No	The symbol name to get context for. Use either symbol_id or name, not both.
`depth`	No	Context depth: 0=just the node, 1=direct callers/callees, 2=indirect connections, etc. Maximum depth is 5.
`format`	No	Response format: 'json' for structured data suitable for parsing, 'markdown' for human-readable text with code blocks.	json
`symbol_id`	No	The unique ID of the symbol (returned from find_symbol). Use either symbol_id or name, not both.

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It explains the behavior in detail: returns symbol plus connected nodes within a depth, and relationships. It does not disclose edge cases like duplicate symbol_id/name or error handling, but for a read tool this is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, no filler. The first sentence states the action and scope, the second gives a practical usage rationale. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only graph traversal tool without an output schema, the description conveys the return concept (nodes + relationships) and depth semantics. It omits details about response formats or limits, but the schema's format parameter and maximum depth cover some of that.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 100% coverage, so the baseline is 3. The description adds meaning beyond schema by enumerating node types (callers, callees, imports, containers) and framing depth as neighborhood expansion, which enriches the schema's per-parameter descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'Get' and names the resource 'contextual neighborhood around a symbol', specifying included node types (callers, callees, imports, containers) and depth. This clearly distinguishes it from siblings like find_callers (specific relationship) or find_symbol (single symbol).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'compact alternative to reading whole files for context' gives clear usage context and implies when to prefer this tool. However, it does not explicitly mention alternative tools or when not to use it, so it's a half-step above basic guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

index_projectA

(Re)index the project to build the code graph. Scans Python, TypeScript, and JavaScript files, extracts definitions, and resolves call/import relationships. Indexing also happens automatically on the first query; use this tool with force=true for a full rebuild, or to see indexing stats and the context-footprint reduction.

ParametersJSON Schema

Name	Required	Description	Default
`path`	No	Path to the project directory to index. If not provided, uses the project root configured at server startup. Example: '/path/to/my-project'
`force`	No	Force full re-indexing even if files haven't changed. Set to true to rebuild the entire graph from scratch.

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the transparency burden. It discloses key behaviors: scanning file types, extracting definitions, resolving relationships, automatic indexing on first query, and the ability to force a full rebuild. It stops short of detailing side effects like performance impact or overwriting behavior, but the core behavior is well covered.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the primary purpose, and every clause adds value. It efficiently conveys scope, automatic behavior, and usage options without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given only two optional parameters and no output schema, the description adequately covers what the tool does, when to use it, and what to expect (stats and context-footprint reduction). It could mention error conditions or return format, but for this simplicity level, it is sufficiently complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and both parameters have descriptions that fully explain their meaning and defaults. The tool description mentions 'force=true' and path indirectly, but adds no new semantic information beyond what the schema already provides, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('index') and resource ('project to build the code graph'). It also specifies file types scanned and what relationships are resolved, making it distinct from sibling tools like find_symbol or get_context which query the graph.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clarifies that indexing happens automatically on first query, implying the tool is usually unnecessary unless a full rebuild is needed or stats are desired. It provides clear context for when to use it with force=true, though it doesn't explicitly mention alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

6 tool updatesv0.2.0Aug 9, 2026
- First observeddebug_dump_graph
- First observedexpand_source
- First observedfind_callers
- First observedfind_symbol
- First observedget_context
- First observedindex_project

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.2/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: indexing, symbol lookup, caller analysis, context retrieval, source expansion, and graph dumping. There is no overlap that would cause an agent to select the wrong tool.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in lowercase snake_case (e.g., find_symbol, get_context). The verbs are descriptive and uniform, making the toolset predictable.

Tool Count5/5

Six tools is a well-scoped size for a code graph server, covering core operations without excessive fragmentation or missing essential functionality. Each tool earns its place.

Completeness5/5

The toolset covers the full workflow: indexing, symbol discovery, relationship analysis, source retrieval, and graph visualization. There are no significant gaps for the stated purpose of providing code context.

Maintenance

ActivitySlowing

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

memnodeOAuth
dev.memnode
Persistent, inspectable memory for AI agents with lineage, correction, and a hosted MCP endpoint.
Knowledge & Memory Autonomous Agents Agent Orchestration
2
BrainboxOAuth
dev.thexi
Persistent, portable memory for AI assistants — your private memory graph, from any MCP client.
Knowledge & Memory AI & Machine Learning
2
Ace Memory BOAuth
io.github.rudedoggg
Persistent memory for AI agents. Semantic search, memory graph, W3C DID identity.
Knowledge & Memory RAG Systems Autonomous Agents
4
Penfield Memory AOAuth
io.github.penfieldlabs
Persistent memory and knowledge graphs for AI agents. Hybrid search, context checkpoints, and more.
Knowledge & Memory RAG Systems Vector Databases
26

Related MCP Servers

Knowledge Master
Knowledge & Memory Developer Tools Code Analysis
subzone
A
license
A
quality
A
maintenance
A local knowledge graph MCP server that provides AI agents with permanent, structured memory about codebases, enabling semantic search, blast radius analysis, and convention enforcement.
Updated a month ago (2026-08-06 19:04 UTC)
8
2
MIT
kg-memory-mcp
Knowledge & Memory Coding Agents
arunmenon
F
license
Not graded
quality
D
maintenance
An in-memory knowledge graph MCP server that gives coding agents structural and semantic recall over codebases by indexing Python source, ADR documents, and project configuration, exposing 7 tools for search, traversal, context retrieval, and natural-language Q&A.
Updated 6 months ago (2026-03-05 04:54 UTC)
-
Graph-Mem MCP
Knowledge & Memory RAG Systems
Sathvik-1007
A
license
Not graded
quality
A
maintenance
A universal MCP server providing persistent, structured memory through a knowledge graph with graph storage, semantic vector search, and multi-hop traversal for AI agents and IDEs.
Updated 2 months ago (2026-07-21 20:43 UTC)
1
MIT
gbrain
Knowledge & Memory RAG Systems Search
laozhong86
A
license
Not graded
quality
C
maintenance
A local-first compiled knowledge graph MCP server that provides structured memory for AI agents with full-text search, vector embeddings, and timeline tracking.
Updated 5 months ago (2026-04-07 07:16 UTC)
415
8
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/padobrik/mcp-context-graph'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

MCP Context Graph

The Problem

Proof of Work: Measured Token Reduction

How It Works

Design Constraints (Why It Stays Small)

Installation

Connecting an MCP Client

Claude Code

Claude Desktop (claude_desktop_config.json)

Cline / Cursor / other MCP clients

MCP Tools

A Typical Agent Session

Token-Level Source Maps

Supported Languages

CLI Reference

Development

Project Structure

Architecture Notes

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

Claude Desktop (`claude_desktop_config.json`)