Graphify: Turn Any Codebase Into a Knowledge Graph (2026 Guide)

Graphify (Graphify-Labs/graphify) is the repo I keep seeing near the top of GitHub’s weekly trending page this month. It parses your code with tree-sitter into a knowledge graph of functions, classes, imports and calls, layers your docs and PDFs on top, and gives your coding agent a /graphify skill to query that graph instead of grepping file by file.

I read the README, the docs, the CLI help and the skill file at v0.9.95 on 26 Oct 2026 to separate what runs locally for free from what costs tokens, and to check when a code graph actually beats grep plus embeddings. I didn’t install it on this machine: every command below is checked against the source, and every number is attributed.

1. What It Is: Stars, License and Scope

Graphify is a Python CLI plus an assistant skill. The library does the work (detect files, extract, build the graph, cluster, report) and the skill tells your agent when and how to call it. The repo describes itself as a /graphify skill for Claude Code, Cursor, Codex and Gemini CLI with local deterministic AST parsing, every edge explained and no vector store. The README lists more than 20 supported assistants.

⭐

GitHub stars

~135.8K

GitHub API, 26 Oct 2026. #6 on weekly trending with ~6.9K stars that week

⚖️

License

Apache-2.0

Relicensed from MIT; earlier contributions stay MIT (NOTICE, LICENSE-MIT)

🏷️

Latest release

v0.9.95

Published 23 Oct 2026. Needs Python 3.10+

📦

Package

graphifyy

Two y’s on PyPI. The command is still graphify

Why it’s everywhere right now

The repo was created on 3 Apr 2026, and Trendshift’s GitHub Trending chart for it starts on 3 Jul 2026 with a best rank of #5. The README badges it as Y Combinator S26 and promotes a paid sibling, Graphify Cloud, for always-on and cross-repo graphs. This post covers only the open-source CLI.

Watch the package name

The README is explicit: the official PyPI package is graphifyy with a double y, and other graphify* packages on PyPI are not affiliated. Several third-party MCP wrappers also reuse the name. Install the exact package name, or start from the GitHub repo.

2. The Architecture in 4 Steps

Putting together the README, ARCHITECTURE.md and docs/how-it-works.md, the pipeline is detect, extract, build, cluster, report and export. Here it is in four steps.

🔎

1. Detect and classify the corpus

detect() walks the folder, honors .gitignore and .graphifyignore, and groups files into code, docs, papers, images and video. A .graphifyrc file pins ambiguous extensions (.inc, .h, .m) to the right language. The skill warns when a run goes past 500 files or 2 million words and asks you to pick a subfolder.

🌳

2. Extract: an AST for code, a model for everything else

Code goes through tree-sitter locally: classes, functions, imports, calls and inheritance across about 40 languages, with no LLM and nothing leaving your machine. Docs, PDFs and images go through a semantic pass that uses your assistant’s model or a configured API key. Audio and video are transcribed locally with faster-whisper. Every file is fingerprinted with SHA256, so re-runs skip unchanged files.

🧩

3. Resolve, tag and cluster

Fragments merge into one NetworkX graph. Every edge carries a provenance tag: EXTRACTED (explicit in the source), INFERRED (resolved by graphify, with a confidence score when a model made it) or AMBIGUOUS (flagged for review). Leiden groups nodes into communities (Louvain if you skip the leiden extra), and the most-connected nodes become “god nodes”.

💾

4. Write graphify-out/ and query it

The output is graph.json (NetworkX node-link format), GRAPH_REPORT.md and an interactive graph.html. Agents query it with graphify query, path and explain, through hooks that nudge them before grep, or through an MCP server. Neo4j and FalkorDB exports are optional extras. There is no vector store.

INFERRED does not mean “an LLM guessed”

The architecture docs say resolution can infer a connection from static evidence, so an INFERRED edge may come from the AST resolver rather than a model. The vendor hand-audited 12 cross-file INFERRED edges in FastAPI’s production code on 5 Oct 2026 and found all of them correct, while noting that test helpers with repeated names produce noisier edges. That’s a spot check, not a metric: treat INFERRED as a lead to verify.

3. A 5-Minute Quickstart on FastAPI (Offline, No API Key)

I picked FastAPI because it’s the corpus the README demo uses, so you can compare your output with theirs. The commands come from the README and the CLI help in v0.9.95. I didn’t run them, so try them in a throwaway folder first.

1. Install the CLI

# Python 3.10+ and uv (or pipx). The PyPI package has two y's
uv tool install graphifyy
graphify --version

2. Clone a sample repo and build a code-only graph

# FastAPI: the same corpus the README demo uses
git clone --depth 1 https://github.com/fastapi/fastapi.git
cd fastapi

# Code only, fully offline: tree-sitter AST, no API key, no LLM
export GRAPHIFY_BACKEND=none        # PowerShell: $env:GRAPHIFY_BACKEND = "none"
graphify extract . --code-only      # writes graphify-out/graph.json
graphify cluster-only .             # communities, GRAPH_REPORT.md, graph.html

3. Query the graph from the terminal

graphify god-nodes --top 10            # the hubs everything flows through
graphify explain "APIRouter"           # source line, community, edges
graphify path "FastAPI" "ModelField"   # shortest path between two symbols
graphify affected "Dependant"          # reverse traversal: what depends on it
graphify query "how does a request reach dependency injection?" --budget 1500

What the README shows for FastAPI (real output, quoted)

$ graphify explain "APIRouter"
Node: APIRouter
  Source:    routing.py L2210
  Community: 2
  Degree:    47

Connections (47):
  --> RequestValidationError [uses] [INFERRED]
  --> .get() [method] [EXTRACTED]
  <-- __init__.py [imports] [EXTRACTED]
  ...

$ graphify path "FastAPI" "ModelField"
Shortest path (3 hops):
  FastAPI --uses--> DefaultPlaceholder <--references-- get_request_handler() --references--> ModelField

extract stops at graph.json

Headless graphify extract writes graph.json plus an analysis sidecar, then prints a hint to run graphify cluster-only, which writes GRAPH_REPORT.md and graph.html. With no LLM backend, each community is named after its most-connected node, so the labels are deterministic. Query commands exit 0 with an answer, 3 when a name is ambiguous (they list the candidates instead of guessing) and 4 when nothing matches, which makes them easy to script.

On Windows

Use $env:GRAPHIFY_BACKEND = "none" in PowerShell instead of export. If graphify isn’t found after uv tool install, the README’s fix is uv tool update-shell. The README’s platform table says the Claude Code installer auto-detects Windows.

Pin the version

Four releases landed between 16 and 23 Oct 2026 (v0.9.92 to v0.9.95), and the last three bumped the AST cache schema, so the first build after each upgrade re-extracts everything. For a team, pin it with uv tool install graphifyy==0.9.95 and upgrade on purpose. There’s also an old v1.0.0 git tag from 5 Apr 2026; it isn’t the current release.

4. Wiring It Into Your Coding Agent

The terminal is for checking the graph; the real point is your agent using it. There are three integration paths, and the README is clear that they’re separate: the skill, the always-on instructions and MCP.

Claude Code: skill, always-on hook and freshness

graphify install            # registers the /graphify skill (Claude Code by default)
graphify claude install     # CLAUDE.md section + PreToolUse hook: graph before grep
graphify hook install       # git hooks rebuild the graph on commit and checkout

# inside Claude Code
/graphify .

# after a git pull, per the README
graphify update .           # re-extracts changed code, no LLM

Other agents (from the README’s platform table)

• Codex: graphify install --platform codex, then invoke it with $graphify (set multi_agent = true under [features] in ~/.codex/config.toml for parallel extraction)
• Cursor: graphify cursor install (writes .cursor/rules/graphify.mdc)
• Gemini CLI: graphify install --platform gemini (GEMINI.md section + BeforeTool hook)
• VS Code Copilot Chat: graphify vscode install
• OpenCode: graphify install --platform opencode
• Any Agent Skills reader: graphify install --platform agents (.agents/skills/)

MCP: expose the graph as tools

uv tool install "graphifyy[mcp]"
claude mcp add graphify -- graphify-mcp graphify-out/graph.json

The mcp extra adds a stdio server, graphify-mcp (also runnable as python -m graphify.serve). In serve.py at v0.9.95 it lists ten tools: query_graph, get_node, get_neighbors, get_community, god_nodes, graph_stats, shortest_path, list_prs, get_pr_impact and triage_prs. Add --transport http --port 8080 --api-key to share one server with your team.

The hook changes how your agent behaves

graphify claude install writes a section into CLAUDE.md plus a PreToolUse hook that fires before search-style calls and before reading source files one by one with Read or Glob, nudging the agent toward graphify query. With GRAPHIFY_HOOK_STRICT=1 it denies an indexed read once per session. That’s the feature, but on a stale graph it steers the agent toward old facts. graphify uninstall removes it from every platform.

5. Cost, Privacy and Local Models

The headline is “code maps for free”, and for code that holds. The bill shows up when you add docs, PDFs and images, and when you count tokens at query time. These are the vendor’s numbers, all self-reported.

🆓

Code graph build

Tree-sitter runs locally. The README’s benchmark table lists 0 LLM credits to build the graph

🧠

Your agent’s tokens

Docs, PDFs and images

In Claude Code the skill dispatches parallel subagents for the semantic pass; headless extract needs an API key or a local model

📉

71.5x vs ~1x

Tokens per query vs reading raw files

52-file mixed corpus vs a 6-file library (docs/how-it-works.md). Savings grow with corpus size

🎯

70.8% → 82.0%

Key-fact coverage on ERPNext

~1M LOC, n=6 questions, Claude Opus 4.8 agent, ~140K tokens per query (BENCHMARKS.md)

Running the LLM part locally

GRAPHIFY_BACKEND=none (or --code-only) keeps the graph purely AST. For docs with data-residency rules, GRAPHIFY_BACKEND=ollama uses a local Ollama instance at OLLAMA_BASE_URL, and the openai backend reaches llama.cpp, vLLM or LM Studio through OPENAI_BASE_URL and OPENAI_MODEL. The CLI help recommends --max-concurrency 1 for local LLMs.

Three privacy gotchas

First, the skill reads exactly one API key: if GEMINI_API_KEY or GOOGLE_API_KEY is set in your shell, the semantic pass goes to Gemini instead of your agent’s model. Second, headless extract auto-detects a provider in the order Gemini, Kimi, Claude, OpenAI, DeepSeek, Azure, Bedrock, Ollama, and Kimi routes to Moonshot AI servers in China; pass --backend to choose. Third, there’s no telemetry, but every query is logged locally to ~/.cache/graphify-queries.log (opt out with GRAPHIFY_QUERY_LOG_DISABLE=1).

How I read the benchmarks

The code result covers six questions: that’s a demo, not a benchmark. LOCOMO and LongMemEval are conversational-memory datasets, and that harness ran graphify with hybrid retrieval and a local BGE-m3 embedder, which isn’t the plain “no embeddings” CLI path. The 71.5x figure is self-reported, and the “80% fewer tokens” banner in the README is a Graphify Cloud claim with no methodology attached.

6. Graphify vs Vector RAG, PageIndex and GraphRAG

All four approaches build an index once and query it many times. They differ in what the index is, who builds it and which questions it answers well.

🔤

Grep + embeddings

Index: Raw files plus chunk embeddings (often with BM25)
Built by: An embedding model per chunk; grep needs nothing
Query: Exact match or semantic similarity
Best at: Exact strings and “find code that does something like X”

🌲

PageIndex (vectorless tree)

Index: A tree of one long document’s sections
Built by: PDF layout plus LLM node summaries
Query: An LLM reasons its way down the tree
Best at: Long, structured PDFs such as filings and manuals

🕸️

Microsoft GraphRAG

Index: Entity graph plus hierarchical community summaries
Built by: LLM extraction over text units; its README warns indexing is expensive
Query: Global, local, DRIFT or basic search
Best at: Theme-level questions over narrative text

🧬

Graphify

Index: A symbol graph of the code, plus doc concepts
Built by: Tree-sitter AST locally; a model only for docs and media
Query: BFS or DFS traversal, shortest path, explain
Best at: Multi-hop structural questions about a codebase

GraphRAG is in maintenance mode

Microsoft’s README now says GraphRAG is largely in maintenance mode and won’t take new features (latest release v3.3.0, 8 Oct 2026). It’s still the reference for LLM-extracted entity graphs, but on code it pays an LLM to rediscover what a parser reads for free.

Where a code graph beats grep + embeddings

• “How does A reach B?”: path returns the hop-by-hop chain across files, which grep only approximates with several searches
• Impact before a refactor: affected runs a reverse traversal to list what depends on a symbol
• Onboarding to a large, unfamiliar repo: god nodes, communities and GRAPH_REPORT.md give you a map before you open a single file
• Linking intent to code: # NOTE: and # WHY: comments plus ADR or RFC citations become nodes connected to the code they explain
• Agents that re-read the same files every session: the graph persists, so the expensive part isn’t repeated

My reading (inference, not a measurement)

Graph queries start from keyword matches against node names (the CLI’s --seed flag exists to override them), so a question phrased in words the code doesn’t use can miss where embeddings would still land. Grep remains faster for exact strings like error messages and config keys. In practice I’d keep grep, add the graph for structure, and only reach for embeddings when paraphrased search is a real need.

7. When NOT to Use It

This is the part a trending badge won’t tell you.

✅ A good fit if...

• Your repo has hundreds of files or more, and your agent keeps re-reading the same ones
• You ask structural questions: call chains, dependencies, the blast radius of a change
• You want code to stay local: the AST pass never leaves your machine
• You can keep the graph fresh with git hooks or graphify update in CI
• Your team will commit or share the graph so everyone queries the same map

⚠️ Skip it (or keep it optional) if...

• The repo is small: on a 6-file corpus the vendor’s own table shows ~1x token reduction, and your agent can simply read it
• Code changes faster than you rebuild: a stale graph plus an always-on hook confidently points the agent at old structure
• Your code leans on dynamic dispatch, reflection, DI containers or string-based routing a static parser can’t see; the docs warn an absent path is not proof two systems are independent
• Your questions are exact strings (error messages, env vars, config keys): grep is faster and complete
• Your corpus is mostly docs and you can’t send them to a model provider, or can’t afford the semantic pass
• It’s a huge monorepo: the skill asks you to narrow past 500 files, graph.html aggregates past 5,000 nodes, and always-on cross-repo graphs are the paid Cloud
• You need a stable tool today: it ships several releases a week, and cache-schema bumps force full re-extraction

My take

Start code-only and offline: it costs nothing, takes minutes, and GRAPH_REPORT.md alone tells you whether the graph understands your repo. If the god nodes and communities match how you think about the system, install the skill and the hook. If they look like noise, your codebase is probably too small or too dynamic for this to pay off, and grep stays the right tool.

Conclusion

Graphify’s core idea is sound and cheap: a parser already knows your call graph, so let it build the map and let the agent walk it instead of grepping. The open-source CLI does that locally for about 40 languages, with every edge labeled by how it was found.

The costs sit at the edges: tokens for the docs pass, discipline to keep the graph fresh, and a hook that changes your agent’s habits. Treat it like any index: build it on your own repo, check the report against what you know, and keep it only if it saves your agent real work.

Verification stamp

Stars, release and license were checked against the GitHub API, PyPI and the LICENSE and NOTICE files on 26 Oct 2026 (v0.9.95). Commands come from the README, the CLI help in graphify/__main__.py, cli.py, serve.py and the skill file at the same version. I did not install or run the package. Benchmark figures are the vendor’s and self-reported.