How Graphify Turns Your Chaotic Codebase Into a Queryable Brain for AI Assistants
Let's be honest: most of us have opened a codebase we haven't touched in months and immediately felt that familiar dread. You know the files are there. You vaguely remember the architecture. But connecting the dots? That's a archaeology project.
Graphify wants to change that—specifically for AI coding assistants.
What Is Graphify, Anyway?
Graphify is an open-source skill that builds a queryable knowledge graph from your entire codebase. We're talking source code, documentation, research papers, and even diagrams—all merged into a single, searchable graph that explains both what your code does and why it was designed that way.
Think of it as giving your AI assistant a map of your project instead of just a pile of files.
The tool was created by Safi Shamsi and released under the MIT license. It runs on solid, well-established foundations: NetworkX for graph operations and Tree-sitter for static code analysis.
The Multi-Modal Magic
Here's what makes Graphify interesting: it doesn't just parse code. It handles multiple input types:
- Source code (.py, .js, .go, .java, and more) — Tree-sitter extracts abstract syntax trees, call graphs, and docstrings
- Markdown and PDFs — LLM-driven extraction pulls concepts from prose
- Diagrams and images — Vision models actually read your architecture diagrams
This multi-modal approach means you're not just getting a call graph. You're getting semantic relationships between concepts across different file types and formats.
From Messy Repo to Interactive Graph
The pipeline is straightforward but powerful:
- Detect & Collect — Find all relevant files
- Extract — Pull ASTs and semantic nodes/edges
- Build — Create a NetworkX graph
- Cluster — Apply the Leiden algorithm for community detection
- Analyze — Identify "god nodes" (high-centrality files) and unexpected connections
- Report — Generate readable output
The community detection part is particularly clever. Instead of relying on vector embeddings (which can be expensive and fuzzy), Graphify uses the Leiden algorithm to group related code into semantic clusters. No embedding model required.
God Nodes and "Surprises"
One feature that caught my attention: Graphify identifies what it calls "god nodes"—the files or components with the highest connectivity in your graph. These are typically your core classes, main entry points, or critical shared utilities.
More interestingly, it flags "surprises"—unexpected cross-file or cross-domain connections that might indicate design issues, undocumented dependencies, or areas worth investigating.
In one of their worked examples with the httpx library, Graphify found a surprise connection between DigestAuth and Response. That's the kind of relationship that's not obvious from reading individual files but becomes crystal clear when visualized as a graph.
The Token Efficiency Argument
Here's a number worth remembering: in their mixed corpus benchmark (GPT framework repos plus research papers), Graphify achieved a 71.5× reduction in token usage compared to naive context injection approaches.
That's not trivial. When you're paying per token for AI API calls, cutting query costs by that margin matters. And it's not just about money—smaller context windows mean faster responses and less hallucination risk.
Security That Doesn't Get Ignored
Open-source tools that fetch URLs and process code need to take security seriously. Graphify appears to do this:
- Only allows http/https URLs
- Size and timeout limits on downloads
- Path containment checks (no directory traversal)
- HTML escaping on all node labels
- No telemetry or third-party data collection
Your code never leaves your environment. Graphify only sends semantic descriptions (not raw source) to your configured AI model.
How It Integrates With AI Assistants
Graphify ships with simple commands for Claude Code, Codex, and OpenCode:
/graphify— Build a new graph/graphify query <question>— Ask questions about your codebase/graphify path <file>— Focus on specific paths/graphify explain— Get explanations of the graph structure
Output includes an interactive graph.html visualization, a graph.json for programmatic access, and a GRAPH_REPORT.md audit file.
Installation
If you want to try it:
pip install graphifyy
graphify install
graphify ./your-project
Requirements: Python 3.10+ and an API key configured for your preferred AI model (Claude, OpenAI, etc.).
Where Graphify Fits in the Ecosystem
It's not trying to replace Sourcegraph's enterprise code search or Neo4j's general-purpose graph database. Instead, Graphify occupies an interesting middle ground:
- More semantic than static analysis tools
- More structured than vector-based retrieval
- Purpose-built for AI assistant context injection
For developers working with AI coding assistants on complex projects—especially mixed codebases with documentation and research—this fills a genuine gap.
The Bigger Picture
Tools like Graphify represent a broader trend: AI assistants that don't just generate code, but actually understand the systems they're working with. A knowledge graph isn't just a visualization trick—it's a reasoning structure that can support more accurate, context-aware suggestions.
Whether Graphify becomes the standard for AI code understanding remains to be seen. But the problem it's solving is real. Codebases are complex, interconnected systems. Maybe they deserve graph-based tools instead of file-tree navigators.
If you've been struggling to get AI assistants to understand your project's architecture, Graphify might be worth an afternoon experiment.
Have you tried knowledge graph tools for code understanding? Share your experience in the comments.