Graphify: a Codebase Knowledge Graph for Claude Code
Graphify turns a repository — code, docs, SQL schemas, configs, PDFs — into a knowledge graph you can query from inside Claude Code. Local tree-sitter parsing, every edge labelled, no vector store.
Graphify at a glance
- A third-party open-source project (Graphify-Labs/graphify, Apache-2.0, written in Python), not an Anthropic product. It ships a `/graphify` skill for Claude Code, Cursor, Codex, Gemini CLI and other assistants.
- Code is parsed with tree-sitter into an AST, locally and deterministically, with no model call. Every edge is tagged `EXTRACTED` (explicit in the source) or `INFERRED` (resolved by Graphify).
- It is a graph you traverse, not a vector index: no embeddings, no vector store. `/graphify query` returns only the nodes and edges the answer needs.
- Three commands get you running: `uv tool install graphifyy`, `graphify install`, then `/graphify .` in the repository. Output lands in `graphify-out/`.
Graphify-Labs/graphify — repository and README
Sourcegithub.com2026-11-15
Graphify Quickstart
Sourcedocs.graphify.com2026-11-15
GitHub REST API — repos/Graphify-Labs/graphify
Sourceapi.github.com2026-11-15
Every command, flag and file name on this page was read from the three sources above on 2026-11-15. Commands and paths are left untranslated on purpose — a translated command is not runnable.
Checked 2026-11-15. The repository's default branch is v8 and it was last pushed on 2026-11-14; star and fork counts move daily, so re-read the API before quoting them.
What Graphify actually is
Graphify's own description: turn any codebase, with its docs, SQL schemas, configs and PDFs, into a queryable knowledge graph — a `/graphify` skill for Claude Code, Cursor, Codex and Gemini CLI, with local deterministic AST parsing, every edge explained, and no vector store.
In practice you install a CLI (`graphify`) plus a skill, then type `/graphify` inside your assistant. The assistant runs detection, extraction and clustering, writes the graph into `graphify-out/`, and afterwards answers questions by traversing that graph instead of grepping the tree.
- License
- Apache-2.0
- Language
- Python (package: graphifyy)
- Stars / forks
- 147,983 / 14,194 — 2026-11-15 snapshot
- Status
- Third-party; default branch v8; last push 2026-11-14
Not an Anthropic project
Graphify is published by the Graphify-Labs organization (the GitHub API reports is_verified: false) under Apache-2.0. Anthropic does not maintain it and Claude Code does not ship it: you install it yourself, and it runs against your own files.
How the graph is built
Code is parsed with tree-sitter into an AST. That pass is deterministic and runs on your machine: no LLM, nothing leaves it. Cross-file links (calls, imports, inherits, mixes_in) come out of the AST across roughly 40 languages, and `# NOTE:` / `# WHY:` comments as well as ADR and RFC references become nodes too.
Docs, PDFs, images and video take a second, semantic pass that uses your assistant's model, or a configured API key. That is the part that costs tokens; the code map itself does not.
Every edge is explained
Each connection carries a tag: `EXTRACTED` when the relationship is explicit in the source, `INFERRED` when Graphify resolved it. You can see what was read from the code and what was deduced.
Not a vector index
There are no embeddings and no vector store. The output is a real graph — nodes, edges, communities, god nodes — that you traverse with `query`, `path` and `explain`.
Install Graphify for Claude Code
Three commands. Claude Code is the default target of `graphify install`; another assistant is one flag away.
Install the CLI
The package is `graphifyy` — two y's. It installs the `graphify` and `graphify-mcp` commands. Python 3.10 or later is required, and any of the three package managers works.
# Python 3.10 or lateruv tool install graphifyy# or: pipx install graphifyy# or: pip install graphifyyMind the spelling: the package you install is `graphifyy`, while the commands you type are `graphify` and `graphify-mcp`.
Register the skill
With no flag, `graphify install` targets Claude Code. It copies the skill to `~/.claude/skills/graphify/SKILL.md` and registers it in `~/.claude/CLAUDE.md`. For another agent, pass `--platform`.
graphify install# Claude Code (default): ~/.claude/skills/graphify/SKILL.md# registered in ~/.claude/CLAUDE.md# another assistant: graphify install --platform codexFor example `graphify install --platform codex`. If `/graphify` is still not recognised, restart the assistant, or check that `~/.claude/skills/graphify/SKILL.md` exists.
Run it in a repository
Open the repository in your assistant and run `/graphify .`. The agent detects, extracts and clusters, then reports back; code is parsed locally, while docs and papers go through the agent's own model.
/graphify .Then ask questions: `/graphify query "how does authentication reach the database"` returns only the nodes and edges the answer needs, trimmed to a token budget.
Before you start
- 1Python 3.10 or later.
- 2uv, pipx or pip — whichever you already use for CLIs.
- 3A coding assistant that `graphify install` supports (Claude Code is the default), plus a repository to index — local, or a public GitHub URL for `/graphify <url>`.
The commands you will actually use
Verbatim from the docs' quickstart and command table. Commands starting with `/` are typed inside your assistant; the rest run in a shell.
| Command | What it does |
|---|---|
/graphify query "…" | Ask a question; returns only the nodes and edges needed to answer, trimmed to a token budget. |
/graphify path "AuthModule" "Database" | Show the shortest path between two nodes — here from AuthModule to Database. |
/graphify explain "SessionStore" | Explain a single node: what it is, what it connects to, and why. |
/graphify . --update | Refresh an existing graph instead of rebuilding it from scratch. |
/graphify . --mode deep | Run the deeper extraction mode — slower, and more of the graph is resolved. |
/graphify . --wiki | Also produce a wiki-style write-up of the graph. |
/graphify https://github.com/<owner>/<repo> | Point it at a public repository by URL instead of a local path. |
graphify hook install | Install git hooks (post-commit, post-checkout, post-merge, post-rewrite plus a merge driver) so the graph follows the repository; `graphify hook status` should list all four as installed. |
graphify god-nodes --top 5 | Print the most connected nodes — a quick check that a graph exists and looks sane. |
graphify extract . --code-only | Re-extract with the code pass only, skipping the LLM steps for docs and media. |
graphify uninstall | Remove the skill and its registrations. |
If a command cannot find the graph, run it from the directory that contains `graphify-out/`, or pass `--graph graphify-out/graph.json`.
What lands in graphify-out/
The docs' tree, verbatim:
graphify-out/├── graph.json├── graph.html├── GRAPH_REPORT.md├── manifest.json└── cache/- 1`graph.json` — the full graph, and the file to read when something else needs the data.
- 2`graph.html` — a browser view: click nodes, filter, search.
- 3`GRAPH_REPORT.md` — the highlights, the surprising connections and suggested questions.
- 4`manifest.json` — the manifest of what was indexed.
- 5`cache/` — local working data; add it to `.gitignore` rather than committing it.
What to commit
The docs suggest committing `graph.json` and `GRAPH_REPORT.md`, and adding `cache/` to `.gitignore`. The README's shorter version says you get "three files" (`graph.html`, `GRAPH_REPORT.md`, `graph.json`); the quickstart lists five entries. Both describe the same directory at different levels of detail.
A persisted graph also records `graph.schema_version` and `graph.graphify_version`. Check them after upgrading the CLI: an older graph may need a rebuild.
Keeping the graph fresh
A graph is only as good as its last build, so wire it into git:
graphify hook installgraphify hook status# → 4 hooks installed, merge driver: registered`graphify hook install` wires post-commit, post-checkout, post-merge and post-rewrite hooks plus a merge driver. `graphify hook status` should then show four hooks installed and "merge driver: registered".
When docs or images change, re-run `/graphify . --update` instead of a full build.
When it fits, and what it does not do
Graphify is a code-mapping tool. It is worth the install when the shape of a repository matters more than the text of any single file.
Good fit
- 1You are onboarding into an unfamiliar codebase and want the modules, the god nodes and the communities before you read files.
- 2The question is a relationship question — how does this reach that, who calls this — which grep answers badly.
- 3You want the map committed, so a team or an agent can re-read it without paying to rebuild it.
Limits to know about
- 1The free, fully local part covers code. Docs, PDFs, images and video go through a model for the semantic pass, so those parts cost tokens or an API key.
- 2`INFERRED` edges are Graphify's resolution, not a fact in the source. Read the tag before trusting a connection.
- 3The graph is a snapshot. Without the hooks or `--update` it goes stale the same way a README does.
- 4It is a young third-party project: the case for it comes from its own README, not from an independent evaluation.
The project publishes its own benchmark table in the README — for example LOCOMO recall@10 of 0.497 at n=300. Those are the maintainers' measurements, not an independent result, so treat them as a claim to verify on your own repository.
Graphify on DeepSeek Harness
There is also a third-party native plugin for DeepSeek Harness, listed in its plugin directory. It is community work, separate from the Graphify-Labs repository.
See the plugin listing