Graphify getest: wat de kennisgraaf van je code ziet en wat niet (november 2026)

Ik vroeg Graphify wat er geraakt wordt als ik Auth::requireAuth() verander, de functie die elke beheerpagina van deze site achter een login zet. Het antwoord kwam in een halve seconde: No affected nodes found. Achttien bestanden roepen die functie aan. Een codeeragent die dat antwoord gelooft, kan de controle aanpassen of weghalen in de veronderstelling dat er niets van afhangt.

Graphify is in november 2026 een van de snelst gegroeide ontwikkeltools op GitHub, met ruim 144.000 sterren in zeven maanden. Het belooft dat je codeeragent minder tokens verbruikt omdat hij een kennisgraaf van je project raadpleegt in plaats van te grep'en. Ik heb versie 0.9.104 gedraaid op de 153 PHP-bestanden van deze website, de broncode van de benchmark gelezen en de onafhankelijke metingen opgezocht. Hieronder staat wat het programma doet, waar het goed in is, waarom het de helft van een gewone PHP-site niet ziet, en hoe je dat in je eigen project in tien seconden controleert.

Kort antwoord. Graphify (Python, Apache 2.0) maakt van je code een graaf van klassen, functies, aanroepen en imports, met tree-sitter en zonder taalmodel. Je agent kan die graaf bevragen met graphify query, path, explain en affected. Voor code in klassen en functies werkt dat snel en betrouwbaar: 153 bestanden in 3,5 seconden. Code die direct in een bestand staat, buiten elke functie, krijgt geen enkele edge. Op deze site mist de graaf daardoor 21 van de 25 bestanden die de klasse Post gebruiken. De beloofde tokenbesparing is niet onafhankelijk bevestigd. Gebruik het als kaart van je architectuur, niet als bewijs dat iets nergens gebruikt wordt.

Wat is Graphify?

Graphify is een opdrachtregelprogramma en een skill voor codeeragents zoals Claude Code, Codex, Cursor en Gemini CLI. Het leest een map met code, en eventueel documenten, pdf's en afbeeldingen, en schrijft drie bestanden weg: graph.json met de volledige graaf, GRAPH_REPORT.md met de belangrijkste knooppunten en een interactieve graph.html. De agent stelt daarna vragen aan de graaf in plaats van bestanden te openen.

De repository verscheen op 3 april 2026, een dag nadat Andrej Karpathy op X beschreef hoe je met taalmodellen persoonlijke kennisbanken bouwt. De maker, Safi Shamsi, schrijft zelf dat het project 48 uur na die post viraal ging. Het bedrijf Graphify Labs zit inmiddels in de zomerbatch van Y Combinator en verkoopt een betaalde cloudversie. De opensourceversie viel tot 22 juli onder MIT en sindsdien onder Apache 2.0, vanwege het expliciete octrooirecht. Wie wil weten hoe Karpathy zelf met agents werkt: ik schreef eerder over de skills van Andrej Karpathy.

Let op de naam van het pakket. Op PyPI heet het graphifyy, met twee y's, het commando zelf heet graphify. De README waarschuwt dat andere pakketten met "graphify" in de naam niet van de makers zijn, en in issue #280 werd al op die verwarring gewezen.

Hoe bouwt Graphify de graaf?

Volgens de eigen uitleg gebeurt het in drie rondes, en alleen de laatste kost geld.

Daarna deelt het algoritme Leiden de graaf op in groepen knooppunten die veel met elkaar verbonden zijn, de "communities". Zonder de optionele extra leiden valt Graphify volgens de README stil terug op Louvain, een ouder algoritme met hetzelfde doel. Elke edge krijgt een label: EXTRACTED als de relatie letterlijk in de code staat, INFERRED als Graphify haar afleidt (met een score van 0,55 tot 0,95), AMBIGUOUS als het twijfelt. Er zitten geen embeddings of vectordatabase in. Dat is een bewuste keuze en een wezenlijk verschil met zoeken op betekenis met vectoren: Graphify vindt alleen wat letterlijk met elkaar verbonden is.

Die derde ronde loopt sneller op dan je zou denken. Een gebruiker mat 28.000 tot 30.000 tokens per afbeelding, en een ander betaalde $4,31 waar $1,50 verwacht was. Met --code-only sla je die ronde over. Dat heb ik gedaan.

De test: 153 PHP-bestanden van deze site

Deze website draait op PHP zonder framework: klassen in classes/ met een eigen autoloader, en pagina's zoals blog/post.php die bovenaan new Post() doen en daarna HTML uitspugen. Dat is de vorm van ontelbare PHP-projecten, van oude maatwerksites tot WordPress-thema's. Ik heb Graphify 0.9.104 in een losse Python-omgeving geïnstalleerd en het laten lopen op een kopie van alle PHP-bestanden in git, zonder de migraties en vendor/: 153 bestanden, 29.304 regels.

uv venv --python 3.12 venv
uv pip install --python venv/Scripts/python.exe "graphifyy==0.9.104"
cd site
set GRAPHIFY_BACKEND=none
venv\Scripts\graphify extract . --code-only

GRAPHIFY_BACKEND=none zet elk taalmodel uit, ook voor het benoemen van de communities. Op mijn laptop (Windows 11, i9-13980HX, 16 GB) duurde een koude run 3,4 tot 3,8 seconden, en met de cache 1,7 seconden. Graphify verwerkt bestanden parallel in 32 processen.

[graphify extract] found 153 code, 0 docs, 0 papers, 0 images
  warning: 53 code file(s) yielded no symbols (0.18 MB) — a data file, or source
  this extractor models no symbols for: 404.php, admin/_sidebar.php, admin/activity.php, …
[graphify extract] wrote …/graph.json: 957 nodes, 1360 edges, 124 communities

De lijst met belangrijkste knooppunten ("god nodes") klopt: Database met 32 edges, dan Backup, Post, SearchConsoleClient, HealthCheck, Portfolio en Auth. Wie deze code nooit zag, weet na die tien regels waar je moet beginnen. 92 procent van de edges is EXTRACTED. Ook de JavaScript in de <script>-blokken van de PHP-pagina's staat in de graaf, sinds versie 0.9.64 van 18 september.

Minder bruikbaar is de rest van het rapport. De communities heten "Community 0" tot "Community 123", want namen geven kost een taalmodel. De "verrassende verbanden" zijn vijf testbestanden die de klasse aanroepen die ze testen. En de waarschuwing over 53 bestanden zonder symbolen bleek de belangrijkste regel van de hele uitvoer.

Code buiten een functie ziet de graaf niet

Die 53 bestanden zijn geen databestanden. Het zijn de pagina's van de site: de homepage, het blog, de RSS-feed, het hele beheergedeelte. Ze bevatten geen klassen of functies, alleen code die van boven naar beneden draait. Twee bestanden van vijf regels laten zien wat er dan gebeurt:

Dit is geen PHP-fout. Graphify koppelt een aanroep aan de functie of methode waarin hij staat. Code bovenaan een bestand heeft zo'n omhulsel niet, dus er is geen "aanroeper" en dus geen edge. Een gebruiker beschreef dat in juli in issue #1972 als "uniform across languages": het geldt ook voor Python-scripts, Ruby-rakefiles en losse JavaScript-modules. Een correctie die het bestand zelf als aanroeper gebruikt, ligt sinds 19 juli klaar in pull request #2016, maar is op 9 november nog niet samengevoegd.

Voor een project waarin alles in klassen zit, maakt het weinig uit. Een Laravel-app met controllers, modellen en services zou grotendeels zichtbaar moeten zijn; dat is een afleiding uit hoe de extractor werkt, ik heb geen Laravel-project getest. Voor een site zoals deze is het gat groot, en precies op de plek waar het pijn doet. Beheerpagina's beginnen met een toegangscontrole, en die staat altijd bovenaan.

Vraag je de graaf iets over zulke code, dan krijg je geen foutmelding maar een leeg antwoord. graphify affected ".requireAuth()" meldt No affected nodes found., en een agent die de instructie volgt om eerst de graaf te raadplegen, kan dat lezen als "niemand gebruikt dit".

Zo controleer je je eigen project

Het volgende script legt graph.json naast een simpele tekstzoekactie. Het zoekt de klasse en haar methodes in de graaf, verzamelt de bestanden met een echte edge ernaartoe (aanroep, import, verwijzing), en vergelijkt die met de bestanden waarin new Klasse of Klasse:: voorkomt. Het heeft PHP 7.4 of hoger nodig en geen packages.

graph-blinde-vlekken.php

<?php
declare(strict_types=1);

/**
 * graph-blinde-vlekken.php: legt Graphify's graph.json naast een simpele tekstzoekactie.
 * Gebruik: php graph-blinde-vlekken.php <projectmap> <Klassenaam>
 * Toont de PHP-bestanden die de klasse gebruiken (new X, X::) maar in de graaf geen enkele edge naar X hebben.
 * Exitcode: 0 = geen blinde vlekken, 1 = wel, 2 = verkeerde invoer.
 */

if ($argc !== 3) {
    fwrite(STDERR, "Gebruik: php {$argv[0]} <projectmap> <Klassenaam>\n");
    exit(2);
}
[, $root, $class] = $argv;

$norm = static fn (?string $path): string => str_replace('\\', '/', (string) $path);
$root = rtrim($norm(realpath($root) ?: ''), '/');
if ($root === '' || !preg_match('/^[A-Za-z_][A-Za-z0-9_]*$/', $class)) {
    fwrite(STDERR, "Onbekende map of ongeldige klassenaam\n");
    exit(2);
}

$graphFile = "$root/graphify-out/graph.json";
$json = is_file($graphFile) ? file_get_contents($graphFile) : false;
$graph = $json === false ? null : json_decode($json, true);
if (!is_array($graph) || !isset($graph['nodes'])) {
    fwrite(STDERR, "Geen leesbare $graphFile. Draai eerst: graphify extract . --code-only\n");
    exit(2);
}

// 1. De klasse-node en haar methodes (Graphify koppelt methodes met de relatie "method").
$targets = [];
foreach ($graph['nodes'] as $node) {
    if (($node['label'] ?? '') === $class) {
        $targets[$node['id']] = true;
    }
}
if ($targets === []) {
    fwrite(STDERR, "Klasse $class staat niet in de graaf\n");
    exit(2);
}
$edges = $graph['links'] ?? $graph['edges'] ?? [];
foreach ($edges as $edge) {
    if ($edge['relation'] === 'method' && isset($targets[$edge['source']])) {
        $targets[$edge['target']] = true;
    }
}

// 2. Bestanden waarin de graaf een echte edge naar die nodes heeft (structuur-edges tellen niet mee).
$structural = ['method' => true, 'contains' => true];
$inGraph = [];
foreach ($edges as $edge) {
    if (!isset($structural[$edge['relation']]) && isset($targets[$edge['target']])) {
        $inGraph[$norm($edge['source_file'] ?? '')] = true;
    }
}

// 3. Bestanden die de klasse in de tekst gebruiken.
$pattern = '/\bnew\s+\\\\?' . $class . '\b|\b' . $class . '::/';
$inText = [];
$files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($root, FilesystemIterator::SKIP_DOTS));
foreach ($files as $file) {
    $path = $norm($file->getPathname());
    if ($file->getExtension() !== 'php' || preg_match('#/(vendor|graphify-out|node_modules)/#', $path)) {
        continue;
    }
    if (preg_match($pattern, (string) file_get_contents($path))) {
        $inText[substr($path, strlen($root) + 1)] = true;
    }
}

$missing = array_keys(array_diff_key($inText, $inGraph));
sort($missing);
printf(
    "%s: %d bestanden gebruiken de klasse, de graaf heeft een edge voor %d daarvan.\n",
    $class,
    count($inText),
    count(array_intersect_key($inText, $inGraph))
);
foreach ($missing as $path) {
    echo "  niet in de graaf: $path\n";
}
exit($missing === [] ? 0 : 1);

Op deze site:

$ php graph-blinde-vlekken.php . Post
Post: 26 bestanden gebruiken de klasse, de graaf heeft een edge voor 4 daarvan.
  niet in de graaf: admin/analytics.php
  niet in de graaf: admin/api-seo-ai.php
  …
  niet in de graaf: blog/post.php
  niet in de graaf: classes/PostRevision.php
  …
  niet in de graaf: tests/unit/slug_redirects.php

Eén van die 22 is vals alarm: classes/PostRevision.php noemt Post::update() alleen in een commentaarregel. Daar is de graaf slimmer dan een tekstzoekactie, want tree-sitter weet wat commentaar is. De andere 21 zijn echte aanroepen, zoals regel 10 van blog/post.php: $postModel = new Post();. Voor Auth is het verschil nog groter: 33 bestanden, waarvan 1 in de graaf.

Het script stopt met exitcode 1 als het blinde vlekken vindt, dus je kunt het in een CI-stap zetten voor de klassen waar veel van afhangt. Getest met PHP 7.4.33, 8.2.35 en 8.3.36 op de graaf van deze site, op de twee voorbeeldbestanden en op foute invoer.

Bespaart Graphify echt tokens?

Rond Graphify circuleren drie getallen, en ze meten alle drie iets anders.

"Cut agent token spend by 80%" staat bovenaan de README, maar gaat over de betaalde cloudversie. Ik vond er geen meting van, en explainx.ai evenmin.

"71,5x minder tokens per vraag" komt uit de eigen documentatie, gemeten op 52 bestanden: repositories van Karpathy, vijf wetenschappelijke artikelen en vier afbeeldingen. Bij een bibliotheek van zes bestanden noemt dezelfde tabel "~1x". De vergelijking is telkens: de antwoordtekst van de graaf tegenover het hele corpus in één keer lezen.

De ingebouwde benchmark gaf op mijn code "25,8x fewer tokens per query". Ik heb de broncode gelezen om te zien waar dat vandaan komt. Als je graphify benchmark los aanroept, telt het je bestanden niet. Het schat de omvang als aantal nodes keer 50 woorden: 957 × 50 = 47.850 woorden, ofwel ongeveer 63.800 tokens. Mijn PHP-bestanden zijn samen 1.432.136 tekens, met dezelfde vuistregel van vier tekens per token ongeveer 358.000 tokens. Twee van de vijf testvragen vonden niets ("how does authentication work" en "how are errors handled") en tellen niet mee. Het getal zegt dus weinig, in welke richting dan ook.

Belangrijker is dat geen agent ooit het hele project inleest om één vraag te beantwoorden. Een agent zoekt met grep en opent daarna een paar bestanden. Tegen die werkwijze is het verschil kleiner, en daar zijn wel metingen van:

• In issue #985 (mei 2026, nog open) schrijft een gebruiker die Graphify in het eigen bedrijf invoerde dat "Claude Code alone seems to provide similar results with the same or even lower token consumption". Een tweede gebruiker mat op een grote .NET-monorepo 1,6 tot 1,9 keer hogere kosten met Graphify, voor een minder volledig antwoord.
• Srijan, die code aan Graphify bijdraagt, deed 360 proeven op Airflow, VS Code en Spring met Claude Code en Codex (16 oktober). De conclusie: de graaf maakte sterke agents "not clearly more accurate or cheaper". De agents vonden de juiste bestanden met grep in de eerste paar stappen en lazen ze daarna toch. Een nieuwe versie van de hook bespaarde in een kleine run ongeveer 13 procent.
• De eigen benchmark op ERPNext, een project van ongeveer een miljoen regels, laat iets positiefs zien: met Graphify als extra gereedschap dekten de antwoorden 82,0 procent van de kernfeiten, tegen 70,8 procent met alleen grep. Dat zijn wel zes vragen, met ongeveer 140.000 tokens per vraag, gemeten door de makers.

Mijn lezing: de graaf helpt bij vragen over structuur in een groot, onbekend project, zoals "hoe hangen deze twee subsystemen samen?". Voor een vraag als "waar staat deze functie?" is grep in één stap klaar en goedkoper.

Dat de zoekfunctie letterlijk werkt, merkte ik ook. graphify query "how does authentication work" gaf "No matching nodes found", omdat de klasse Auth heet en niet "authentication". graphify query "how does Auth check the CSRF token" gaf wel een nette subgraaf van 24 knooppunten met alle CSRF-methodes en hun regelnummers. De vraag moet de namen uit je code bevatten.

Wat Graphify aan Claude Code verandert

Met graphify claude install zet Graphify een blok in CLAUDE.md met als regel: "run graphify query before your first grep, search or source-file read". Daarnaast komt er een PreToolUse-hook die de agent een duwtje geeft als hij toch gaat zoeken of bestanden leest. Met --strict weigert die hook één keer per sessie zelfs een leesactie, als de graaf het bestand kent en de agent de graaf het afgelopen halfuur niet heeft geraadpleegd. Wie Claude Code net gebruikt: dit soort regels bepaalt hoe de agent werkt, dus lees ze voordat je ze installeert.

Die duwtjes kostten geld. Een gebruiker telde in issue #3435 8.348 herinneringen in 87 sessies, samen ongeveer 651.000 tokens, 3,7 keer meer dan alle echte Graphify-vragen in die sessies. Dat is inmiddels begrensd: standaard vijf herinneringen per sessie (GRAPHIFY_HOOK_NUDGE_CAP).

Een ander probleem bestaat nog. Issue #3791 meldt dat een herinstallatie alles in CLAUDE.md onder het Graphify-blok kan wissen, als er na dat blok geen kop met één # meer komt. De melder verloor 217 regels. Ik heb de reproductie uit het issue gedraaid met 0.9.104, in een tijdelijke map via CLAUDE_CONFIG_DIR: het bestand ging van 7 naar 3 regels, en mijn sectie "## My own rules" was weg. Een waarschuwing kwam er niet; de uitvoer eindigde met een link naar de proefversie van de cloud. Maak dus een kopie van je CLAUDE.md voordat je installeert, of installeer per project met --project in een map onder git.

Veiligheid en privacy

• Code blijft lokaal zolang je --code-only gebruikt of GRAPHIFY_BACKEND=none zet. Zonder die instelling kiest graphify extract zelf een aanbieder op basis van de API-sleutels die het vindt, in de volgorde Gemini, Kimi, Claude, OpenAI. De README meldt dat Kimi naar servers van Moonshot AI in China gaat.
• Elke vraag wordt gelogd in ~/.cache/graphify-queries.log: tijd, vraag, project. Uitzetten met GRAPHIFY_QUERY_LOG_DISABLE=1.
• graph.html laadt een script van internet: vis-network 9.1.6 via unpkg.com. Wie de graaf offline of op een afgeschermde machine opent, ziet niets.
• Indexeer geen code die je niet vertrouwt met een oude versie. Beveiligingsmelding GHSA-pcc4-rvhr-2pr8 (ernst hoog, 27 september) beschrijft hoe een Fortran-bestand met een slimme #include bestanden van je computer in de graaf kon trekken, zoals een SSH-sleutel. Opgelost in 0.9.70.

Wanneer is Graphify de moeite waard?

Veelgestelde vragen

Is Graphify gratis?

Ja. Het opensourceprogramma valt onder Apache 2.0, en het bouwen van een graaf van alleen code kost geen tokens. Je betaalt alleen voor de semantische ronde over documenten, pdf's en afbeeldingen, of voor de cloudversie van Graphify Labs.

Stuurt Graphify mijn code naar een taalmodel?

Niet voor code: die wordt lokaal met tree-sitter gelezen. Documenten, pdf's en afbeeldingen gaan wel naar het model van je codeeragent of naar een API waarvan je de sleutel hebt ingesteld. Met --code-only of GRAPHIFY_BACKEND=none sluit je dat uit.

Werkt Graphify met PHP?

Ja, voor klassen, functies, methodes, closures, use-imports, new en statische aanroepen binnen functies. Code die direct in een bestand staat, buiten elke functie, krijgt in versie 0.9.104 geen edges (issue #1972). require_once en include worden niet als import vastgelegd.

Wat is het verschil met een vectordatabase of RAG?

Een vectordatabase vindt tekst die qua betekenis lijkt op je vraag. Graphify vindt wat in de code met elkaar verbonden is: wie roept wie aan, wie erft van wie. Daarom vond het bij mij niets voor "authentication" terwijl de klasse Auth heet.

Hoe haal ik Graphify weer weg?

graphify uninstall haalt de skill, het CLAUDE.md-blok en de hooks weg bij alle platforms, en --purge wist ook graphify-out/. Maak ook hier eerst een kopie van CLAUDE.md: de melder van issue #3791 vermoedt, na het lezen van de code, dat verwijderen dezelfde fout heeft als installeren.

Een kennisgraaf die zegt dat niets van requireAuth() afhangt, is gevaarlijker dan geen kennisgraaf, omdat het antwoord zo zeker klinkt. Graphify is een goed gemaakte kaart van wat er in je klassen en functies staat, gratis te bouwen en in een paar seconden klaar. Lees een leeg antwoord dus als "dat weet de graaf niet" en laat je agent in dat geval gewoon grep'en. Draai het controlescript één keer op je eigen project: dan weet je hoe groot het onbekende deel bij jou is.

Verder lezen op deze site

• Claude Code in PhpStorm: installatie, plugin en de gewoontes die werken
• Herdr, Caprock en ccdeck vergeleken: zo houd je meerdere codeeragents bij (november 2026)
• Claude Code effectief gebruiken: wat echt werkt in 2026
• Een AI-agent bouwen in PHP: compleet voorbeeld met Composer, Claude en MCP

Bronnen

Officiële documentatie en broncode

• Graphify Labs, Graphify-Labs/graphify: README, How graphify works, BENCHMARKS.md (bijgewerkt 5 juli 2026), SECURITY.md, CHANGELOG en graphify/benchmark.py, versie 0.9.104 van 8 november 2026, gelezen op 9 november 2026
• Graphify Labs, commit ba7f9ea, overstap van MIT naar Apache 2.0, 22 juli 2026
• Graphify Labs, beveiligingsmelding GHSA-pcc4-rvhr-2pr8, 27 september 2026, opgelost in 0.9.70
• Safi Shamsi, GitHub-profiel (herkomst van het project, volgens de maker zelf), en Y Combinator, bedrijfspagina Graphify Labs (batch S26), geraadpleegd op 9 november 2026

Issues en pull requests

• #1972 code buiten een definitie krijgt geen edges (17 juli 2026, open) en PR #2016 met een correctie (19 juli 2026, open)
• #985 Graphify tegenover Claude Code alleen (22 mei 2026, open)
• #3435 tokenkosten van de hook (9 september 2026, gesloten 12 oktober)
• #3791 installatie wist inhoud van CLAUDE.md (24 september 2026, open)
• #450 en #730 kosten van de semantische ronde; #280 verwarring over de pakketnaam

Onafhankelijke en andere bronnen

• Srijan, Does graphify help coding agents on big codebases?, 16 oktober 2026. De auteur draagt code bij aan Graphify; de proeven gebruikten prototypes van de hook, niet de uitgebrachte versie.
• Yash Thakker, explainx.ai, Graphify: codebase knowledge graph skill, 20 oktober 2026

Eigen metingen

• 9 november 2026, Windows 11, Intel i9-13980HX, 16 GB, Python 3.12, graphifyy 0.9.104 zonder extra's (dus Louvain in plaats van Leiden), GRAPHIFY_BACKEND=none. Corpus: 153 PHP-bestanden van vandeblaak.com die in git staan, zonder migraties en vendor, 29.304 regels, 1.432.136 tekens. Tijden: drie koude runs (3,4 tot 3,8 s) en drie runs met cache (1,7 s), gemeten met PowerShell Measure-Command.
• Aantallen "gebruikt de klasse" met een tekstzoekactie op new Klasse en Klasse::; voor Post is één treffer een commentaarregel (meegeteld in de 26, niet in de 25). De 18 aanroepen van requireAuth zijn met de hand nagelopen.
• Issue #3791 nagespeeld met de reproductie uit het issue, in een tijdelijke map via CLAUDE_CONFIG_DIR.
• Het controlescript is getest met PHP 7.4.33, 8.2.35 en 8.3.36.