Foreword¶
In early August 2026, an open-source project named Graphify (Graphify-Labs/graphify) kept appearing on GitHub Trending. According to the rankings from Trending8 on 2026-08-05, this project gained 600 to 900 new stars in a single day, and was widely discussed by developers alongside tags like Claude Code Skill and GraphRAG.
Its selling point is straightforward: In AI coding assistants such as Claude Code, Cursor, Codex, and Gemini CLI, just input /graphify to build a queryable knowledge graph from the current project’s code, documentation, SQL Schema, PDF and more. Afterwards, you can use commands like query, path, and explain to look up relationships, instead of repeatedly running grep or relying on embedding vector retrieval.
This article is organized based on the official repository README, documentation from graphify.net, and Trending ranking information, focusing on how it pushes “codebase understanding” from traditional vector RAG to structured GraphRAG, and how to quickly try it locally.
What is Graphify¶
Graphify is a Skill / CLI tool for AI coding assistants, maintained by Graphify-Labs. Its PyPI package name is graphifyy (note the double y), while the command line alias remains graphify.
The official description can be summarized in three sentences:
1. Multimodal input: Source code, Markdown, PDF, images, videos, and SQL Schema (requires the [sql] extension) can all be added to the same graph.
2. Local code parsing: Source code uses tree-sitter for deterministic AST extraction, no LLM calls are made, and data never leaves the local machine.
3. Graph instead of vector database: Outputs graph.json for traversal and querying, explicitly stating no embedding is used and no vector storage is required.
After the build is completed, three files are generated in the graphify-out/ directory by default:
graphify-out/
├── graph.html # Interactive browser view
├── GRAPH_REPORT.md # Core nodes, unexpected connections, suggested queries
└── graph.json # Persistent graph that can be queried repeatedly without re-reading source code
Why Some People See It as an “Alternative to Vector RAG”¶
The common workflow of traditional code RAG is: split files → vectorize → similarity retrieval → feed several chunks to the model. The problems with this approach are:
- The retrieval results are fragments, and cross-file call chains and inheritance relationships are easily truncated.
- Embedding similarity does not equal structural relevance, and questions like “who calls whom” are difficult to answer using cosine distance.
- Each session often re-reads files or re-performs retrieval, resulting in high context token overhead.
Graphify follows the GraphRAG / Knowledge Graph approach. In the FastAPI example given in the official README, you can directly execute:
$ graphify explain "APIRouter"
Node: APIRouter
Source: routing.py L2210
Community: 2
Degree: 47
Connections (47):
--> RequestValidationError [uses] [INFERRED]
--> .get() [method] [EXTRACTED]
<-- __init__.py [imports] [EXTRACTED]
...
$ graphify path "FastAPI" "ModelField"
Shortest path (3 hops):
FastAPI --uses--> DefaultPlaceholder <--references-- get_request_handler() --references--> ModelField
Each edge is labeled with EXTRACTED (explicitly present in the source code) or INFERRED (inferred by the tool), allowing queryors to distinguish between “read facts” and “guesses”. This differs significantly from vector retrieval, which returns “several similar paragraphs”, especially in terms of interpretability.
The official BENCHMARKS.md also published comparative data from LOCOMO, LongMemEval-S, etc. (for example, LOCOMO recall@10 scored 0.497), and emphasized that the graph construction phase uses zero LLM quota for code. Third-party articles (such as Augment Code’s introduction to v0.9.9) also mentioned that the token count for mixed corpus queries can be reduced from hundreds of thousands to thousands of levels — the specific value varies depending on the repository size, but the core idea of “build the graph first, then query the subgraph” is clear.
Core Mechanism: tree-sitter AST + Graph Clustering¶
1. Code Layer: Local Extraction with tree-sitter¶
Graphify’s first processing step for code is traversing the AST with tree-sitter. The official tree-sitter documentation page states that this phase has no LLM calls, no embedding, and no network requests.
The capabilities listed in the README include:
| Capability | Description |
|------|------|
| Cross-file linking | calls / imports / inherits / mixes_in, covering approximately 40 programming languages |
| Design rationale | Comments like # NOTE: and # WHY: are promoted to first-class nodes |
| Community partitioning | Runs the Leiden algorithm on the NetworkX graph to cluster subsystems without relying on vectors |
| God nodes | High-degree hub nodes that help quickly locate architectural centers |
Pure code repositories can be indexed completely offline using --code-only without needing an API key:
graphify extract ./raw --code-only
2. Documentation and SQL: Semantic Supplement¶
Documents, PDFs, images, etc. require semantic extraction using models already configured in the AI assistant; the official emphasizes that semantic descriptions rather than raw source code are sent. SQL Schema requires additional installation:
uv tool install "graphifyy[sql]"
# Or connect directly to PostgreSQL
uv tool install "graphifyy[postgres]"
graphify extract --postgres "postgresql://user:pass@host/db"
This allows application code, database table structures, and infrastructure configurations to exist in the same graph, eliminating the need to manually piece together grep results when answering questions like “which tables does the authentication module connect to”.
3. Output and Query Commands¶
Common Skill commands (within the assistant):
/graphify . # Build a knowledge graph for the current directory
/graphify query "what connects auth to the database?" # Natural language subgraph query
/graphify path "UserService" "DatabasePool" # Shortest path between two nodes
/graphify explain "RateLimiter" # Adjacent explanation for a single node
Equivalent CLI examples:
graphify query "show the auth flow"
graphify path "DigestAuth" "Response"
Installation and Integration with Claude Code, Cursor¶
Environment Requirements: Python 3.10+, it is recommended to use uv or pipx for isolated installation.
Step 1 — Install the CLI (the official PyPI package is graphifyy, do not confuse it with other packages of the same name):
uv tool install graphifyy
# Or: pipx install graphifyy
Step 2 — Register the Skill:
graphify install
Step 3 — Build the knowledge graph in the assistant:
/graphify .
Platform-specific commands (extracted from the official README):
| Platform | Installation Command |
|------|----------|
| Claude Code | graphify install |
| Cursor | graphify cursor install |
| Codex | graphify install --platform codex |
| Gemini CLI | graphify install --platform gemini |
Cursor will write an alwaysApply: true rule to .cursor/rules/graphify.mdc, guiding the assistant to prioritize graphify query over full-file grep. Claude Code also has an optional strict mode (graphify install --project --strict), which prevents the first bare reading of source code at the start of a session and forces a graph query first.
Teams can commit graphify-out/graph.json and GRAPH_REPORT.md, and others can directly load the graph in their assistants after cloning the repository without rebuilding it for each person. Combined with graphify hook install, automatic incremental updates can be performed after git commit.
Applicable Scenarios and Usage Notes¶
More suitable for:
- Taking over unfamiliar monoliths/microservices and needing to clarify module boundaries and call chains.
- Mixing code, SQL, documentation, and ADRs together, and needing to ask about “design reasons” rather than just “where the definition is”.
- Hoping to reduce token consumption caused by AI assistants repeatedly reading/grepping files.
Points to note:
1. Documentation/multimedia still require models: Pure offline use is available with --code-only; full multimodal support requires configuring existing API keys for the assistant.
2. The graph needs maintenance: After major structural changes, run /graphify . --update or rely on hooks to rebuild.
3. INFERRED edges require manual verification: The high value lies in EXTRACTED structural edges, and inferred edges should be cross-checked.
4. Trending popularity and star count: The rankings reflect recent growth rates; when evaluating a project, it is recommended to check releases, issues, and local testing rather than just star counts.
Summary¶
Graphify has turned a clear direction in the 2026 AI coding assistant field into an installable Skill: use tree-sitter to deterministically extract code structures locally, use a knowledge graph to carry cross-file relationships, and use interpretable edges instead of black-box vector similarity. It does not eliminate LLMs, but rather lets LLMs perform subgraph queries and reasoning on an existing “map”, representing a practical force for the evolution of code intelligence from “embedding retrieval” to “structured GraphRAG”.
If you are already using Claude Code or Cursor, install it in 30 seconds, run /graphify ., and open graphify-out/graph.html to view community coloring and God nodes — this is more intuitive than reading ten pages of README.
References
- Official Repository: https://github.com/Graphify-Labs/graphify
- Project Website: https://graphify.net/
- GitHub Trending Aggregator: https://trending8.vercel.app/