graphify: a knowledge graph that answers questions about your repo without rereading it
graphify is a command-line tool that reads a folder of code, builds a knowledge graph, and then lets you query it in plain language. It reads code with tree-sitter, no language model involved: in our test, three files produced 11 nodes, 13 edges and 3 communities in 1.18 to 1.34 seconds, and every link came back with a file, a line, and a label saying whether it came from the syntax tree or was inferred. It is not an MCP server, nothing is declared in a config file, no restart is needed, and for code it costs zero tokens and zero money. For PDFs, images and notes it asks for a Gemini key, and that part we did not measure.

What it does
Picture asking your repository “what connects the class that serves users to the database?” and getting an answer with a file name and a line number, without opening a single file. That is what graphify does, without sending your code to any model.
A “knowledge graph” is a network: the things inside the code — files, classes, functions — and the relationships between them. This file imports that one, this class uses that one. The node is the thing, the edge is the relationship. You do not have a list of files; you have a map.
“Tree-sitter” is a language parser: it takes code as text and produces a syntax tree — which function contains which call, which import joins which files. It does not understand meaning; it understands structure, down to the character. That is why it needs no model.
The flow has two stages, kept apart. In the first you build the graph, a matter of seconds. In the second you ask, in three shapes: a path from one point to another, a search in plain language, an explanation of a single node. The README offers it as a skill for coding agents (repository), but it also works on its own from the shell — that is the part I ran. It is not an MCP server: nothing is declared in a config file, no tool schema is loaded, no restart is required.
Its most serious feature came out of the runs. Every edge carries a provenance label: EXTRACTED means it came out of the syntax tree and is a fact; INFERRED means it was concluded, and then a confidence score comes with it. In my test, UserService --uses --> Pool came back as INFERRED at 0.95. The certain and the probable are not presented as the same thing.
It is worth separating the three questions. The path answers a relationship between two known points, and helps when you know what you are looking for but not how it connects. The search takes a sentence and returns the points it touches, with their positions. The explanation takes one point and shows what touches it. They are not the same job, and they do not replace each other.
What the registries say. On PyPI the package is named graphifyy and the latest version is 0.9.100, published on 1 November 2026, 00:53 UTC (package). The requires-python field declares >=3.10. The license field is empty, while license_expression says Apache-2.0, and the README ships LICENSE, LICENSE-MIT and NOTICE; I report it as it is. On GitHub: 140,154 stars, 13,378 forks, 1,632 open issues, Apache-2.0, created on 3 April 2026, last push 1 November 2026 (repository).
And the caveat up front. Only code runs without a model. For PDFs, images, diagrams and notes it asks for a Gemini key, via GEMINI_API_KEY or GOOGLE_API_KEY — I saw that in its own message. With a key I did not run it, so that part stays unmeasured.
Who it is for
For anyone with a folder of code who is tired of rereading all of it for one question.
The beginner starts with the friendliest thing: you press the query command and it comes back with which files talk to each other, without you having read a line. No account, no key, no query language — you write the question the way you would say it to a person.
The professional gains three things. Cost: the analysis never passes through a model, so it is never billed in tokens. Traceability: every link with a file and line position, plus a provenance label. Durability: the output is written to files, so it can go into a pipeline or be read by another program.
There is also the team case. When the graph is written to a file inside the repository, every person and every assistant looks at the same picture, instead of each building their own. That counts when the question is not “how does this work” but “what does the thing I am changing touch”.
Who it is not for. If your documents are PDFs, this is not your tool — for those it asks for a model key, and I did not measure that part. If you want comprehension of meaning, a graph gives structure and relationships, not intent. And for a large project, do not lean on our measurement: what was measured is a three-file project.
Install
Through uv, from any folder:
uv tool install graphifyyTwo y’s. The name graphify on PyPI is taken by someone else, so the package ships as graphifyy. The command afterwards is ordinary:
graphifyWhat gets installed
Two executables: graphify and graphify-mcp. The first is the tool this article describes. The second states it also offers an MCP server — the executable exists, but I did not measure its schema. On disk 143.94 MB with dependencies. The weight is not the tool: the wheel is 1.72 MB. The rest is the 26 tree-sitter grammars, one grammar per language.
The 26 grammars are the reason the tool reads many languages with nothing added: the same package knows how to build a tree from whatever language you hand it. The cost is disk space, once, not time on every run.
First run
You go into the folder with the code:
graphify update .The dot is the current folder, and you say it explicitly. The work is written to graphify-out/: graph.json for programs, GRAPH_REPORT.md for people, graph.html for a browser.
Using it with each LLM
Here it is simple: nothing is declared in a config file, no restart is needed, it takes no context space until you call it. The assistant issues a shell command and reads what was printed and what it exited with.
The first move, identical everywhere:
graphify update .Then the question:
graphify query "what connects UserService to the database?"And the two special moves:
graphify path "UserService" "Pool"graphify explain "UserService"The rule: update the graph first, then ask, judge by the exit code. 0 means an answer, 3 means an ambiguous name — that is “I do not know which you mean”, not an error. An assistant that knows this asks for clarification instead of giving up.
In practice it never needs more than two moves: an update, then one question. If a second is needed it asks again — it does not rebuild, because the graph is already there.
Claude Code
In the rules file: before answering a question about structure, update the graph and query it.
graphify update . && graphify query "how does authentication reach the database?"Codex CLI
The same in AGENTS.md, with one difference: tell it to use the tool before opening files, otherwise it reads everything and then asks.
graphify path "Config" "Pool"Cursor
One instruction in the project rules is enough. Tell it to read GRAPH_REPORT.md too, because that is knowledge already condensed.
graphify update .In an automation pipeline
Exit codes separate failure from a request for clarification without reading any text, and the output stays in files inside graphify-out/. This is my own recommendation: do not build the graph twice in the same job. The cost sits in the build; the questions are cheap.
Where it wins, where it loses
It wins on time, measured: 1.18 and 1.34 seconds to build the graph over a three-file folder.
It wins on the EXTRACTED and INFERRED distinction with a score: they tell you how much to trust each line, and that the vendor knows the difference between what it read and what it suspected.
It wins on position: every answer carries a file and a line, not a summary — UserService --uses [INFERRED]--> Pool at=pkg/service.py:L4. I clicked and went there.
It wins on agent-friendliness: zero schema symbols, zero configuration, zero tokens for the analysis.
Now where it loses. Coverage: without a model, code only; the rest wants a Gemini key. The claims: “71.5× fewer tokens per question” is a vendor claim I did not measure. The second executable: I did not examine graphify-mcp. Age: born in April 2026, with 1,632 open issues — a reason to know what you are holding. And I am not claiming it works on a large repository: the test was three files.
The test
I ran it and measured; the numbers came out of the runs, not out of documentation.
Three files of my own: UserService in the first, Pool in the second, Config in the third, with a real from .db import Pool import. In other words a relationship that is not visible from the name but from the syntax.
graphify update .11 nodes, 13 edges, 3 communities, message Re-extracting code files in . (no LLM needed). Time 1.18 and 1.34 seconds. Exit code 0.
graphify path "UserService" "Pool"One edge, one hop: UserService --uses [INFERRED 0.95]--> Pool, with a “Path confidence” line. Exit code 0. It did not merely see an import; it inferred a use and said so with a score.
graphify query "what connects UserService to the database?"8 nodes, 12 edges, each with a position: UserService --uses [INFERRED]--> Pool at=pkg/service.py:L4 and service.py --imports_from [EXTRACTED context=import]--> db.py at=pkg/service.py:L1.
graphify explain "UserService"Node degree 4, with every connection and its line.
What it left behind: graph.json at 5,298 bytes, graph.html at 28,477 bytes, GRAPH_REPORT.md at 1,289 bytes, the folder at 75 KB.
What I did not measure: the Gemini-key part, the 71.5× claim, graphify-mcp as a server, and performance on a large repository. Any number not reported here is not ours.
What it costs
What I measured.
Build: 11 nodes, 13 edges, 3 communities, in 1.18 to 1.34 seconds.
Output: 5,298 bytes for graph.json, 28,477 bytes for graph.html, 1,289 bytes for the report, 75 KB for the folder.
Disk: 143.94 MB with dependencies. Wheel 1,805,544 bytes = 1.72 MB, sdist 3,102,438 bytes = 2.96 MB. The weight is the 26 tree-sitter grammars.
Assistant context: zero schema symbols; only the output you asked for. graphify-mcp exists, its schema unmeasured.
Tokens and money for code: zero and zero, under Apache-2.0, with no account and no key. Downloads: 1,630,115 a month, 480,736 a week, 51,169 a day (statistics) — these do not separate automated tests from people, so a ceiling.
Requirements: Python >=3.10.
What the vendor says, unverified. The 71.5× fewer tokens per question. That with a Gemini key it also reads PDFs, images, diagrams and notes. That it is also offered as an MCP server through graphify-mcp.
Verdict
Score: 7.8/10.
It does what it promises in the part I measured. It read three files in one second, found the relationship that was not visible from the name, said where it inferred it from and with how much confidence, and gave a file and line for every link. No account, no key, no configuration, no restart, no context space — and no cost.
It does not earn a ten, for three reasons. Its promise for documents beyond code goes through another company’s key and stays unmeasured. The most attractive number on its page is theirs, not ours. And the test was small, the repository new, with 1,632 open issues.
In practice: put it where you lose time rereading code, and have your assistant run it first, before opening files. Keep the split — a graph for code, a model for documents — and try it on your own before leaning on us for large projects.
Sources:
https://github.com/Graphify-Labs/graphify