TL;DR

Graphify is an open-source AI coding assistant skill that turns any folder of code, SQL schemas, PDFs, images, and even video into a queryable knowledge graph. You type /graphify . in Claude Code, Cursor, Codex, Gemini CLI, or one of 20+ other agents, and 30 seconds later you have a real graph you can traverse instead of a fuzzy grep. It’s MIT-licensed, backed by Y Combinator’s S26 batch, sits at 88,215 GitHub stars with 7,483 added this week, and was one of the top three trending Python repos on GitHub the day this review was written.

The pitch that got it there: your AI agent shouldn’t re-grep your codebase every conversation. Graphify parses your code locally with tree-sitter (no LLM, nothing leaves your machine), builds a real graph — nodes are concepts, edges are calls/imports/inherits/mixes_in — runs Leiden community detection to label subsystems, and hands your assistant three artifacts: interactive graph.html, GRAPH_REPORT.md, and a graph.json you can query anytime. On LOCOMO it beats mem0 and supermemory on recall@10 (0.497 vs 0.048 / 0.149), and Reddit users are reporting 71x fewer tokens on real codebases.

Key facts up front:

  • 88,215 GitHub stars, 8,637 forks, 7,483 stars this week (Trending #3 Python, Jul 16 2026)
  • YC S26 backed, official PyPI package is graphifyy (double-y — critical, other graphify* packages are unaffiliated)
  • 20+ AI assistants supported — Claude Code, Cursor, Codex, OpenCode, Gemini CLI, GitHub Copilot, Aider, OpenClaw, Kilo, Trae, Kiro, Devin, Amp, Google Antigravity, and more
  • ~40 languages via tree-sitter AST, MIT license, Python 3.10+
  • Local-first for code — deterministic, no embeddings, no vector store, no LLM required for the code pass
  • Benchmarks: LOCOMO recall@10 0.497 (10x mem0, 3x supermemory), 76% QA on LongMemEval-S
  • PyPI: 2.2M+ downloads in 2.5 months, 450k+ downloads in the first 26 days after release

If you have ever watched Claude Code burn 30k tokens re-reading the same repo for the fifth time this week, this is the skill that fixes it.

Who Built It and Why It Matters

Graphify comes out of Graphify Labs (safishamsi is the primary human contributor; the project is publicly AI-assisted, with a large claude bot committer share). They took Graphify from empty repo on April 5, 2026 to Y Combinator’s S26 cohort by late June, riding a genuinely explosive curve: ~40k stars by May 1, 58k by mid-May, 73k by early July, 88k today. Roughly a thousand new stars a day sustained for three months.

The reason it caught fire is a real problem. AI coding agents now regularly work on 500k-line monorepos, and every conversation starts with the agent grepping and re-reading the same files it saw yesterday, burning 10-40k input tokens before it says a useful sentence. mem0 and supermemory tried to fix this with vector embeddings on top of message history. Fine for chat memory. Bad at “what calls APIRouter.__init__?”

Graphify’s insight: a codebase is not a chat log. It has real syntactic structure a parser can read for free. Tree-sitter already does this deterministically across ~40 languages. So instead of embedding everything and hoping cosine similarity finds the right function, Graphify walks the AST, extracts the actual calls/imports/inherits/mixes_in edges, runs Leiden community detection to label subsystems, and ships you a graph. Every edge is tagged EXTRACTED (explicit) or INFERRED (resolved), so you can see what was read directly versus guessed.

What “One Command” Actually Looks Like

The whole install is two lines:

uv tool install graphifyy    # install the CLI (or: pipx install graphifyy)
graphify install             # register the skill with your AI assistant

Then, in Claude Code (or Cursor, or Codex, or any of the 20+ supported agents), you type:

/graphify .

Thirty seconds later you get:

graphify-out/
├── graph.html          # open in any browser, click nodes, filter, search
├── GRAPH_REPORT.md     # the highlights: key concepts, surprising connections, suggested questions
└── graph.json          # the full graph — query it anytime without re-reading your files

The graph.html file is the demo that made this repo famous — a fully interactive, colored-by-community, clickable network view of your codebase you can commit and share with your team. But the real value is the CLI. Once the graph exists, you query it instead of reading files:

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

Connections (47):
  --> RequestValidationError [uses] [INFERRED]
  --> Dependant           [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

$ graphify query "how does dependency injection work here?"
# returns a scoped subgraph for the plain-language question

Three commands cover most of what a coding agent actually needs to know about a repo: explain for one concept, path for how two things connect, and query for a plain-language question that returns a scoped subgraph. Your agent uses these instead of grepping, and your token bill drops accordingly.

The Platform Matrix Is the Real Killer Feature

This is the piece most reviews miss. Graphify isn’t just “yet another Claude Code skill.” It ships first-class installers for twenty different AI coding platforms, and each install writes the right hooks/rules/config file for that agent:

PlatformInstallMechanism
Claude Codegraphify installPreToolUse hook + CLAUDE.md
Cursorgraphify cursor install.cursor/rules/
Codexgraphify install --platform codexPreToolUse hook + AGENTS.md
Gemini CLIgraphify install --platform geminiPreToolUse hook
OpenCodegraphify install --platform opencodeAGENTS.md
GitHub Copilotgraphify install --platform copilotrules file
Aidergraphify install --platform aidersequential extraction
OpenClawgraphify install --platform clawsequential extraction
Kilo Codegraphify kilo installSkill + native /graphify
Devin / Trae / Amp / Antigravityper-platform installernative
Cross-framework Agent Skillsgraphify install --platform agents.agents/skills/ (spec)

On hook-capable platforms (Claude Code, Codex, Gemini CLI, CodeBuddy), the installer wires in a PreToolUse hook that fires before search-style tool calls (grep, rg, find, Read, Glob) and nudges the agent toward graphify query. On instruction-file platforms (Cursor, OpenCode), it writes an always-on rules file. Same idea, different mechanism.

The --platform agents target installs to the generic cross-framework Agent Skills spec location (~/.agents/skills/ global, ./.agents/skills/ project) — the same spec npx skills reads. If you’re building your own agent stack, that’s the correct target.

Benchmarks: Do the Numbers Hold Up?

Graphify’s BENCHMARKS.md is one of the more honest self-benchmarks I’ve seen from a project this young. The headline result:

BenchmarkMetricgraphifymem0supermemory
LOCOMO (n=300)recall@100.4970.0480.149
LOCOMO (n=300)QA accuracy45.3%27.3%49.7%
LongMemEval-S (n=50)QA accuracy76%—— (tied with dense RAG)

Every system ran on the same harness with the same model and budgets, scored by a judge blind-validated against a second judge (90.6% agreement, Cohen’s kappa 0.81). The recall@10 result is genuinely large — an order of magnitude over mem0 and 3x over supermemory. The QA accuracy result is more mixed: supermemory beats Graphify on LOCOMO QA (49.7% vs 45.3%), so if your workload is “recall a fact from chat history” and not “traverse code structure,” supermemory is still competitive.

The other number that matters: LLM credits used to build the graph = 0. Every competing system pays per-token for their initial index. Graphify’s code pass is pure tree-sitter — the semantic pass over docs/media can call a backend, but only if you configure one. On a 500k-line repo that difference is the whole cost of the tool.

Reddit reports independently corroborate the win. From r/ClaudeAI: “I built a /graphify skill for Claude Code that maps your entire codebase into a knowledge graph, 71x fewer tokens, way less hallucination.” From a forked user: “Graphify is great. I forked it to do something non-code but the guts are excellent and continues to reduce token usage significantly.” From a large-company thread: someone reported their entire org got an email asking them to use tools like this to reduce AI-coding token spend.

Community Reactions

Graphify hit Hacker News and Reddit multiple times over its first three months. Three themes stand out:

“It really fills my gap between claude-mem and non-code Wiki. The flow is First see the Graph, then Check Claude-mem, then plan, edit with karparthy.” — r/ClaudeCode. People aren’t using Graphify standalone; they’re stacking it with claude-mem and other memory skills.

“58,000 Stars, a YC Backing, and a 0% Adoption Rate with Claude.” — r/ClaudeCode, April 2026. The honest early complaint: getting Claude Code to actually use the graph instead of falling back to grep was hard at first. Graphify’s answer was the PreToolUse hook install, which intercepts grep/rg/find at the tool boundary and redirects to graphify query. That fixed the “Claude ignores the graph” problem for most users.

“Graphify vs. code-review-graph: which is better for context-mapping across large codebases?” — the current live debate. CRG is the sibling project: an MCP server that maintains a self-updating SQLite graph, queryable via ~25 MCP tools (semantic_search_nodes, query_graph, get_impact_radius, list_communities). Emerging consensus: use Graphify for the one-shot human-readable HTML/JSON, and CRG for the always-live agent-queryable graph. Not competing — complementary.

Honest Limitations

Real gotchas from actually running it:

  1. PyPI package name is graphifyy — two y’s. Every other graphify* on PyPI is unaffiliated. pip install graphify (one y) gets you a completely different broken package. CLI command is still graphify — only the PyPI name is doubled. Use uv tool install graphifyy or pipx install graphifyy.
  2. Avoid pip install on Mac/Windows. The skill resolves Python at runtime from graphify-out/.graphify_python, and if that points at a different env than where pip installed the package, you get ModuleNotFoundError. uv tool install and pipx install isolate the package and avoid this — the single most-reported “it doesn’t work” bug.
  3. PowerShell: use graphify . not /graphify . — the leading slash is a path separator in PowerShell. This burns a lot of Windows users on first run.
  4. Docs, PDFs, images, and video use your assistant’s model. Only the code pass is fully local. On a repo with 400MB of PDFs, that’s a real backend call. Configure --backend explicitly, or use --code-only.
  5. Codex needs multi_agent = true under [features] in ~/.codex/config.toml for parallel extraction. OpenClaw and Aider are sequential-only for now — parallel agent support is still early there.
  6. Leiden community detection requires Python < 3.13 (via the [leiden] extra). On 3.13, Graphify falls back to a simpler algorithm and community labels get less precise. Pin to Python 3.12 if you want the pretty colored HTML.

None of these are dealbreakers. Rough edges on a project three months old growing at a thousand stars a day — but worth knowing before you commit graphify-out/ to your team’s repo.

How Graphify Compares to the Alternatives

vs mem0 / supermemory (vector RAG memory): Different problem class. Vector RAG is good for chat memory; Graphify is good for code structure. Graphify beats both on recall@10 by 3-10x on LOCOMO. Supermemory edges Graphify on LOCOMO QA (49.7% vs 45.3%). Use both if you can.

vs code-review-graph (sibling project): Complementary. Graphify is the batch tool that ships a rich HTML/JSON graph for humans. CRG is an MCP server with a self-updating SQLite graph for agents to query continuously. Run Graphify once for the readable map, install CRG for always-live agent context.

vs raw grep + reads: Graphify wins on tokens (71x reduction reported), hallucination rate, and cross-file reasoning. Grep still wins for “find every literal string ‘TODO’ in this repo.”

vs Serena / aider-repo-map: These build a similar map but ship it as tool output, not as a queryable graph. Graphify’s explain / path / query CLI is more expressive.

FAQ

Q: Is Graphify free? Do I need an API key?

Yes, MIT-licensed and free. The code pass is fully local and requires no API key — it’s just tree-sitter parsing. You only need an API key for the semantic pass over docs/PDFs/images/video (via --backend claude/openai/gemini/ollama/bedrock/azure). For pure code repos, --code-only skips the backend entirely.

Q: How is this different from Claude Code’s CLAUDE.md or Cursor’s .cursor/rules?

Rules files are static instructions you write by hand. Graphify builds a real graph of your actual code, then Claude/Cursor query that graph. The rules file Graphify writes is one line — “check graphify query first.” The actual knowledge lives in graph.json. Rules files don’t scale; a graph does.

Q: What languages does tree-sitter cover?

Roughly 40 out of the box — Python, TypeScript, JavaScript, Rust, Go, C, C++, Java, Kotlin, Swift, Ruby, PHP, C#, Scala, Elixir, Haskell, Lua, Dart, Julia, Zig, and more. Optional extras cover BYOND DreamMaker, Pascal/Delphi, Terraform/HCL, and SQL. For unsupported languages, Graphify falls back to a regex extractor (works, but more INFERRED edges).

Q: Does Graphify send my code anywhere?

No, not for code. The code pass runs entirely locally with tree-sitter. Nothing leaves your machine. The semantic pass over docs/PDFs/media does call whatever backend you configure. Use --code-only to guarantee no network calls.

Q: How much does it cost to build the graph on a large repo?

Code-only, zero — tree-sitter is free and runs in ~30 seconds on a 100k-line repo. Semantic pass cost depends on the corpus (FastAPI’s docs cost ~$0.30 with Claude in Graphify’s benchmarks). Use --backend ollama for a free local semantic pass.

Q: Does Graphify work with OpenClaw?

Yes — graphify install --platform claw writes the correct config. OpenClaw is sequential-only for extraction right now (no parallel subagent dispatch), so the initial build takes longer than on Claude Code or Codex.

Sources

Graphify is one of the fastest-growing developer tools of 2026 — 88K stars, YC S26 backing, 2.2M+ downloads, and a genuinely novel approach to the AI-coding token problem. If you’re using Claude Code, Cursor, Codex, or any agent on a repo bigger than 20k lines, this is worth 30 seconds to install.