More than 130,000 GitHub stars as of October 21, 2026: Graphify has become one of the most popular tools for coding agents. Its pitch is that your agent stops running grep and reading files one by one, and instead queries a knowledge graph of the project that is built locally, with no LLM involved for code.
What it is
Graphify is a Python CLI (package graphifyy, double y) that ships with a skill for Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot and more than twenty other assistants. Running /graphify . walks the project and produces three files in graphify-out/: graph.json with the full graph, graph.html to explore it in a browser, and GRAPH_REPORT.md with the key concepts and the most surprising connections.
Under the hood there are two passes:
- Code: parsed with the tree-sitter AST across about 40 languages, resolving
calls,importsand inheritance across files. It's deterministic, uses no LLM, and nothing leaves your machine. - Docs, PDFs, images and video: these need a model for semantic extraction, either your assistant's or one behind a configured API.
It isn't a vector index: there are no embeddings, just a graph you traverse. Every edge is tagged EXTRACTED (explicit in the source) or INFERRED (resolved by Graphify), and the graph is split into communities with the Leiden algorithm to separate subsystems. # NOTE: and # WHY: comments and ADR or RFC references become nodes linked to the code. The license is Apache-2.0, and the repo also ships an MIT license file.
How to use it
It needs Python 3.10 or later and uv (or pipx):
uv tool install graphifyy # the CLI
graphify install # detects your assistant and registers the skillThen run /graphify . in the assistant, and from there on you query the graph instead of the files:
graphify explain "APIRouter" # one concept and its connections
graphify path "FastAPI" "ModelField" # how two things relate
graphify query "where is the token validated?"
graphify hook install # rebuild on commit and branch checkoutgraphify claude install sets the project up so Claude Code always uses the graph: a hook fires before searches, and before reading files with Read or Glob, and nudges the agent toward a graph query. Codex, Cursor and others get the same through instruction files such as AGENTS.md.
One install warning: the README stresses that the official package is graphifyy, and other graphify* packages on PyPI aren't affiliated. A typo in the name can install something else entirely.
What I like and what I don't
I like that the code pass is local and deterministic: you can index a private repo without sending it to any provider, and --code-only or GRAPHIFY_BACKEND=none guarantees no LLM gets called. I also like that it separates extracted from inferred edges, which is exactly what you need to trust an agent's answer. And it sends no telemetry.
What I'm less sold on:
- The benchmarks are its own, and some are tiny. On LOCOMO (300 questions) it reaches 0.497 recall@10, but on answer accuracy it trails supermemory (45.3% vs 49.7%). On LongMemEval-S it ties with dense RAG (76%), and the gain over
grepplus file reads (82.0% vs 70.8%) comes from just 6 tasks. - Automatic provider selection. If
graphify extractfinds several API keys in the environment, it picks one by priority (Gemini first), and the README warns that Kimi routes to servers in China. For code with data-residency requirements, set--backendor use Ollama. - The query log. Every
query,pathandexplaincall is logged to~/.cache/graphify-queries.log, question included. Turn it off withGRAPHIFY_QUERY_LOG_DISABLE=1. - The commercial push. The README spends a lot of space on Graphify Cloud, the paid version with a continuously updated, multi-repo graph. The local tool works without it, but be clear about which part is the product.
- The hook intercepts reads. It does its job, but if the graph is stale the agent answers from an old snapshot of the code; the commit hook, or
graphify update .after everygit pull, is mandatory.
Graphify vs grep and embedding-based RAG
Until now, a coding agent understood a repo in one of two ways: reading files with grep and Read, or through an embeddings index that returns chunks similar to the question.
grep + reads | Embedding RAG | Graphify | |
|---|---|---|---|
| What it returns | Lines matching a pattern | Semantically similar chunks | Nodes and relations (calls, imports, inheritance) |
| Indexing cost | None | Embeddings for every chunk | Local AST for code; LLM only for docs and media |
| Structural questions ("what calls X?") | Several chained searches | Weak | Its strong suit |
| Data leaving your machine | No | Depends on the embedding model | No, for code |
| Freshness | Always current | Needs reindexing | Needs rebuilding (git hooks) |
When to use each: grep is still unbeatable for finding a literal and never goes stale. RAG works well for natural-language questions over documentation. Graphify wins on structural questions (where a value comes from, what a change breaks, how two modules connect) in large repos, where reading file by file burns the agent's context.
Sources
- Graphify-Labs/graphify, GitHub
- graphify README, Graphify Labs