Graphify: Turn Your Codebase into a Knowledge Graph Your Agent Can Query

Something unusual happened in the agent-skills world this October: a tool called graphify went from a niche repo to one of the fastest-rising search terms in the space. Whatever the spark was, the numbers are real: the repo (Graphify-Labs/graphify) sits at roughly 128,000 GitHub stars as of mid-October 2026, created in April 2026, with 2,400+ commits and 238 releases. That is not normal growth for a developer tool. It suggests a real itch is being scratched.

The pitch fits in one line: point it at any folder and one command builds a queryable knowledge graph — code, docs, PDFs, images, even video transcripts — that your AI coding assistant traverses instead of grepping through files.

This post explains what that actually means, how the mechanism works under the hood, and where the honest limits are.

Why grep stopped being enough

Ask an agent "where is request validation handled?" and the default strategy is lexical: grep for "valid", open five files, read, repeat. On a large repo, the agent spends a large share of its effort just finding things — re-reading files, losing track of how modules connect. Every re-read costs tokens, and every wrong turn compounds.

A knowledge graph changes the shape of the problem. Instead of searching text, the agent asks structural questions: what calls this function? What sits between A and B? Which concepts does everything flow through? The map is built once and persisted; queries traverse it without re-reading the raw files. That is the entire value proposition: pay the indexing cost once, stop paying the search cost on every question.

What graphify actually does

Graphify is two things in one: a CLI and an agent skill (Apache-2.0 licensed; the repo also ships an MIT license file). Installation is two commands — and note the double y, which matters:

uv tool install graphifyy   # official PyPI package is "graphifyy"
graphify install            # detects your assistant, registers the skill

Then, inside Claude Code (it also supports Cursor, Codex, Gemini CLI, GitHub Copilot, and 20+ other assistants):

/graphify .

That single command produces a graphify-out/ folder with three artifacts:

• graph.html — an interactive, clickable graph you open in any browser, with node search and community filtering
• GRAPH_REPORT.md — the highlights: key concepts, surprising connections, suggested questions to ask
• graph.json — the full graph, persisted so a query weeks later needs no re-reading of your files

From the terminal you can then interrogate the codebase directly:

graphify query "how requests are validated"
graphify path "FastAPI" "ModelField"
graphify explain "APIRouter"

The path command is the one that makes the value click. It traces the shortest route between any two concepts — in the project's own demo, three hops from FastAPI through get_request_handler() to ModelField — so you see how things connect instead of reconstructing it from file names and memory.

How it works: two passes, honest edges

The architecture is the interesting part, and it is what separates graphify from yet another RAG wrapper.

Pass one is deterministic. Code is parsed with tree-sitter AST analysis across roughly 40 languages. No LLM is involved, nothing leaves your machine, zero tokens are spent. This pass extracts the hard facts: what calls what, what imports what, what inherits from what — resolved across files, not just within them.

Pass two is model-assisted. Everything the parser cannot understand — design docs, ADRs, PDFs, screenshots, diagrams, whiteboard photos, video transcripts — goes through your assistant's model (or a configured API key) for concept and relationship extraction.

Both passes merge into one persistent graph. And here is the detail that earned engineers' trust: every edge carries a confidence tag. EXTRACTED means the relationship was explicit in the source; INFERRED means graphify derived it by resolution. What was found versus what was guessed is always visible — an audit trail instead of a confident hallucination.

On top of the raw graph, graphify surfaces "god nodes" (the most-connected concepts — i.e., what everything flows through) and splits the codebase into communities via Leiden clustering, with plain-language labels and a stated reason for each surprising connection. # NOTE: and # WHY: comments and ADR/RFC citations become first-class nodes linked to the code they explain.

Two design decisions are worth naming explicitly. First, there is no vector database anywhere: no embeddings, no Neo4j, no server to run. It is a real graph you traverse (NetworkX under the hood), not an embedding index you sample. Second, an optional hook (graphify claude install) nudges your agent to consult the graph before falling back to grep-style file reading — the "always check the map first" behavior has to be installed, it is not magic.

How it differs from the alternatives

It helps to place graphify against the three things teams already use:

• grep / ripgrep is lexical. It finds text, not relationships. It cannot answer "what calls this" without you doing the joining.
• ctags / LSP "go to definition" is structural but single-hop. Great for one jump, useless for "show me everything between the API layer and the database."
• Vector RAG over code chunks is semantic but lossy. It retrieves similar-looking chunks; it does not know that A calls B, and it cannot trace a path.

Graphify's bet is that code is already a graph — calls, imports, inheritance — and that parsing it deterministically beats guessing at it semantically. The LLM is reserved for the part parsers cannot do: human prose and images.

The honest limits

No tool deserves an uncritical writeup. Here is the other side:

• The doc pass isn't free. The code graph costs zero tokens; the semantic pass over docs and media spends your model's tokens (or your API key). On doc-heavy repos, budget for it — and decide whether you need the docs in the graph at all.
• Watch the package name. The official PyPI package is graphifyy with a double y, and the README explicitly warns that other graphify* packages are not affiliated. Type it from memory and you may install a stranger's code. Copy the install command; don't freestyle it.
• Graphs go stale. A map is a snapshot. If your team won't rebuild after refactors, you'll be navigating last month's codebase — rebuild the graph when the code moves.
• Small repos don't need it. On a twelve-file project the graph is a curiosity; the value grows with repo size, age, and unfamiliarity. Don't install process where grep is already instant.
• Benchmarks are self-reported. The repo publishes its own numbers — 0.497 recall@10 on LOCOMO, zero LLM credits for the code-graph build, measured on its own harness against its own baselines. Interesting, not independent. Evaluate it on your own monorepo, not on their README.

Who it's for — and who should skip it

Graphify fits teams whose "why" lives outside the code: design docs, ADRs, RFCs, the meeting notes where a decision was actually made. It fits anyone onboarding onto an unfamiliar monorepo who wants the lay of the land in one command instead of two weeks of archaeology. And it fits agents doing exploration before they write code — give the agent the map first, then let it dig.

Skip it if your repo is small, if nobody will rebuild the graph after refactors, or if your codebase's docs are already so thin that the semantic pass has nothing to chew on. A graph of nothing is still nothing.

Where the map ends

One thing to say plainly: graphify is not a debugger. A map tells you where things are; it doesn't tell you why they're broken. But the two compose well. When the graph surfaces a suspicious call chain — say, validation logic that three different handlers reach through three different paths — that's where a systematic debugging workflow earns its keep: hypothesis first, reproduction second, bisection third, fix verification last, in that order. Our systematic-debugging skill is built for exactly that next step. And if you're reviewing a PR that touches one of the graph's "god nodes," our code-review-and-quality skill gives you a checklist shaped for high-blast-radius changes. Map first, then method.

Try it in an afternoon

If "where does this get called?" is a question you ask weekly, graphify is worth an afternoon: install it, run /graphify ., open graph.html, and ask it one question you'd normally grep for. Then compare the answers — speed, accuracy, and how much context you had to read yourself. That comparison is the whole evaluation, and it's the only benchmark that matters for your repo.