Graphify installeren in Claude Code: zo werkt de kennisgraaf

Je vraagt Claude Code iets over je project en ziet eerst tientallen bestanden openen voordat er een antwoord komt. Dat kost tijd en tokens. Graphify bouwt één keer een kennisgraaf van je hele codebase, inclusief docs en PDF’s. Je assistent doorzoekt die graaf in plaats van losse bestanden (Bron: GitHub). Het open-source project (Apache-2.0) staat sinds april 2026 op GitHub, heeft inmiddels ruim 140.000 sterren en zit op versie 0.9.102 van 3 november 2026 (Bron: PyPI).

Update 4 november 2026 Sterren en versie zijn bijgewerkt (het origineel meldde ruim 129.000 sterren). De belofte van 80% minder tokens hoort in de README nu bij het gehoste Graphify Cloud. Voor de gratis tool beschrijft dit stuk het meetcommando graphify benchmark, plus --code-only en de git-hook.

Wat doet Graphify met je codebase?

Graphify ontleedt je code met tree-sitter, een parser die ongeveer 40 programmeertalen kent. Functies, klassen, tabellen en hun verbanden komen als knooppunten en lijnen in een graaf. Er zijn geen embeddings en geen vectordatabase: het is een echte graaf waar je doorheen loopt. Elke verbinding krijgt een label. EXTRACTED betekent dat het verband letterlijk in de bron staat, INFERRED dat Graphify het zelf heeft afgeleid (Bron: GitHub). Zo zie je welke verbanden hard zijn en welke een aanname.

Het werkt als skill in Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot CLI, Aider en meer dan twintig andere assistenten. Skills van derden zijn handig maar vragen om vertrouwen, want ze draaien met de rechten van je assistent. Hoe groot dat risico is, lees je in AI-skills als beveiligingsrisico: OWASP’s nieuwe top 10. En ben je op zoek naar andere skills, dan zet waarom vijf lijstjes met beste Claude skills elkaar tegenspreken de zoektocht in perspectief.

Hoe installeer je Graphify voor Claude Code?

Je hebt Python 3.10 of hoger nodig en bij voorkeur uv. Het pakket heet graphifyy met twee y’s. De README waarschuwt dat andere graphify*-pakketten op PyPI niet van de makers zijn (Bron: GitHub).

uv tool install graphifyy      # of: pipx install graphifyy
graphify install               # zonder vlag: de skill voor Claude Code

Zonder vlag zet graphify install de skill neer in ~/.claude/skills/graphify/SKILL.md en registreert hem in ~/.claude/CLAUDE.md. Voor een andere assistent geef je een vlag mee, bijvoorbeeld graphify install --platform codex. Cursor heeft een eigen opdracht: graphify cursor install (Bron: Graphify-documentatie). Wil je de skill alleen in één repository, voeg dan --project toe.

Let op De dubbele y staat zo op PyPI. Na de installatie typ je gewoon graphify, met één y. Vindt je shell het commando niet, draai dan eenmalig uv tool update-shell.

Hoe bouw je je eerste graaf?

Open je project in Claude Code en typ:

/graphify .

In de map graphify-out/ staan daarna drie bestanden:

Zit er veel documentatie of zitten er screenshots in je repository, dan kost de eerste run tokens, want die gaan langs het taalmodel. Alleen de code laten indexeren kan zonder model met graphify extract . --code-only (Bron: Graphify-documentatie). Gebruik je Codex, dan begin je opdrachten met $graphify in plaats van /graphify.

Hoe stel je vragen aan de graaf?

Zodra de graaf er staat, bevraag je hem in gewone taal:

/graphify query "waar wordt de betaalstatus bijgewerkt?"
/graphify path "OrderService" "InvoiceTable"
/graphify explain "retry-logica"

Met query krijg je een afgebakend stuk van de graaf terug dat bij je vraag past. path laat zien hoe twee onderdelen verbonden zijn en eindigt met de zekerheid van het zwakste stuk van dat pad. Met explain krijg je uitleg over één begrip. Past een naam op meerdere onderdelen, dan weigert Graphify te gokken en toont het de kandidaten. Begin met de vragen die GRAPH_REPORT.md zelf voorstelt: die laten snel zien of de graaf je project goed begrijpt.

Hoe houd je de graaf actueel?

Met graphify hook install wordt de codegraaf op de achtergrond opnieuw gebouwd na commits, branchwissels, merges en pulls. Dat kost geen modelaanroepen. Veranderen docs of afbeeldingen, dan werk je die bij met /graphify . --update (Bron: Graphify-documentatie). Met de extra mcp (uv tool install "graphifyy[mcp]") kun je de graaf ook als MCP-server aanbieden aan andere tools.

Wat verlaat je machine en wat niet?

Code wordt lokaal ontleed en blijft op je machine. Video en audio worden lokaal getranscribeerd. Docs, PDF’s en afbeeldingen gaan voor de semantische analyse naar een taalmodel: dat van je assistent als je /graphify gebruikt (Bron: GitHub).

Draai je graphify extract zonder assistent, dan kiest Graphify een aanbieder op basis van welke API-sleutel je hebt ingesteld en meldt het welke omgevingsvariabele de keuze bepaalde. Kimi stuurt data naar servers van Moonshot AI in China. Voor gevoelige code is --backend ollama volledig lokaal. Met GRAPHIFY_BACKEND=none zijn alle modelaanroepen uit. Volgens de README is er geen telemetrie.

Gevorderden Je vragen worden standaard gelogd in ~/.cache/graphify-queries.log, met tijdstip, vraag en aantal teruggegeven onderdelen. Werk je aan vertrouwelijke code, zet dan GRAPHIFY_QUERY_LOG_DISABLE=1 in je shellprofiel (Bron: GitHub).

Bespaart Graphify echt 80% aan tokens?

De README opent met “Cut agent token spend by 80%”, maar die zin gaat over Graphify Cloud, de gehoste variant die één live graaf over al je repositories bijhoudt. Een meting voor de gratis tool staat er niet bij.

Voor de gratis tool zit er een eigen teller in: graphify benchmark vergelijkt de tokens van je hele corpus met die van de antwoorden op vijf standaardvragen. De documentatie toont 136,8 keer minder tokens op een middelgrote Python-repository en 83,6 keer op httpx. Dezelfde pagina noemt de vergelijkingskant een schatting en geen gemeten prompt (Bron: Graphify-documentatie). Bovendien stuurt geen agent je hele repository mee. De eerlijke vergelijking is met grep en bestanden lezen.

Op die vergelijking meten de makers kwaliteit. Op ERPNext, een repository van zo’n miljoen regels, haalt een agent met één Graphify-tool 82,0% van de kernfeiten tegenover 70,8% met grep en lezen, bij ongeveer 140.000 tokens per vraag. Dat zijn zes vragen, dus een indicatie (Bron: BENCHMARKS.md). Een tokenvergelijking met die grep-baseline vond ik daar niet. Test het dus zelf: stel dezelfde vraag met en zonder graaf en kijk naar je verbruik. Wil je tokens langs een andere route besparen, dan comprimeert Headroom tool-output voordat het model die leest. Een verwant idee voor code review beschrijft Code Review Graph via MCP.

Checklist: ben je klaar?

• Python 3.10+ en uv of pipx geïnstalleerd
• graphifyy (twee y’s) geïnstalleerd en graphify install gedraaid
• Eerste graaf gebouwd met /graphify .
• GRAPH_REPORT.md gelezen en de voorgestelde vragen geprobeerd
• Besloten of docs en PDF’s naar een model mogen, anders --code-only of GRAPHIFY_BACKEND=none
• graphify hook install gedraaid zodat de graaf bijblijft
• Tokenverbruik met en zonder graaf vergeleken