Deepseek ArtifactsDeepseek Artifacts
Third-party · Apache-2.0 · Python

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

Open

Graphify Quickstart

Sourcedocs.graphify.com2026-11-15

Open

GitHub REST API — repos/Graphify-Labs/graphify

Sourceapi.github.com2026-11-15

Open

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 graphifyy

Mind 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 codex

For 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.

CommandWhat 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 . --updateRefresh an existing graph instead of rebuilding it from scratch.
/graphify . --mode deepRun the deeper extraction mode — slower, and more of the graph is resolved.
/graphify . --wikiAlso 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 installInstall 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 5Print the most connected nodes — a quick check that a graph exists and looks sane.
graphify extract . --code-onlyRe-extract with the code pass only, skipping the LLM steps for docs and media.
graphify uninstallRemove 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

Graphify: frequently asked questions

Keep reading