CodeGraphContext Skill

Structural code graph queries using the CodeGraphContext MCP server (tree-sitter AST + KuzuDB property graph).

When to Use vs Other Search Tools

Need	Tool
Who calls foo()?	find_callers (this skill)
What does foo() call?	find_callees (this skill)
Class hierarchy / interface implementors	get_class_hierarchy (this skill)
Dead code / unreachable functions	find_dead_code (this skill)
Module-level import graph	get_module_deps (this skill)
Keyword / regex search	pnpm search:code or ripgrep
Semantic / conceptual search	code-semantic-search skill
AST shape matching	code-structural-search skill
Compiler-verified definition/references	lsp-navigator skill

Use this skill when you need relationship traversal across the call graph or import graph, not text matching.

MCP Tool Reference

Tool	Purpose	Key Parameters
find_callers	All functions/methods that call a symbol	symbol, file?, depth?
find_callees	All symbols called by a function	symbol, file?, depth?
get_class_hierarchy	Superclasses, subclasses, interfaces	class_name, direction?
find_dead_code	Functions with no callers in graph	scope?, min_confidence?
get_module_deps	Import/require dependency graph	module, direction?, depth?
query_graph	Raw Cypher query against KuzuDB	cypher, params?

Setup

# Install CodeGraphContext MCP server
npm install -g @codetiger/code-graph-context-mcp

# Index your codebase (run from project root)
code-graph-context index --root . --lang typescript,javascript

Add to .claude/settings.json under mcpServers:

"CodeGraphContext": {
  "command": "code-graph-context-mcp",
  "args": ["--db", ".claude/context/data/code-graph.kuzu"]
}

Usage Pattern

// 1. Find all callers of a function
mcp__CodeGraphContext__find_callers({ symbol: 'shouldUseWorktree', depth: 2 });

// 2. Trace what a function depends on
mcp__CodeGraphContext__find_callees({ symbol: 'routeRequest', file: 'routing-table.cjs' });

// 3. Dead code candidates (low confidence = more results)
mcp__CodeGraphContext__find_dead_code({ scope: 'src/', min_confidence: 0.8 });

// 4. Raw Cypher for custom traversal
mcp__CodeGraphContext__query_graph({
  cypher: 'MATCH (a:Function)-[:CALLS]->(b:Function) WHERE b.name = $name RETURN a',
  params: { name: 'handleAuth' },
});

Integration with Agent-Studio Memory

After graph analysis, record structural findings:

MemoryRecord({
  type: 'pattern',
  content: 'routeRequest has 12 callers — high-risk refactor target',
  area: 'architecture',
});
MemoryRecord({
  type: 'gotcha',
  content: 'worktree-utils dead code: shouldPruneWorktree() never called',
  area: 'cleanup',
});

MCP Server Mode (Dual CLI + MCP)

CodeGraphContext supports two operation modes:

CLI mode (batch indexing, one-shot queries):

code-graph-context index --root . --lang typescript,javascript
code-graph-context query --cypher "MATCH (f:Function) RETURN f.name LIMIT 10"

MCP server mode (live, incremental — recommended for agent use):

npx @codetiger/code-graph-context-mcp --watch --db .claude/context/data/code-graph.kuzu

With --watch, the server monitors file changes and re-indexes incrementally. No manual re-index after refactors.

Neo4j Enterprise Option

For large codebases (>100K nodes), replace KuzuDB with Neo4j:

code-graph-context index --root . --backend neo4j --uri bolt://localhost:7687

Add to settings.json:

"CodeGraphContext": {
  "command": "code-graph-context-mcp",
  "args": ["--backend", "neo4j", "--uri", "bolt://localhost:7687"]
}

Interactive HTML Visualization

Generate a browsable call graph:

code-graph-context visualize --output .claude/context/tmp/call-graph.html

Pre-Indexed Bundles

For CI/CD pipelines, ship a pre-built graph bundle with the repo:

# In CI: build + archive
code-graph-context index --root . --export .claude/context/data/code-graph.bundle.gz

# In agent startup: restore
code-graph-context restore --bundle .claude/context/data/code-graph.bundle.gz

Complexity Analysis

// Find high-complexity functions (cyclomatic > 10)
mcp__CodeGraphContext__query_graph({
  cypher:
    'MATCH (f:Function) WHERE f.complexity > $threshold RETURN f.name, f.file, f.complexity ORDER BY f.complexity DESC',
  params: { threshold: 10 },
});

Anti-Patterns

• Do not use query_graph raw Cypher before checking if a purpose-built tool covers the need
• Do not treat find_dead_code results as certain — dynamic dispatch and reflection create false positives
• With --watch MCP mode, manual re-index is not needed — avoid running index --incremental during active MCP sessions
• Graph queries do not cross language boundaries (TypeScript ≠ Python in same repo)
• Do not use KuzuDB for >100K node graphs in production — switch to Neo4j backend

When to Invoke

Skill({ skill: 'code-graph-context' });

Invoke for: impact analysis before refactoring, call chain debugging, dead code audits, module dependency reviews, and architectural dependency mapping.