Smorster

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

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

Decision Card

Effort: ~20 min to install and build your first graph on one project (uv tool install graphifyy && graphify install, then /graphify), plus ~12 min of unattended graph-building time per large repo as shown in the video.

Honest take: The presenter is refreshingly honest that his own test showed only ~7–8% token savings, not the headline “71.5x” — that benchmark compares Graphify against a strawman workflow (pasting all 52 files into context) that nobody actually uses, so the real win is answer quality and fewer wrong-direction reads, not raw token count.

Concrete next steps:

  • Install on one mixed-content project (code + docs) and run /graphify, then ask 2–3 architecture questions you’d normally ask cold (~20 min). (repo)
  • If you keep it, wire graphify hook install so the graph rebuilds on commit/branch-switch (~2 min).
  • Skip if your projects are small, single-language, or you mostly run short one-off sessions — the savings “grow with session length” and project size, so small/short workflows see little benefit 09:08.

TL;DR

Graphify scans a project once, builds a queryable knowledge graph (code via local AST parsing, audio/video via local Whisper, docs via a one-time Claude pass), and injects a graph summary at the start of every AI session so the assistant makes a few targeted reads instead of re-reading everything. The presenter’s own A/B test found modest token savings (~7–8%) but noticeably better answer quality, and he debunks the repo’s “71.5x” claim as measuring an unrealistic baseline.

Key Points

  • Without a persistent map, every new AI session rebuilds project understanding from scratch, re-reading the same files and burning the same tokens 00:38
  • Graphify reads the project once, builds a knowledge graph of connections, and the assistant reads that graph at session start instead of re-reading files 00:54
  • The system is three passes: local code parsing (no API/tokens), local audio/video transcription via Faster-Whisper, and a one-time Claude sub-agent pass over docs/PDFs/images 02:12
  • Only pass three touches the Claude API and only runs once; afterward every session reads the cached graph for free 03:06
  • In the presenter’s 10-question A/B test, token use was 120k (no Graphify) vs 113k (with) — under 8% difference, not the advertised figure 04:03
  • Answer quality was visibly better with Graphify — e.g., it explained each of three phases in detail plus loop-detection/replanning, where the baseline just named functions 04:23
  • The “71.5x” benchmark measures naive load-all-52-files (~123k tokens) vs Graphify’s ~1,700 tokens/query — a workflow the presenter says nobody actually uses 08:17
  • Install is pip install graphifyy (double-y) then graphify install, then graphify claude install to auto-load it every session 05:23
  • Output lands in graphify-out/ with GRAPH_REPORT.md and an interactive graph.html; the demo found 4,041 nodes, 20,900 edges, 185 communities 06:24
  • It works on non-code folders too — research notes, transcripts, PDFs, meeting recordings — making it useful for research vaults and planning folders 09:36

Notable Quotes

“Every session, it rebuilds the same understanding from scratch. It burns the same tokens, makes the same searches, re-reads the same files every time.” 00:46

“Pass three is the only part that touches Claude’s API and it only runs once. After that, every session reads the cached graph for free.” 03:06

“Nobody works by pasting 52 files into a Claude conversation… So that 71 times benchmark is comparing against a workflow most people don’t actually use.” 08:47

Verified Claims

Graphify is a real open-source tool with ~25,000 stars (at recording time). 02:04

Code is parsed locally via tree-sitter with no external API calls or tokens used. 02:27

  • Graphify README: “Code is extracted locally with no API calls (AST via tree-sitter)”
  • Verdict: Confirmed

Audio/video is transcribed locally and for free using Faster-Whisper. 02:47

  • SYSTRAN/faster-whisper — open-source CTranslate2 reimplementation of Whisper, up to ~4x faster, runs locally
  • Verdict: Confirmed

An algorithm groups related concepts into “neighborhoods”/communities. 03:17

  • Graphify README: uses Leiden clustering to identify semantic communities (NetworkX + Leiden)
  • Verdict: Confirmed

The 71.5x figure is measured against loading all 52 files (~123k tokens) directly, at ~1,700 tokens/query. 08:17

  • Graphify README / repo reports 71.5x fewer tokens per query on a mixed corpus (Karpathy repos + papers + images)
  • PyShine writeup repeats the 71.5x-vs-raw-files framing
  • Verdict: Confirmed (the number is accurate; the presenter’s caveat that the baseline is unrealistic is fair)

Only pass three (docs/PDFs/images) uses the Claude API. 03:06

  • Graphify README: “Docs, PDFs, and images require API calls to your assistant’s model,” while code and media transcription run locally
  • Verdict: Confirmed

The tool was inspired by Andrej Karpathy’s “/raw folder” idea and shipped shortly after he described it. 02:04

  • MindStudio writeup and themenonlab blog describe Graphify as Karpathy-inspired; the repo includes a graphify clone for his nanoGPT repo
  • Verdict: Inconclusive on the exact “48 hours after” timing, but the Karpathy-inspiration framing is widely corroborated

Install is pip install graphifyy (double-y) then graphify install. 05:23

  • graphifyy on PyPI — package name is indeed graphifyy; uv tool install graphifyy / pipx install graphifyy also documented
  • Verdict: Confirmed

Tools, Papers & Standards Mentioned

Follow-up Questions

  1. In real day-to-day sessions (tagging a folder and asking questions, not pasting files), what is the measured token and quality delta across project sizes — does the benefit actually scale with file count as claimed?
  2. How stale does the graph get between rebuilds, and does the git-hook auto-rebuild add meaningful latency or token cost on large repos with frequent commits?
  3. For privacy-sensitive codebases, what exactly is sent to the Claude API during pass three (docs/PDFs/images), and can that pass be disabled while keeping the local code+media graph?

Sources