
Code Graph
- 6 installs
- 706 repo stars
- Updated July 14, 2026
- alinaqi/maggy
code-graph is a Claude Code skill that uses the codebase-memory-mcp server to query an AST code graph for symbol lookup, call tracing, and blast-radius analysis before reading files.
About
A Claude Code skill that directs the agent to query an AST-based code graph (via the codebase-memory-mcp MCP server) before reading files, for symbol lookup, call tracing, dependency analysis, and blast-radius detection. It documents the server's tools and a graph-first navigation workflow. A developer uses it to plan and scope code changes with fewer tokens than brute-force file reads.
- Query an AST code graph via the codebase-memory-mcp server (14 tools)
- Symbol lookup, call tracing, and blast-radius detection instead of grep
- Graph-first, file-second navigation workflow
Code Graph by the numbers
- 6 all-time installs (skills.sh)
- Ranked #12,756 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
code-graph capabilities & compatibility
Skill is free; requires running the codebase-memory-mcp server.
- Capabilities
- agent tooling · refactoring · code review
- Use cases
- refactoring · code review · debugging
- Pricing
- Free
What code-graph says it does
Use the code graph (codebase-memory-mcp) for sub-millisecond symbol lookup, function search, dependency analysis, and blast radius detection.
Graph first, file second.
npx skills add https://github.com/alinaqi/maggy --skill code-graphAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 6 |
|---|---|
| repo stars | ★ 706 |
| Last updated | July 14, 2026 |
| Repository | alinaqi/maggy ↗ |
What it does
Guides the agent to query an AST code graph via an MCP server for symbol lookup and blast-radius analysis before editing code.
Who is it for?
Developers navigating large codebases who want graph-based symbol lookup and impact analysis instead of grep-and-read.
Skip if: Searching string literals, log messages, or config values, where grep is still the right tool.
When should I use this skill?
Before reading files, query the graph first for symbol lookup, call tracing, and blast radius.
What you get
Sub-millisecond symbol lookup, dependency tracing, and blast-radius detection via the code graph.
- Graph-first navigation workflow
- MCP tool usage guide
- Blast-radius analysis steps
By the numbers
- 14 MCP tools
- 64 languages supported
- ~99% fewer tokens for navigation vs file reads
Files
Code Graph Skill
Purpose: Use the code graph (codebase-memory-mcp) for sub-millisecond symbol lookup, function search, dependency analysis, and blast radius detection. This replaces brute-force grep and file reading for code navigation.
---
Core Principle
Graph first, file second. Before reading files or grepping, query the code graph. Only read full files when you need to modify them or need context beyond what the graph provides.
Consider graph when planning. When planning any change — feature, refactor, bug fix — start by querying the graph to understand scope, dependencies, and blast radius. This applies to thinking and planning phases, not just implementation. Grep is still the right tool for searching string literals, log messages, config values, and content that lives outside code structure.
┌────────────────────────────────────────────────────────────────┐
│ GRAPH FIRST, FILE SECOND │
│ ─────────────────────────────────────────────────────────────│
│ The code graph indexes your entire codebase as a persistent │
│ knowledge graph. Claude queries it via MCP for instant │
│ symbol lookup, dependency chains, and blast radius — instead │
│ of reading hundreds of files. │
│ │
│ 14 MCP tools │ 64 languages │ sub-ms queries │ zero deps │
│ ~99% fewer tokens for navigation vs brute-force file reads │
├────────────────────────────────────────────────────────────────┤
│ AUTO-UPDATED │
│ ─────────────────────────────────────────────────────────────│
│ File watcher keeps graph in sync. Post-commit hook ensures │
│ freshness. No manual rebuild needed. │
└────────────────────────────────────────────────────────────────┘---
When to Use Graph vs Direct Read
| Task | Use Graph Tool | Use Direct Read? |
|---|---|---|
| Find function/class definition | search_graph | No |
| Get function signature + docs | get_code_snippet | No |
| Find all callers of a function | trace_call_path | No |
| Trace dependency chain | query_graph | No |
| Determine blast radius of change | detect_changes | No |
| Understand project architecture | get_architecture | No |
| Search for code patterns | search_code | No |
| Read full implementation to modify | search_graph to locate, then Read file | Yes |
| Understand business logic context | get_code_snippet for overview, then Read | Yes |
Rule: If a graph tool can answer the question, use it. Only open files when you need the full source to make edits.
---
Available MCP Tools
Indexing & Status
| Tool | Purpose | When to Use |
|---|---|---|
index_repository | Build/rebuild graph for a project | First setup, or after major restructure |
index_status | Check if graph is current | Before querying, if unsure of freshness |
list_projects | List all indexed projects | Multi-project navigation |
Querying & Navigation
| Tool | Purpose | When to Use |
|---|---|---|
search_graph | Find symbols by name (fuzzy) | "Find auth-related functions" |
search_code | Text search across indexed codebase | "Find TODO comments", pattern matching |
get_code_snippet | Get source code for a specific symbol | Need signature, docstring, implementation |
get_graph_schema | Understand graph structure and relationships | Exploring what data is available |
query_graph | Run structured graph queries | Complex dependency/relationship queries |
Analysis
| Tool | Purpose | When to Use |
|---|---|---|
trace_call_path | Trace caller/callee chains | "Who calls sendEmail?", "What does init() trigger?" |
detect_changes | Identify changed files and blast radius | Before/after code changes, PR review |
get_architecture | High-level module/package structure | Onboarding, understanding project layout |
Management
| Tool | Purpose | When to Use |
|---|---|---|
delete_project | Remove a project from the graph | Cleanup, project restructure |
manage_adr | Architecture decision records | Document architectural decisions |
ingest_traces | Import runtime traces | Performance analysis, dead code detection |
---
Workflow: Before Any Code Change
0. PLAN → get_architecture + search_graph to understand scope before planning
1. LOCATE → search_graph to find the symbol
2. UNDERSTAND → get_code_snippet for context
3. BLAST → detect_changes to assess impact
4. TRACE → trace_call_path to find all affected callers
5. CHANGE → Read file, make edit
6. VERIFY → detect_changes again to confirm scopeStep 0 applies to planning, not just coding. When the user asks you to plan a feature, refactor, or fix — query the graph first to understand what exists, what depends on what, and what the scope looks like. This prevents plans based on wrong assumptions about the codebase.
Never skip step 3. Blast radius analysis prevents unexpected breakage from changes to shared code.
---
Graph Data & Freshness
The graph stays fresh automatically through 3 layers — no manual rebuild needed:
| Layer | Trigger | What Happens |
|---|---|---|
| File watcher | Every file save | codebase-memory-mcp detects changes and re-indexes affected files in real-time |
| Auto-index | Session start | auto_index: true ensures graph is current when Claude Code starts |
| Post-commit hook | Every git commit | Touches .code-graph/.needs-update marker — file watcher picks it up (~10ms, non-blocking) |
You do NOT need to manually re-index unless you do a major restructure (rename entire directories, switch branches with massive diffs). In that case: index_repository once, then the 3 layers keep it fresh.
- Storage:
.code-graph/directory (auto-created, gitignored) - MCP config:
.mcp.jsonat project root (committed, shared with team)
---
MCP Configuration
The code graph MCP server is configured in .mcp.json at project root:
{
"mcpServers": {
"codebase-memory": {
"command": "codebase-memory-mcp",
"args": []
}
}
}Installation: ~/.claude/install-graph-tools.sh
---
Decision Framework
Need to find a symbol/function?
→ search_graph (sub-ms, structured result)
→ NOT: grep -r "functionName" (slow, unstructured)
Need to understand dependencies?
→ query_graph or trace_call_path (complete, traversable)
→ NOT: manually reading import statements
Need to assess change impact?
→ detect_changes (comprehensive, instant)
→ NOT: searching for usages manually across files
Need to understand architecture?
→ get_architecture (high-level overview)
→ NOT: reading every directory listing
Need to read/modify code?
→ search_graph to locate, then Read the specific file
→ NOT: reading entire directories hoping to find it---
Anti-Patterns
| Anti-Pattern | Do This Instead |
|---|---|
| Grepping for function names | search_graph with the function name |
| Reading entire files to find a signature | get_code_snippet for the specific symbol |
| Manually tracing import chains | trace_call_path or query_graph |
| Making changes without checking impact | detect_changes before every edit to shared code |
| Reading all files in a directory | get_architecture for structure, search_graph for specifics |
| Ignoring graph staleness warnings | Check index_status, re-index if needed |
| Re-indexing on every query | Trust the file watcher; only manual re-index after major restructure |
Related skills
FAQ
When should you use the graph vs grep?
Use the graph for symbol lookup, call tracing, and dependency queries; use grep for string literals, logs, and config values.
How does the graph stay current?
A file watcher and post-commit hook keep the graph in sync automatically.