What This Actually Does
Your AI is reading your whole codebase over and over
Here's what happens every time you ask Claude Code to change something. To understand your project, it opens your files and reads them, line by line. Then it does it again on the next question. And the next one. Every read is tokens, and on a real codebase that adds up fast. It's the single biggest thing quietly draining your usage.
Graphify is a free, open-source tool that fixes it. Instead of your AI re-reading your files, Graphify reads your codebase one time and turns it into a knowledge graph: a map of every concept in your project and how they all connect. From then on, your AI reads the map, not the files.
It's over 90,000 stars on GitHub for a reason. This is the setup, in plain English, for someone who's never touched a knowledge graph in their life.
Where the 71% Comes From
Read the map, not the whole book
Think about how you'd answer "how does login connect to the database?" in a big project. The slow way is to open every file and read until you piece it together. That's what your AI does by default, and every one of those reads costs tokens.
Graphify already drew the map. So instead of reading twenty files to trace a connection, your AI asks the graph and gets the answer in a couple of hops, without opening a single file. On the FastAPI codebase, tracing how two pieces connect takes 3 hops and zero files opened.
That's the whole trick. You stop paying to re-read your codebase from scratch on every question, which is where the token savings come from. Fewer files opened, fewer tokens burned, and as a bonus your AI actually understands how your project fits together instead of guessing from whatever few files it happened to read.
In plain English: re-reading your code is like re-reading an entire book every time you have one question. Graphify hands your AI the index and the map instead, so it flips straight to the answer.
The Setup
Three commands, about two minutes
One thing to check first: Graphify runs on Python 3.10 or newer. If you're not sure you have it, the easiest path is to install uv (a tiny, fast installer). On Mac that's brew install uv. On Windows, winget install astral-sh.uv. Or paste the line below and it installs itself.
Step 0 (only if you don't have uv) — Mac / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
Step 1: Install Graphify. One line. Heads up on the one thing that trips people up: the package name is graphifyy with a double "y" (the plain one is a different, unaffiliated package). The command you type after is still just graphify.
Step 1 — install the tool
uv tool install graphifyy # or: pipx install graphifyy
Step 2: Connect it to your AI. One command wires Graphify into your assistant (Claude Code, Cursor, Codex, Gemini CLI, Copilot, and more). Run it once.
Step 2 — register it with your assistant
graphify install # add --project to scope it to one repo
Step 3: Build the map. Open your AI assistant, go into your project, and type this. Graphify reads your codebase and builds the graph in about 30 seconds. The dot means "this whole folder."
Step 3 — inside your AI assistant
/graphify .
That's it. You'll get a new graphify-out/ folder with three things: a graph.html you open in any browser and click around, a GRAPH_REPORT.md with the highlights and suggested questions, and a graph.json your AI queries from then on. Open the HTML file first. Seeing your own codebase as a clickable map is the moment it clicks.
Using It
Now ask the map instead of the files
Once the graph is built, your AI pulls from it on its own, so most of the savings happen quietly in the background. But you can also query it directly. Three commands, and every one of them answers from the map without opening your files:
graphify query "how does auth work?" Ask a plain-English question. Returns only the part of the graph that answers it, not the whole codebase.
graphify explain "APIRouter" Show one concept and everything it connects to, with each link tagged as read-from-source or inferred.
graphify path "FastAPI" "ModelField" Trace the shortest path between two things. On the real FastAPI codebase this answers in 3 hops. Zero files opened.
Don't want to remember commands? You don't have to. Once it's installed, just work like normal. Your AI reaches for the graph on its own before it starts opening files. The commands are there for when you want to poke around yourself.
What You Get
Four things worth knowing about
A map of your whole codebase
Graphify reads every file once and turns your project into a knowledge graph: every function, class, and concept is a node, and every connection between them is drawn in. You get a graph.html you open in your browser and actually click around, plus a graph.json your AI reads instead of your raw files.
The "god nodes" you should know about
It surfaces the most-connected pieces of your codebase automatically, so the first thing you see is what everything else flows through. On a new or messy project, that alone is worth the two-minute setup.
Ask, trace, or explain, without opening a file
Three commands do the work. Ask a plain-English question and get back just the slice of the graph that matters. Trace the shortest path between any two things. Or explain one concept and see everything it touches. Every answer comes from the map, not from re-reading your code.
It works in the tool you already use
One command registers it with Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, and 15+ more. Your AI starts pulling from the graph on its own. You set it up once and every session after that is cheaper.
The Honest Part
What to know before you dive in
The savings depend on your codebase. "Up to 71%" is the ceiling, not a promise. The bigger and more tangled your project, the more you save, because that's where re-reading files hurts most. On a tiny two-file script you won't notice much. On a real codebase you'll notice a lot.
Rebuild the map when your code changes a lot. The graph is a snapshot. After big changes, run /graphify . again to refresh it. For small edits it's smart enough to nudge your AI when a file is stale.
It lives in a coding-style agent, not the phone app. This runs in tools like Claude Code, Cursor, or VS Code where the AI can run commands on your computer. If you're brand new, the desktop Claude Code app is the friendliest place to start.
It's genuinely free and open source. No account, no paywall, no per-run fee. Building the graph doesn't cost you AI credits either.
Full credit to the team behind Graphify (github.com/Graphify-Labs/graphify). If it saves you tokens, give them a star. That's how good open-source tools get found.
Your AI has been quietly re-reading your entire codebase to answer every question, and paying for it in tokens the whole time. Build the map once and that stops. Two minutes, three commands, and your assistant gets faster and cheaper at the same time.
Go build the graph.
Work with Me
Want me on your problem for an hour?
Book a 1:1 call and we build the fix live — the workflow you want automated, the tool you can’t crack, whatever’s stuck. Direct, hands-on, no pitch waiting at the end.