ashokvarmamatta/graphify-mcp-guide.md

🧠 Make Your AI Coding Assistant 500x Smarter

Stop Burning Tokens — Use Knowledge Graphs + MCP to Give AI a Map of Your Code

📖 What This Guide Covers

Your AI assistant reads your ENTIRE codebase every time you ask a question.
That's slow, expensive, and dumb.

This guide gives your AI a MAP of your code — so it looks up answers
instead of reading everything from scratch.

         ┌──────────────────────────────────┐
         │  1. What is MCP?                 │  ← The "USB port" for AI
         │  2. Install graphify             │  ← Builds the knowledge graph
         │  3. Install code-review-graph    │  ← Fast code-only MCP server
         │  4. Connect via MCP              │  ← Wire it to Claude Code
         │  5. Automate updates             │  ← Graph stays fresh forever
         │  6. Use it                       │  ← 500x less tokens
         └──────────────────────────────────┘

🤔 Wait, What is MCP?

MCP = Model Context Protocol

Think of it like a USB port for AI.

USB lets ANY device talk to ANY computer:

  🖨️ Printer ──┐
  📷 Camera  ──┤── USB ──── 💻 Computer
  🎮 Gamepad ──┘

MCP lets ANY tool talk to ANY AI assistant:

  📊 Graph DB    ──┐
  💬 Slack       ──┤── MCP ──── 🤖 AI Assistant
  📁 Code Graph  ──┘

Without MCP:

You: "How does LlmRouter work?"

AI: "Let me read... *reads 143 files* ... *burns 362,000 tokens* ... here's what I found"
    ⏱️ 30 seconds
    💰 $$$ tokens burned

With MCP:

You: "How does LlmRouter work?"

AI: "Let me check the graph..."
    → query_graph("callers_of", "LlmRouter")
    → gets back 10 precise connections in 0.2 seconds
    "LlmRouter has 47 connections. It's called by WebChatServer, ZeroClawService..."
    ⏱️ 2 seconds
    💰 ~700 tokens (that's 500x less!)

The Restaurant Analogy 🍕

WITHOUT MCP (reading files):
┌──────────────────────────────────────────┐
│                                          │
│  You walk into a restaurant.             │
│  There's no menu.                        │
│  You go to the kitchen.                  │
│  You open EVERY fridge.                  │
│  You read EVERY ingredient label.        │
│  Then you decide what to order.          │
│                                          │
│  That's your AI reading your codebase.   │
│                                          │
└──────────────────────────────────────────┘

WITH MCP (using graph):
┌──────────────────────────────────────────┐
│                                          │
│  You walk into a restaurant.             │
│  There's a MENU on the table.            │
│  You pick what you want.                 │
│  Done.                                   │
│                                          │
│  The graph IS the menu.                  │
│  MCP IS the waiter.                      │
│                                          │
└──────────────────────────────────────────┘

🧩 The Two Tools (And Why You Need Both)

┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│   graphify                        code-review-graph             │
│   ════════                        ═════════════════             │
│                                                                 │
│   📚 The FULL picture             ⚡ The FAST picture           │
│                                                                 │
│   ✅ Code (functions, classes)    ✅ Code (functions, classes)  │
│   ✅ Docs (README, guides)        ❌ No docs                   │
│   ✅ Images (screenshots)         ❌ No images                  │
│   ✅ Bugs & plans                 ❌ No docs                    │
│   ✅ Semantic connections         ❌ Only structural            │
│   ✅ Community clusters           ❌ Basic clusters             │
│   ✅ Interactive HTML viz         ✅ HTML viz                   │
│                                                                 │
│   🐌 Needs LLM for docs/images   ⚡ Pure AST, no LLM needed   │
│   📊 1,479 nodes example          📊 1,411 nodes example       │
│                                                                 │
│   Best for:                       Best for:                     │
│   "How does feature X relate      "Who calls this function?"    │
│    to the bug in BUGS.md?"        "What imports this class?"    │
│                                   "Impact of changing this?"    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

USE BOTH. They complement each other.
code-review-graph = your quick dictionary
graphify = your full encyclopedia

📦 Step 1 — Install Everything

1a. Install graphify

pip install graphifyy

Yes, it's graphifyy with two y's on PyPI.

1b. Install code-review-graph

pip install code-review-graph

1c. Verify both installed

graphify --version
code-review-graph --help

You should see version info and help text. If not, make sure Python is in your PATH.

🔨 Step 2 — Build Your First Graph

2a. Build the graphify knowledge graph

Navigate to your project root and run:

cd /path/to/your/project

Then in Claude Code (or any AI assistant with graphify skill):

/graphify .

This will:

Detect all files (code, docs, images)
Parse code via AST (free, no LLM)
Extract concepts from docs/images (uses LLM)
Build a graph with nodes + edges
Cluster into communities
Generate graphify-out/graph.html (interactive viz!)

What happens:

  Your Project                          graphify-out/
  ├── src/                              ├── graph.json      ← The graph data
  │   ├── auth.kt        ──────►       ├── graph.html      ← Open in browser!
  │   ├── router.kt      ──────►       ├── GRAPH_REPORT.md ← Audit report
  │   └── database.kt    ──────►       └── cost.json       ← Token usage
  ├── README.md           ──────►
  ├── BUGS.md             ──────►
  └── screenshots/        ──────►
        All files become graph nodes
        with edges showing relationships

2b. Build the code-review-graph

code-review-graph build

This is instant — it only parses code via AST (no LLM needed):

$ code-review-graph build
INFO: Progress: 50/140 files parsed
INFO: Progress: 100/140 files parsed
INFO: Progress: 140/140 files parsed
Full build: 140 files, 1411 nodes, 2801 edges

2c. Open the graph in your browser

# graphify interactive visualization
open graphify-out/graph.html    # macOS
start graphify-out/graph.html   # Windows
xdg-open graphify-out/graph.html # Linux

You'll see something like this:

    ┌─────────────────────────────────────────────┐
    │                                             │
    │    ○ LlmRouter                              │
    │   /|\                                       │
    │  / | \                                      │
    │ ○  ○  ○  WebChat  KeyManager  ToolSystem    │
    │ |  |  |                                     │
    │ ○  ○  ○  Service  Agents  OfflineModel      │
    │                                             │
    │   Nodes colored by community                │
    │   Click any node to see connections          │
    │   Zoom, pan, drag                           │
    │                                             │
    └─────────────────────────────────────────────┘

🔌 Step 3 — Connect to Your AI via MCP

What are we doing here?

Right now:

  Claude Code ──── ??? ──── Your graph
  (can't see the graph)

After this step:

  Claude Code ──── MCP ──── code-review-graph server ──── Fast code lookups
       │
       └────────── MCP ──── graphify server ──────────── Full knowledge graph

3a. Create `.mcp.json` in your project root

Create a file called .mcp.json (note the dot!) in your project's root directory:

{
  "mcpServers": {
    "code-review-graph": {
      "command": "code-review-graph",
      "args": ["serve"],
      "type": "stdio"
    },
    "graphify": {
      "command": "python",
      "args": ["-m", "graphify.serve", "graphify-out/graph.json"],
      "type": "stdio"
    }
  }
}

That's it. Claude Code reads .mcp.json on startup and connects to both servers automatically.

3b. What each server provides

code-review-graph MCP tools:

Tool	What it does	Example
`semantic_search_nodes`	Find code by keyword	"Find all auth-related classes"
`query_graph`	Trace relationships	"Who calls LlmRouter?"
`get_impact_radius`	Blast radius of a change	"What breaks if I change this?"
`detect_changes`	Risk-scored code review	"Review my last commit"
`get_review_context`	Token-efficient snippets	"Show me relevant code for review"
`get_affected_flows`	Execution path analysis	"Which flows does this change affect?"

graphify MCP tools:

Tool	What it does	Example
`query_graph`	Search the full graph	"How does auth relate to the API?"
`get_node`	Get node details	"Tell me about OfflineModelManager"
`get_neighbors`	Find connected nodes	"What's connected to LlmRouter?"
`get_community`	See a cluster	"Show me the memory subsystem"
`god_nodes`	Most connected nodes	"What are the core abstractions?"
`graph_stats`	Graph overview	"How big is the graph?"
`shortest_path`	Find path between concepts	"How does auth connect to database?"

3c. Restart Claude Code

# Close and reopen Claude Code, or start a new session
# The MCP servers will connect automatically

3d. Verify it works

In your new Claude Code session, ask:

"What are the most connected nodes in this codebase?"

If it uses MCP tools (you'll see tool calls like god_nodes or semantic_search_nodes) instead of running Grep/Read on your files — it's working!

BEFORE MCP (what you DON'T want to see):
┌────────────────────────────────────────┐
│  🔍 Grep("class.*Router", **/*.kt)    │  ← Reading files
│  📖 Read(src/LlmRouter.kt)            │  ← Reading files
│  📖 Read(src/ProviderRouter.kt)        │  ← Reading files
│  📖 Read(src/WebChatServer.kt)         │  ← More files...
│                                        │
│  💰 Used: ~50,000 tokens              │
└────────────────────────────────────────┘

AFTER MCP (what you WANT to see):
┌────────────────────────────────────────┐
│  🔌 query_graph("callers_of",          │  ← Graph lookup!
│       "LlmRouter")                     │
│                                        │
│  💰 Used: ~700 tokens                 │
└────────────────────────────────────────┘

🤖 Step 4 — Automate Everything (Set and Forget)

This is the magic part. After this, your graphs update themselves every time you commit code.

4a. Install the graphify git hook

graphify hook install

Output:

post-commit: appended to .git/hooks/post-commit
post-checkout: appended to .git/hooks/post-checkout

4b. Add code-review-graph to the same hook

Open .git/hooks/post-commit and add at the bottom:

# code-review-graph: incremental update for MCP server
if command -v code-review-graph >/dev/null 2>&1; then
    code-review-graph update 2>/dev/null || true
fi

4c. What happens now on every commit

You type: git commit -m "add new feature"

                    ┌──────────────┐
                    │  git commit  │
                    └──────┬───────┘
                           │
                    ┌──────▼───────┐
                    │ post-commit  │
                    │    hook      │
                    └──────┬───────┘
                           │
              ┌────────────┼────────────┐
              ▼                         ▼
    ┌─────────────────┐     ┌──────────────────────┐
    │    graphify      │     │  code-review-graph   │
    │                  │     │                      │
    │ Re-extracts only │     │ Re-parses only       │
    │ CHANGED files    │     │ CHANGED files        │
    │ (AST, no LLM)   │     │ (AST, no LLM)        │
    │                  │     │                      │
    │ Updates:         │     │ Updates:             │
    │ graph.json       │     │ internal graph       │
    │ GRAPH_REPORT.md  │     │ MCP serves new data  │
    └─────────────────┘     └──────────────────────┘

    ⚡ Both take < 5 seconds for code-only changes
    ⚡ No LLM tokens consumed
    ⚡ No internet needed
    ⚡ Completely automatic

4d. What about docs and images?

Code changes auto-update (AST parsing, free). Docs/images need LLM — run manually when you update docs:

/graphify . --update

This only re-extracts new/changed files (cached results are reused):

$ /graphify . --update
Cache: 165 files hit, 2 files need extraction
Semantic extraction: ~2 files → 1 agent, estimated ~45s
...done!

4e. Manual update (no commit needed)

Don't want to commit just to update the graph? Run these anytime:

# Update code-review-graph (instant, no LLM)
code-review-graph update

# Or full rebuild from scratch
code-review-graph build

For graphify, in Claude Code:

/graphify . --update

┌──────────────────────────────────────────────────────────────┐
│                                                              │
│   HOW THE GRAPH STAYS FRESH                                  │
│                                                              │
│   Option 1: Automatic (git commit)                           │
│   ════════════════════════════════                            │
│   git commit → hook runs → both graphs update                │
│   You do nothing. It just works.                             │
│                                                              │
│   Option 2: Manual (anytime)                                 │
│   ═════════════════════════                                   │
│   code-review-graph update    ← run in terminal              │
│   /graphify . --update        ← run in Claude Code           │
│   No commit needed. Run after any edit.                      │
│                                                              │
│   Option 3: Full rebuild (switch branch, big changes)        │
│   ═════════════════════════════════════════════════           │
│   code-review-graph build     ← rebuild from scratch         │
│   /graphify .                 ← full rebuild in Claude Code  │
│                                                              │
└──────────────────────────────────────────────────────────────┘

Summary: What's automatic vs manual

Change Type	Auto-updates?	Cost
New `.kt` / `.java` / `.py` file	✅ On commit	Free (AST)
Modified code file	✅ On commit	Free (AST)
New/changed `.md` / `.txt` doc	❌ Manual: `/graphify . --update`	LLM tokens
New screenshot / image	❌ Manual: `/graphify . --update`	LLM tokens

📊 Step 5 — See the Token Savings

After graphify builds, it prints a benchmark:

graphify token reduction benchmark
──────────────────────────────────────────────────
  Corpus:          271,756 words → ~362,341 tokens (naive)
  Graph:           1,479 nodes, 1,326 edges
  Avg query cost:  ~706 tokens
  Reduction:       513.2x fewer tokens per query

  Per question:
    [787.7x] how does authentication work
    [469.4x] what is the main entry point
    [332.1x] how are errors handled
    [827.3x] what connects the data layer to the api
    [469.4x] what are the core abstractions

What does 500x mean in practice?

Without graph:
  10 questions × 362,341 tokens = 3,623,410 tokens
  💰 ~$10-15 in API costs

With graph:
  10 questions × 706 tokens = 7,060 tokens
  💰 ~$0.02 in API costs

  That's like paying $0.02 instead of $10.
  For the SAME answers.
  Actually BETTER answers (structural context).

🎯 Real Usage Examples

Example 1: "What does LlmRouter do?"

WITHOUT graph:
  AI reads LlmRouter.kt (500 lines)
  AI reads every file that imports it (20+ files)
  AI reads docs mentioning it
  Total: ~50,000 tokens, 30 seconds

WITH graph:
  AI calls: get_node("LlmRouter")
  AI calls: get_neighbors("LlmRouter")
  Gets back: 47 connections, callers, callees, related docs
  Total: ~700 tokens, 2 seconds

Example 2: "What breaks if I change OfflineModelManager?"

WITHOUT graph:
  AI greps for "OfflineModelManager" in all files
  AI reads each file to understand the dependency
  AI guesses at impact
  Total: ~30,000 tokens, maybe misses indirect deps

WITH graph:
  AI calls: get_impact_radius("OfflineModelManager")
  Gets back: direct deps, transitive deps, affected flows, test coverage
  Total: ~500 tokens, complete picture

Example 3: "Review my last commit"

WITHOUT graph:
  AI reads the diff
  AI reads surrounding code for context
  AI reads test files
  Total: ~40,000 tokens

WITH graph:
  AI calls: detect_changes()
  Gets back: risk score, affected communities, missing test coverage
  AI calls: get_review_context() for only the risky parts
  Total: ~2,000 tokens, better review

🗂️ Project Structure After Setup

your-project/
├── .mcp.json                    ← MCP server config (commit this!)
├── .gitignore                   ← Add: graphify-out/
├── .git/hooks/post-commit       ← Auto-update hook
├── graphify-out/                ← ⚠️ GITIGNORED
│   ├── graph.json               ← The knowledge graph
│   ├── graph.html               ← Interactive visualization
│   ├── GRAPH_REPORT.md          ← Audit report (god nodes, surprises)
│   └── cost.json                ← Token usage tracker
├── src/
│   └── ... your code ...
└── README.md

What to commit, what to gitignore

File	Commit?	Why
`.mcp.json`	✅ Yes	Team members get MCP servers too
`graphify-out/`	❌ No	Generated, can be rebuilt
`.git/hooks/`	❌ No	Local only (each dev runs `graphify hook install`)

Add to your .gitignore:

# Knowledge graph outputs (rebuild with: /graphify . )
graphify-out/

🚀 Quick Start — Set Up ANY Project in 2 Minutes

Copy-paste these commands in your project root:

# 1. Install (one-time, works for all projects)
pip install graphifyy code-review-graph

# 2. Build the code-review-graph (instant, no LLM)
code-review-graph build

# 3. Create MCP config for your AI editor
cat > .mcp.json << 'EOF'
{
  "mcpServers": {
    "code-review-graph": {
      "command": "code-review-graph",
      "args": ["serve"],
      "type": "stdio"
    },
    "graphify": {
      "command": "python",
      "args": ["-m", "graphify.serve", "graphify-out/graph.json"],
      "type": "stdio"
    }
  }
}
EOF

# 4. Install auto-update git hooks
graphify hook install

# 5. Add code-review-graph to the same hook
cat >> .git/hooks/post-commit << 'HOOK'

# code-review-graph: incremental update for MCP server
if command -v code-review-graph >/dev/null 2>&1; then
    code-review-graph update 2>/dev/null || true
fi
HOOK

# 6. Gitignore the output
echo -e "\n# Knowledge graph outputs\ngraphify-out/" >> .gitignore

# 7. Auto-configure your AI editor (pick ONE):
graphify claude install       # Claude Code
graphify cursor install       # Cursor
graphify gemini install       # Gemini CLI / Android Studio Gemini
graphify antigravity install  # Google Antigravity
graphify codex install        # OpenAI Codex
graphify copilot install      # GitHub Copilot CLI
graphify opencode install     # OpenCode
graphify aider install        # Aider
graphify droid install        # Factory Droid
graphify claw install         # OpenClaw
graphify trae install         # Trae
graphify trae-cn install      # Trae CN

8. Build the graphify knowledge graph

In Claude Code, just type:

/graphify .

This is a Claude Code skill (slash command). It reads all your code, docs, and images, then builds the full knowledge graph.

Not using Claude Code? You can still build the code graph (no LLM needed):

code-review-graph build

This gives you the AST-based graph with MCP. The full graphify graph (with docs/images/semantic connections) requires /graphify . in Claude Code or another AI editor with the graphify skill installed.

9. Start a new session

Close and reopen your AI editor. The MCP servers load on startup. Done!

┌────────────────────────────────────────────────────┐
│                                                    │
│  ✅ code-review-graph MCP    → code lookups        │
│  ✅ graphify MCP             → full knowledge graph│
│  ✅ git hook                 → auto-updates        │
│  ✅ CLAUDE.md / .cursorrules → AI knows to use it  │
│                                                    │
│  Your AI is now 500x smarter. For every project.   │
│                                                    │
└────────────────────────────────────────────────────┘

🔄 Setting Up Your NEXT Project

Already did the Quick Start once? For each new project, it's even faster:

cd /path/to/new/project

# Build + configure (30 seconds)
code-review-graph build
graphify hook install
graphify claude install    # or: cursor, gemini, antigravity, codex, copilot, etc.

# Create MCP config
cat > .mcp.json << 'EOF'
{
  "mcpServers": {
    "code-review-graph": {
      "command": "code-review-graph",
      "args": ["serve"],
      "type": "stdio"
    },
    "graphify": {
      "command": "python",
      "args": ["-m", "graphify.serve", "graphify-out/graph.json"],
      "type": "stdio"
    }
  }
}
EOF

echo -e "\ngraphify-out/" >> .gitignore

# Add code-review-graph to hook
cat >> .git/hooks/post-commit << 'HOOK'

if command -v code-review-graph >/dev/null 2>&1; then
    code-review-graph update 2>/dev/null || true
fi
HOOK

# Then in Claude Code: /graphify .

That's it — 30 seconds per project after the first time.

🌐 Multi-Project Setup — Query ALL Your Projects From ONE Session

💡 The Problem: You graphified Project A and Project B separately. But when you open Claude Code in Project A, it only sees Project A's graph. How do you query both?

✅ The Solution: Set MCP servers globally so they're available in EVERY session, from ANY folder.

🤔 Local vs Global — What's the Difference?

LOCAL (.mcp.json in project folder)          GLOBAL (~/.claude.json in home folder)
═══════════════════════════════════          ════════════════════════════════════

  📁 Project-A/                                🏠 ~/.claude.json
  │  └── .mcp.json                             │
  │       └── graphify-A  ✅                    ├── graphify-A  ✅
  │                                             ├── graphify-B  ✅
  📁 Project-B/                                 └── graphify-C  ✅
  │  └── .mcp.json
  │       └── graphify-B  ✅                   Open Claude Code ANYWHERE:
  │                                             → ALL graphs available ✅
  Open Claude Code in Project-A:
  → Only sees graphify-A ❌
  → Can't query Project-B ❌

🚀 Step 1 — Graphify Each Project First

# Project A
cd /path/to/project-A
code-review-graph build
# In Claude Code: /graphify .

# Project B
cd /path/to/project-B
code-review-graph build
# In Claude Code: /graphify .

# Project C ... repeat for each project

🔗 Step 2 — Register All Projects in code-review-graph

# code-review-graph has BUILT-IN multi-repo support 🎉
code-review-graph register "/path/to/project-A" --alias projectA
code-review-graph register "/path/to/project-B" --alias projectB
code-review-graph register "/path/to/project-C" --alias projectC

# Check what's registered
code-review-graph repos

┌──────────────────────────────────────────────────────────┐
│                                                          │
│  $ code-review-graph repos                               │
│                                                          │
│  ✅ projectA  → /path/to/project-A  (1,411 nodes)       │
│  ✅ projectB  → /path/to/project-B  (892 nodes)         │
│  ✅ projectC  → /path/to/project-C  (2,100 nodes)       │
│                                                          │
│  ONE MCP server. ALL projects. 🔥                        │
│                                                          │
└──────────────────────────────────────────────────────────┘

🎯 That's it for code-review-graph! The single code-review-graph serve MCP server now queries ALL registered repos automatically.

🧠 Step 3 — Set graphify MCP Globally

For graphify, add each project's graph server to your global ~/.claude.json:

Tell your AI assistant:

"Set up global MCP servers for all my graphified projects"

Or manually add to ~/.claude.json:

{
  "mcpServers": {
    "code-review-graph": {
      "command": "code-review-graph",
      "args": ["serve"],
      "type": "stdio"
    },
    "graphify-projectA": {
      "command": "python",
      "args": ["-m", "graphify.serve", "/path/to/project-A/graphify-out/graph.json"]
    },
    "graphify-projectB": {
      "command": "python",
      "args": ["-m", "graphify.serve", "/path/to/project-B/graphify-out/graph.json"]
    },
    "graphify-projectC": {
      "command": "python",
      "args": ["-m", "graphify.serve", "/path/to/project-C/graphify-out/graph.json"]
    }
  }
}

⚠️ Important: Each graphify server needs a unique name (graphify-projectA, graphify-projectB, etc.)

✅ Result — Everything Connected

┌──────────────────────────────────────────────────────────────────┐
│                                                                  │
│         🌐 OPEN CLAUDE CODE FROM ANY FOLDER                      │
│                                                                  │
│                    ┌─────────────────┐                           │
│                    │   Claude Code   │                           │
│                    │   (any folder)  │                           │
│                    └────────┬────────┘                           │
│                             │                                    │
│              Global MCP Servers Load Automatically               │
│                             │                                    │
│         ┌───────────────────┼───────────────────┐               │
│         │                   │                   │               │
│         ▼                   ▼                   ▼               │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │ 📱 Project A │  │ 🌐 Project B │  │ 🎮 Project C │          │
│  │              │  │              │  │              │          │
│  │ graphify-A   │  │ graphify-B   │  │ graphify-C   │          │
│  │ code-review  │  │ code-review  │  │ code-review  │          │
│  │              │  │              │  │              │          │
│  │ 1,411 nodes  │  │ 892 nodes    │  │ 2,100 nodes  │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
│                                                                  │
│  🔍 "How does auth work in Project A?"  → queries graphify-A    │
│  🔍 "Compare Project B's DB to C's"    → queries both B and C   │
│  🔍 "Impact of changing this class?"    → queries code-review    │
│                                                                  │
│         ALL PROJECTS. ANY SESSION. ZERO SETUP PER SESSION.       │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

📊 Quick Reference

┌─────────────────────┬──────────────────────┬────────────────────────┐
│       Tool          │  Multi-Project How?  │  Where to Configure    │
├─────────────────────┼──────────────────────┼────────────────────────┤
│                     │                      │                        │
│  code-review-graph  │  Built-in!           │  code-review-graph     │
│                     │  register command    │  register <path>       │
│                     │  1 server = N repos  │                        │
│                     │                      │                        │
│  graphify           │  1 server per        │  ~/.claude.json        │
│                     │  project             │  (global mcpServers)   │
│                     │  unique name each    │                        │
│                     │                      │                        │
└─────────────────────┴──────────────────────┴────────────────────────┘

💡 Pro tip: After graphifying a new project, just add one more graphify-newproject entry to ~/.claude.json and restart Claude Code. That's it — the new project is connected to all your sessions.

❓ FAQ

Q: Does this work with Cursor / Windsurf / other AI editors?

Yes! graphify supports 12 AI editors/agents out of the box:

┌──────────────────────────────────────────────────────────────────────┐
│                                                                      │
│  EDITOR / AGENT             INSTALL COMMAND          WHAT IT WRITES  │
│  ═══════════════            ═══════════════          ══════════════  │
│                                                                      │
│  Claude Code                graphify claude install     CLAUDE.md    │
│  Cursor                     graphify cursor install     .cursorrules │
│  Gemini CLI / Android Studio graphify gemini install    GEMINI.md    │
│  Google Antigravity         graphify antigravity install .agent/     │
│  OpenAI Codex               graphify codex install      AGENTS.md   │
│  GitHub Copilot CLI         graphify copilot install    ~/.copilot/  │
│  OpenCode                   graphify opencode install   AGENTS.md   │
│  Aider                      graphify aider install      AGENTS.md   │
│  Factory Droid              graphify droid install       AGENTS.md   │
│  OpenClaw                   graphify claw install        AGENTS.md   │
│  Trae                       graphify trae install        AGENTS.md   │
│  Trae CN                    graphify trae-cn install     AGENTS.md   │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

MCP is a standard protocol. The .mcp.json config works with any editor that supports MCP.

Android Studio users: If you use Gemini in Android Studio, run graphify gemini install. The MCP config (.mcp.json) is project-level so the code-review-graph server is available too.

Q: What languages are supported?

code-review-graph: Kotlin, Java, Python, TypeScript, JavaScript, Go, Rust, C/C++, Ruby, Swift, Scala, PHP, Lua — anything with AST parsing.

graphify: ALL files. Code via AST, docs/images via LLM semantic extraction.

Q: Does this cost money?

code-review-graph: 100% free. Pure AST parsing, no LLM.
graphify AST extraction: Free. No LLM needed for code files.
graphify semantic extraction: Uses your AI tokens for docs/images only. One-time cost, then cached.
Auto-updates on commit: Free (AST only for code changes).

Q: My graph is out of date after switching branches

code-review-graph build          # rebuild from scratch (instant)
# Then in Claude Code:
# /graphify . --update           # incremental update (only changed files)

Q: Can I query the graph without Claude Code?

Yes! graphify has a built-in CLI:

graphify query "how does authentication work?"
graphify query "how does authentication work?" --dfs    # depth-first trace
graphify query "how does authentication work?" --budget 1500  # limit tokens

And in Claude Code, you can use slash commands:

/graphify query "how does authentication work?"
/graphify path "AuthModule" "Database"
/graphify explain "LlmRouter"

Q: How big can the graph get?

Tested with 1,500+ nodes and 2,800+ edges without issues. The HTML visualization handles up to 5,000 nodes. Beyond that, use Obsidian vault (/graphify . --obsidian).

🔧 Troubleshooting

Problem	Fix
`graphify: command not found`	`pip install graphifyy` (two y's!)
`code-review-graph: command not found`	`pip install code-review-graph`
MCP tools not showing in Claude Code	Restart session (MCP loads at startup)
Graph out of date	Run `code-review-graph build` + in Claude Code: `/graphify . --update`
`UnicodeEncodeError` on Windows	Set `PYTHONUTF8=1` environment variable
HTML viz won't open	Try: `python -m http.server 8080` in `graphify-out/`, open `localhost:8080/graph.html`
Hook not running on commit	Check: `ls -la .git/hooks/post-commit` (must be executable)
`Graph was built on different branch`	Run `code-review-graph build` to rebuild

🎁 Bonus: The Full Picture

┌──────────────────────────────────────────────────────────────────┐
│                                                                  │
│                    YOUR DEVELOPMENT WORKFLOW                      │
│                                                                  │
│  ┌──────────┐     ┌──────────┐     ┌──────────┐                │
│  │  Write    │────►│  Commit  │────►│  Hook    │                │
│  │  Code     │     │  (git)   │     │  Runs    │                │
│  └──────────┘     └──────────┘     └─────┬────┘                │
│                                          │                       │
│                            ┌─────────────┼─────────────┐        │
│                            ▼                           ▼        │
│                   ┌────────────────┐        ┌─────────────────┐ │
│                   │   graphify     │        │ code-review-    │ │
│                   │   updates      │        │ graph updates   │ │
│                   │   graph.json   │        │ internal graph  │ │
│                   └───────┬────────┘        └────────┬────────┘ │
│                           │                          │          │
│                           ▼                          ▼          │
│                   ┌────────────────┐        ┌─────────────────┐ │
│                   │   graphify     │        │ code-review-    │ │
│                   │   MCP server   │        │ graph MCP       │ │
│                   │   (full graph) │        │ server (fast)   │ │
│                   └───────┬────────┘        └────────┬────────┘ │
│                           │                          │          │
│                           └──────────┬───────────────┘          │
│                                      │                          │
│                                      ▼                          │
│                             ┌────────────────┐                  │
│                             │  Claude Code   │                  │
│                             │  / Cursor /    │                  │
│                             │  Any AI Editor │                  │
│                             └────────────────┘                  │
│                                      │                          │
│                                      ▼                          │
│                             ┌────────────────┐                  │
│                             │  500x FASTER   │                  │
│                             │  500x CHEAPER  │                  │
│                             │  BETTER ANSWERS│                  │
│                             └────────────────┘                  │
│                                                                  │
└──────────────────────────────────────────────────────────────────┘

Made with 🧠 by Ashok Varma Matta

If this saved you time, star the gist and share it with your team!