Smorster

Graphify: Instant Knowledge Graph for Claude Code/Antigravity (FREE)

FuturMinds · 10m 34s · Watch on YouTube · 11 sources

Decision Card

Effort: Coffee-break trial — pip install graphifyy, graphify install, graphify claude install, then run /graphify on one project and wait ~10–15 minutes for the graph build (the video’s 357-file repo took ~12 minutes).

Honest take: The video’s own head-to-head test undercuts the headline: on 10 identical questions, Graphify saved under 8% of tokens (113k vs 120k), and the presenter concedes the repo’s 71.5x benchmark “is comparing against a workflow most people don’t actually use” — the real, unquantified benefit claimed is answer quality and fewer wrong-direction reads, not token savings.

Concrete next steps:

  • Skim the Graphify repo worked examples and BENCHMARKS.md before trusting any multiplier — the README itself notes savings approach parity on small corpora (~15 min).
  • Trial on a mixed docs+code or research-notes folder rather than a pure code repo, since that’s where the video says savings are “considerable” (~30 min including graph build).
  • If adopted, wire graphify hook install for git-hook auto-rebuilds, or run graphify update manually after big changes (~5 min).
  • Compare against Karpathy’s original LLM Knowledge Bases workflow / llm-wiki gist to decide whether a compiled wiki fits your vault better than a graph (~20 min reading).
  • Skip if your projects are small, single-language codebases with short sessions — the video’s own measurement shows single-digit-percent token savings there, and a 10+ minute build plus graph maintenance won’t pay back.

TL;DR

Graphify builds a persistent knowledge graph of a project (code via local tree-sitter parsing, audio/video via local Faster-Whisper, docs via one-time Claude subagent extraction) that Claude Code auto-loads at session start instead of re-reading files every session. The presenter’s own 10-question test found only ~7–8% token savings but subjectively better answers, and he argues the repo’s 71.5x claim measures an unrealistic paste-everything baseline — the tool’s real value is on large, mixed code+docs projects, research vaults, and long sessions.

Key Points

  • Every new Claude Code session rebuilds codebase understanding from scratch — same file reads, same tokens burned, no memory between sessions 00:38
  • Graphify reads the project once, builds a knowledge graph, and Claude reads that graph at the start of every session instead of re-reading files 00:54
  • The tool shipped 48 hours after Andrej Karpathy described the idea and had almost 25,000 stars at recording time 01:59
  • Three-pass architecture: pass 1 parses code structure locally (no API calls, no tokens — hard facts from every class, function, import, call) 02:12
  • Pass 2 transcribes meeting recordings, tutorials, and YouTube URLs locally with Faster-Whisper; pass 3 uses parallel Claude subagents on docs/PDFs/images and is the only pass touching the API — and only once 02:39
  • A session-start hook loads the graph summary automatically, so Claude makes “two or three targeted reads instead of fifteen” 03:25
  • His controlled test — same project, same 10 questions — showed 120k tokens without Graphify vs 113k with it, under 8% savings, but noticeably more detailed answers on the graph side 04:03
  • Setup is three commands: pip install graphifyy (double y), graphify install, graphify claude install; other platforms (Codex, OpenCode) have equivalent installers 05:23
  • On the browser-use repo it built a graph of 4,041 nodes, 20,900 edges, and 185 communities in ~12 minutes, with an interactive graph.html visualization 06:24
  • The 71.5x benchmark compares against naively pasting all 52 corpus files (~123k tokens) into context vs ~1,700 tokens per graph query — a baseline workflow nobody actually uses 08:18
  • It works on non-code content too: he ran it on a folder of YouTube scripts, transcripts, and research notes and queried topic coverage across them 09:36

Notable Quotes

“It reads your project once, builds a knowledge graph of how everything connects, and Claude reads that graph at the start of every session.” 00:58

“Pass three is the only part that touches Claude’s API and it only runs once.” 03:06

“So that 71 times benchmark is comparing against a workflow most people don’t actually use.” 09:00

Verified Claims

  • Graphify shipped 48 hours after Andrej Karpathy described the workflow it implements. 01:59 — Karpathy’s “LLM Knowledge Bases” post is real, and the 48-hour timing is widely repeated (e.g. this viral X post), but I found no primary-source timestamp comparison — the timing claim traces back to viral posts echoing each other. Verdict: Inconclusive (Karpathy post confirmed; exact 48h timing unverified).
  • The repo has “almost 25,000 stars.” 02:04 — Reporting shows ~22k stars within 10 days of launch, and the official repo now shows ~91k, so 25k was accurate when recorded and is far out of date now. Verdict: Confirmed (at recording time).
  • Code parsing runs entirely locally with no LLM or API calls. 02:27 — The repo README states code is “parsed with tree-sitter AST: deterministic, no LLM, nothing leaves your machine.” Verdict: Confirmed.
  • Audio/video is transcribed locally and free with Faster-Whisper. 02:47 — SYSTRAN/faster-whisper is an open-source (MIT) local Whisper reimplementation via CTranslate2, up to 4x faster than openai/whisper; Graphify’s docs confirm it’s the transcription pass. Verdict: Confirmed.
  • The repo claims a 71.5x token reduction on a 52-file corpus. 04:50 — The v1 README states “71.5x fewer tokens per query vs reading the raw files” on a 52-file corpus of Karpathy repos, papers, and images — and itself notes the reduction “approaches parity” on small corpora, matching the video’s critique. Verdict: Confirmed (claim exists as described, with the caveat the video raises).
  • Install is pip install graphifyy (double y) with CLI commands graphify install and graphify claude install. 05:23 — PyPI: graphifyy exists (package graphifyy, CLI graphify), and the repo documents graphify install plus platform-specific graphify claude install / graphify codex install. Verdict: Confirmed.
  • graphify update re-processes only changed files, and graphify hook install wires git hooks to rebuild on commit/branch switch. 07:34 — The repo README documents graphify update ./src (“re-extract only changed files”) and graphify hook install (post-commit/post-checkout hooks). Verdict: Confirmed.
  • Output lands in graphify-out/ with GRAPH_REPORT.md and an interactive graph.html. 06:28 — The README confirms graphify-out/ containing GRAPH_REPORT.md, graph.html, and graph.json. Verdict: Confirmed.

Tools, Papers & Standards Mentioned

Follow-up Questions

  • What does the graph-build itself cost in Claude API tokens for a large repo (pass 3), and after how many sessions does that one-time cost break even against the ~7–8% per-session savings the video measured?
  • Does the video’s claimed answer-quality improvement hold up under blind evaluation, and how does Graphify’s graph-first retrieval compare quantitatively against embeddings-based RAG or Claude Code’s own built-in search on the same question set?
  • How stale does the graph get in fast-moving repos between rebuilds, and can the git-hook rebuild path introduce wrong “facts” (e.g., edges from deleted code) that mislead Claude worse than no graph at all?

Sources