# skill-shamsi-graphify-2026-08-06

## Veille

**Skill**-Eintrag (kein Artikel): **graphify** von **Safi Shamsi** (Graphify Labs, **Y Combinator S26**) verwandelt ein gesamtes Projekt — Code, Dokumentation, PDFs, Bilder, Videos — in einen **abfragbaren Wissensgraphen**, aufgerufen über `/graphify` aus Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot und etwa fünfzehn weiteren Clients. Beobachtet am **6. August 2026**: **103.187 Sterne**, **10.024 Forks**, Repository erstellt am **3. April 2026** — eine außergewöhnliche Entwicklung in vier Monaten. **Apache-2.0**, Python 3.10+, Standardbranch **v8**. **Die drei Gestaltungsprinzipien passen in drei Zeilen der README**: *„Code maps for free, fully local"* (Code wird zu einem **tree-sitter-AST** geparst, deterministisch, ohne LLM, **nichts verlässt die Maschine**); *„Every edge is explained"* (jede Kante wird mit **`EXTRACTED`** — explizit in der Quelle — oder **`INFERRED`** — von graphify hergeleitet — markiert, mit einem dritten Wert `AMBIGUOUS`, der im Report erscheint); und *„Not a vector index"* — *„no embeddings, no vector store: a real graph you traverse"*. **Drei Ausgaben**: `graph.html` (interaktiver Graph), `GRAPH_REPORT.md` (God Nodes, überraschende Verbindungen, vorgeschlagene Fragen) und `graph.json` (persistenter Graph, Wochen später abfragbar, ohne die Dateien erneut zu lesen). **Drei Abfragemodi** ersetzen grep: `query` (Subgraph für eine Frage in natürlicher Sprache), `path A B` (kürzester Pfad zwischen zwei Entitäten) und `explain` (Nachbarschaft eines Konzepts). **Abdeckung**: 36 tree-sitter-Grammatiken (~40 Sprachen), außerdem Terraform, Apex, **MCP-Konfigurationen**, Paketmanifeste, Office, Google Workspace, PDFs, Bilder und Video-/Audiotranskription **lokal** via faster-whisper. Communities erkannt via **Leiden**, beschriftet **ohne LLM**. ⭐ **Das interessanteste Benchmark-Ergebnis ist kein Sieg, sondern ein kostenloser**: bei LOCOMO erreicht graphify einen **Recall@10 von 0,497** gegenüber 0,149 für supermemory und 0,048 für mem0, **verliert aber bei der QA-Genauigkeit** (45,3 % gegenüber 49,7 %); bei LongMemEval-S erzielt es **76 %, gleichauf mit einem dense RAG**; und die entscheidende Zeile lautet *„Graph build — LLM credits: 0"*, wo die Branche üblicherweise pro Token abrechnet. ⚠️ **Festzuhaltende Punkte**: Der `main`-Branch führt noch eine README aus der v1-Ära, die ein anderes Produkt beschreibt (nur Claude-Code-Skill, die Behauptung „71,5× weniger Tokens"); das PyPI-Paket heißt **`graphifyy`** mit zwei *y*, bis der Name `graphify` zurückgewonnen wird; und standardmäßig wird ein **Query-Log** unter `~/.cache/graphify-queries.log` geschrieben, das über eine Umgebungsvariable deaktivierbar ist.

## Titre Article

graphify — « Turn any codebase, with its docs, SQL schemas, configs, and PDFs, into a queryable knowledge graph. A /graphify skill for Claude Code, Cursor, Codex, and Gemini CLI: local deterministic AST parsing, every edge explained, no vector store. »

## Date

2026-08-06

## URL

https://github.com/Graphify-Labs/graphify

## Keywords

Skill, Wissensgraph, Wissensgraph, AST, tree-sitter, deterministische statische Analyse, lokale Extraktion, kein LLM, NetworkX, Leiden, Community-Erkennung, God Node, überraschende Verbindungen, EXTRACTED, INFERRED, AMBIGUOUS, Kantenherkunft, Konfidenz, keine Vektoren, keine Embeddings, kein Vector Store, Graphdurchlauf, query, path, explain, graph.json, graph.html, GRAPH_REPORT, SHA256-Cache, inkrementelles Update, watch, Post-Commit-Hook, agentendurchsuchbares Wiki, MCP stdio, Neo4j, GraphML, Obsidian, multimodal, PDF, Vision, faster-whisper, lokale Transkription, Terraform, Apex, MCP-Konfigurationen, Paketmanifeste, Google Workspace, LOCOMO, LongMemEval, Recall, mem0, supermemory, dense RAG, null LLM-Credits, Datenresidenz, Ollama, Bedrock, Query-Log, Telemetrie, Y Combinator, Graphify Labs, Safi Shamsi

## Authors

**Safi Shamsi** — créateur et mainteneur de graphify, et de **Graphify Labs**, société passée par **Y Combinator (promotion S26)** selon le badge du dépôt. Il maintient aussi le site d'annuaire `graphify.net` (cf. [[graphify-net-annuaire-ia-coding-2026-08-06]]) et publie un livre, *The Memory Layer*, sur les idées et l'architecture derrière le projet.

**Trace d'historique à connaître** : le dépôt s'appelait `safishamsi/graphify` avant son transfert vers l'organisation `Graphify-Labs`. Le README de la branche `main` porte encore l'ancien chemin dans son badge d'intégration continue et dans sa procédure d'installation manuelle.

**Signaux d'adoption au 6 août 2026** : 103 187 étoiles, 10 024 forks, 823 issues ouvertes, dernier push la veille. Le dépôt affiche un badge Trendshift et propose son README en **33 langues**. Communauté sur Discord, page LinkedIn d'entreprise.

## Ton

**Profil**: dichte Open-Source-Projektdokumentation, geschrieben, um von einem eiligen Entwickler **und** von einem Agenten gelesen zu werden. Technisches Register, sehr wenige Versprechen, viele Tabellen — Dateitypen, Grammatiken, Umgebungsvariablen, eine vollständige Befehlsreferenz.

**Stil**: **Demonstration vor Argument**. Die README zeigt eine echte Ausgabe, bevor sie irgendetwas erklärt — einen `graphify explain "APIRouter"`-Befehl mit zeilenweise annotierter Nachbarschaft, dann ein `graphify path "FastAPI" "ModelField"`, das den Pfad über drei Hops anzeigt. Das Produkt wird bei der Arbeit an einem Repository gezeigt, das der Leser bereits kennt (FastAPI), bevor auch nur ein einziges kommerzielles Argument fällt.

**Drei bemerkenswerte Merkmale**:

1. **Die Position wird durch eine bewusste Verneinung definiert.** *„Not a vector index. No embeddings, no vector store: a real graph you traverse."* Das Projekt positioniert sich **gegen** vektorbasiertes RAG, mittlerweile Standard, und dieser Gegensatz strukturiert alles Weitere — Determinismus, Nullkosten, Kanten-Nachvollziehbarkeit.
2. **Ehrlichkeit gegenüber den eigenen Benchmarks.** Die Tabelle veröffentlicht eine **Niederlage**: 45,3 % QA-Genauigkeit bei LOCOMO gegenüber 49,7 % für supermemory. Wenige Projekte veröffentlichen die Spalte, in der sie verlieren.
3. **Die Datenschutzgrenze verläuft entlang des Dateityps, nicht entlang eines Prinzips.** Code bleibt lokal, ebenso Video (transkribiert via faster-whisper), Dokumente und Bilder gehen an das Modell. Der Abschnitt *Privacy* zählt Fälle auf, statt Lokalität zu versprechen.

**Dem Agenten auferlegtes operatives Register** (der „Ton" im für Skill-Einträge verwendeten Sinn): Das Tool schreibt dem Agenten nichts vor, es **stellt ein Substrat bereit**. Die README widmet einen ganzen Abschnitt *„Make your assistant always use the graph"* — das Ziel ist, dass der Agent den Graphen konsultiert, **bevor** er Dateien liest.

**Signalphrasen**: *„query instead of grepping"*, *„Code maps for free, fully local"*, *„Every edge is explained"*, *„you always know what was found vs guessed"*, *„a real graph you traverse"*, *„Graph build — LLM credits: 0"*.

## Pense-betes

- **Art**: `/graphify`-Skill + Python-CLI, Apache-2.0, auf PyPI unter dem Namen **`graphifyy`** verteilt (zwei *y*, bis `graphify` zurückgewonnen wird). Installation via `uv tool install graphifyy && graphify install`. Funktioniert in Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot und etwa fünfzehn weiteren Clients.
- **⭐⭐ Die drei Gestaltungsprinzipien, und sie greifen ineinander**: 1. **Code wird lokal geparst, ohne LLM.** tree-sitter-AST, deterministisch, *„nothing leaves your machine"*. Ein reines Code-Korpus erfordert **keinen API-Schlüssel** und läuft offline. Dokumente, PDFs und Bilder durchlaufen jedoch ein Modell. 2. **Jede Kante trägt ihre Herkunft.** `EXTRACTED` = explizit in der Quelle; `INFERRED` = von graphify hergeleitet; `AMBIGUOUS` im Report. *„You always know what was found vs guessed."* 3. **Kein Vektorindex.** Keine Embeddings, kein Vector Store: ein Graph, den man durchläuft. → **Die drei Prinzipien verstärken sich gegenseitig**: Determinismus macht die Kosten null, Nullkosten ermöglichen häufiges Neuaufbauen, und die Kantenbeschriftung macht das Ergebnis überprüfbar. Dieselbe Denkfamilie wie die ausführbare Datei, die das Briefing übertrifft, in [[lassiege-usine-logicielle-heure-ia-2026-07-28]].
- **⭐ Der Graph ersetzt grep, und das ist das Nutzungsargument**: `query "<Frage>"` liefert einen Subgraphen für eine Frage in natürlicher Sprache, `path A B` verfolgt den Pfad zwischen zwei Entitäten, `explain X` erschließt die Nachbarschaft eines Konzepts. Das Beispiel der README verdeutlicht dies: `path "FastAPI" "ModelField"` liefert einen Pfad über drei Hops mit dem Typ jeder Kante. **Man fragt nach einer Beziehung, nicht nach einem String-Treffer.** Genau das ist der Nutzen, den Hugo Lassiège in [[lassiege-usine-logicielle-heure-ia-2026-07-28]] GitNexus zuschreibt — *„searching for an execution flow rather than grepping a function name"* und *„the real point isn't speed, it's detecting all the side effects"*.
- **⭐⭐ Die Benchmark-Tabelle, richtig gelesen — die entscheidende Zeile ist kein Sieg**: | Benchmark | Metrik | graphify | Feld | |---|---|---|---| | LOCOMO (n=300) | recall@10 | **0,497** | supermemory 0,149 · mem0 0,048 | | LOCOMO (n=300) | QA-Genauigkeit | 45,3 % | **supermemory 49,7 %** · mem0 27,3 % | | LongMemEval-S (n=50) | QA-Genauigkeit | 76 % | **gleichauf** mit einem dense RAG | | Graphaufbau | LLM-Credits | **0** | anderswo pro Token abgerechnet | → **graphify dominiert weitgehend beim Recall, verliert bei der QA-Genauigkeit, liegt beim zweiten Benchmark gleichauf mit dense RAG und baut seinen Graphen kostenlos auf.** Das haltbare Unterscheidungsmerkmal sind daher **Kosten und Nachvollziehbarkeit, nicht die Antwortqualität**. graphify als „besser als RAG" darzustellen wäre eine Überinterpretation, der die eigenen Zahlen widersprechen. Anerkanntes Protokoll: gleicher Harness, gleiches Modell, gleiche Budgets, Richterurteil blind gegen einen zweiten Richter validiert (**90,6 % Übereinstimmung, Cohens Kappa 0,81**).
- **⭐ Ein Vergleich mit der einzigen vergleichbaren Zahl des Korpus lohnt sich**: Compare the Market maß einen AST-Graphen bei **~70 %** gegenüber **~58 %** für ein vektorbasiertes RAG bei 79 Merge Requests, wobei RAG **schlechter abschnitt als gar kein Kontext** (vgl. [[comparethemarket-context-retrieval-ai-code-review-gkg-rag-2026-03-06]], erneut aufgegriffen in [[sfeir-code-review-anneau-contraintes-2026-07-30]]). **Zwei unabhängige Messungen konvergieren zur Überlegenheit des strukturierten Graphen für Code** — und graphify fügt hinzu, dass der Aufbau nichts kostet.
- **Quellenabdeckung — breiter als „nur Code"**: 36 tree-sitter-Grammatiken für ~40 Sprachen (bis hinunter zu CUDA, Metal, Zig, Elixir, Julia, Dart, SystemVerilog, Delphi, Fortran), außerdem **SQL**, **Terraform/HCL**, **Apex Salesforce**, **MCP-Konfigurationen** (`.mcp.json`, `claude_desktop_config.json` — extrahiert Server, Pakete und erforderliche Umgebungsvariablen), **Paketmanifeste** (`pyproject.toml`, `go.mod`, `pom.xml` — ein kanonischer Knoten pro Paket, folglich ein einziger Hub), Office, Google Workspace, PDFs, Bilder, Video und Audio. ⭐ **Das Graphifizieren der eigenen MCP-Konfigurationen** ist eine unerwartete und unmittelbar nützliche Möglichkeit, die eigene Tooling-Oberfläche zu kartieren.
- **Das „Warum" als vollwertiges Objekt extrahiert**: `# NOTE:`-, `# WHY:`-, `# HACK:`-Kommentare, Docstrings und in der Dokumentation gefundene Design-Begründungen werden zu **eigenständigen Knoten, verlinkt mit dem Code, den sie erklären**. → **Intention wird als Graph-Entität behandelt**, was direkt die Verständnisschuld adressiert: Man kann nach dem *Warum* fragen, nicht nur nach dem *Was*.
- **Aktualität des Graphen, drei Mechanismen**: SHA256-Cache (nur geänderte Dateien werden neu verarbeitet), `--watch` (sofortiger Rebuild beim Speichern einer Code-Datei, **nur AST, ohne LLM**; Dokumente und Bilder markieren, dass ein `--update` nötig ist), und `graphify hook install` (**Post-Commit-Hook**, kein Hintergrundprozess). Der `--watch`-Modus wird explizit für Multi-Agent-Workflows begründet: *„the graph stays current between waves automatically"*.
- **Ausgaben für Agenten**: `--wiki` erzeugt enzyklopädieartige Artikel pro Community mit einer `index.md`, *„point any agent at index.md and it can navigate the knowledge base by reading files instead of parsing JSON"*. Und `--mcp` startet einen MCP-stdio-Server. Exporte nach Obsidian, GraphML (Gephi, yEd), Neo4j (Cypher), SVG. → **Der Graph ist darauf ausgelegt, von einer Maschine gelesen zu werden, mit mehreren Einstiegspunkten je nach Werkzeug.** Dieselbe Absicht wie das Markdown, das Agenten in [[martinho-allen-cloudflare-markdown-for-agents-2026-02-12]] bereitgestellt wird.
- **⚠️ Datenschutz — die Grenze ist subtil, wissenswert**:
- **Lokal**: Code (tree-sitter), Video und Audio (faster-whisper). Ein reines Code-Korpus läuft **offline**, und `--code-only` erzwingt diesen Modus bei einem gemischten Repository.
- **An das Modell gesendet**: Dokumente, PDFs, Bilder. Im Headless-Modus ist ein API-Schlüssel erforderlich, mit einer **automatischen Prioritätskette** (Gemini → Kimi → Claude → OpenAI → DeepSeek → Azure → Bedrock → Ollama). ⚠️ **Kimi leitet an Moonshot-AI-Server in China weiter** — die README weist darauf hin, und `--backend ollama` bietet einen vollständig lokalen Modus.
- **Keine Telemetrie**, kein Nutzungs-Tracking.
- ⚠️ **Standardmäßig wird jedoch ein Query-Log geschrieben** unter `~/.cache/graphify-queries.log` (Zeitstempel, Frage, Korpus, zurückgegebene Knoten, Dauer). Subgraphen werden nicht gespeichert. Deaktivierbar via `GRAPHIFY_QUERY_LOG_DISABLE=1`. **Lokal, aber ohne Opt-in aktiv**: wissenswert vor dem Einsatz in einem sensiblen Kontext.
- **⚠️ Zwei Dokumentationsfallen im Repository selbst**: 1. **Der `main`-Branch ist veraltet.** Er führt eine README aus der **v1**-Ära (7 KB), die *„a Claude Code skill"* für einen einzigen Client beschreibt, die Behauptung **„71,5× weniger Tokens"** bei einem 52-Datei-Korpus von Karpathy hervorhebt und noch auf `safishamsi/graphify` verweist. Der Standardbranch ist **v8** (57 KB), der ein Multi-Client-Produkt beschreibt und die LOCOMO-/LongMemEval-Benchmarks hervorhebt. **v8 lesen, niemals `main`.** 2. **Der Paketname**: `pip install graphifyy` (zwei *y*). CLI- und Skill-Befehl bleiben `graphify`.
- **Geschäftsmodell, zu beobachten**: Der Open-Source-Skill ist der Einstiegspunkt zu einer **kommerziellen Plattform** unter `graphify.com` — *„the always-on layer… applies the same graph approach to your entire working context: meetings, files, docs, and code, updating continuously in the background"*, derzeit über eine Warteliste, mit angekündigter kostenloser Testphase. **Lokale Open Source auf der einen, kontinuierlich gehosteter Dienst auf der anderen Seite**: ein klassisches Muster, das bei jeder Adoptionsentscheidung zu berücksichtigen ist.
- **⚠️ Die Traktion erfordert eine vorsichtige Lektüre**: **103.187 Sterne in vier Monaten** sind ein außergewöhnliches Tempo, selbst für ein virales Tool. Die Zahl ist das, was die GitHub-API am 6. August 2026 zurückgibt; sie sagt nichts über die tatsächliche Nutzung aus, und die offizielle Website des Projekts zeigt weiterhin **3.700** (vgl. [[graphify-net-annuaire-ia-coding-2026-08-06]]), ein Zeichen dafür, dass die Kommunikation nicht Schritt gehalten hat. **Die Sternezahl als Aufmerksamkeitssignal zitieren, niemals als Adoptionsmaß.**
- **Meta / Querverweise**: dieselbe Familie wie [[skill-gibbs-hyperresearch-2026-08-03]] (persistenter Speicher, Herkunftsnachweis, agentenlesbare Ausgabe), jedoch für Code statt dokumentarischer Recherche; realisiert in Produktform, was Hugo Lassiège in [[lassiege-usine-logicielle-heure-ia-2026-07-28]] von GitNexus erhält; numerische Konvergenz mit [[comparethemarket-context-retrieval-ai-code-review-gkg-rag-2026-03-06]] und [[sfeir-code-review-anneau-contraintes-2026-07-30]] zu AST-Graph versus vektorbasiertem RAG; fügt sich in den kodifizierten Kontext von [[vasilopoulos-codified-context-infrastructure-ai-agents-2026-02-24]] und die Kontextplattformen von [[memodb-acontext-context-data-platform-agents-2025-12-11]] ein; formale Verwandtschaft mit anderen Skill-Einträgen, [[skill-pocock-grill-with-docs-2026-06]]; Skill-Mechanik in [[agent-skills-anthropic-2025-10-16]], [[shihipar-claude-code-lessons-building-skills-2026-06-03]] und [[vincent-superpowers-agentic-skills-framework-github-2026-04-02]]. ⚠️ **Begriffsklärung**: Die Website `graphify.net` ist eine von `graphify.com` (der kommerziellen Plattform) getrennte Domain — siehe den eigenen Eintrag.

## RésuméDe400mots

**graphify** (Safi Shamsi, Graphify Labs, Y Combinator S26) verwandelt ein gesamtes Projekt in einen **abfragbaren Wissensgraphen**, aufgerufen über `/graphify` aus Claude Code, Cursor, Codex, Gemini CLI und etwa fünfzehn weiteren Clients. Beobachtet am 6. August 2026: **103.187 Sterne** für ein Repository, das am 3. April erstellt wurde, Apache-2.0, Python.

**Drei Grundprinzipien tragen das Projekt.** **Code wird lokal geparst** zu tree-sitter-AST, ohne LLM: deterministisch, nichts verlässt die Maschine, kein API-Schlüssel nötig für ein reines Code-Korpus. **Jede Kante trägt ihre Herkunft** — `EXTRACTED`, wenn explizit in der Quelle, `INFERRED`, wenn von graphify hergeleitet —, *„so you can tell what was read directly from what was inferred"*. Und das Projekt definiert sich **gegen vektorbasiertes RAG**: *„Not a vector index. No embeddings, no vector store: a real graph you traverse."*

**Die Nutzung ersetzt grep.** `query` liefert einen Subgraphen für eine Frage in natürlicher Sprache, `path A B` verfolgt den Pfad zwischen zwei Entitäten, `explain` erschließt ein Konzept. Drei Ausgaben: ein interaktiver Graph, ein lesbarer Report (God Nodes, überraschende Verbindungen, vorgeschlagene Fragen) und eine persistente `graph.json`, Wochen später abfragbar.

**Die Abdeckung reicht über Code hinaus**: 36 tree-sitter-Grammatiken, aber auch SQL, Terraform, Apex, **MCP-Konfigurationen**, Paketmanifeste, Office, PDFs, Bilder und lokal transkribiertes Video. `# WHY:`-Kommentare und Design-Begründungen werden zu **vollwertigen Knoten, verlinkt mit dem Code, den sie erklären**.

**Die Benchmarks verdienen eine genaue Lektüre.** Bei LOCOMO dominiert graphify beim Recall (0,497 gegenüber 0,149 und 0,048), **verliert aber bei der QA-Genauigkeit** (45,3 % gegenüber 49,7 %); bei LongMemEval-S liegt es mit 76 % **gleichauf mit einem dense RAG**. Die entscheidende Zeile liegt woanders: *„Graph build — LLM credits: 0"*. Das haltbare Unterscheidungsmerkmal sind **Kosten und Nachvollziehbarkeit, nicht die Antwortqualität**.

⚠️ **Drei Vorbehalte.** Der `main`-Branch führt eine veraltete README aus der v1-Ära, die ein anderes Produkt beschreibt: lesen Sie `v8`. Das PyPI-Paket heißt `graphifyy`, bis der Name zurückgewonnen wird. Und ein **lokales Query-Log** ist standardmäßig aktiv, deaktivierbar über eine Umgebungsvariable.

Der Skill dient zugleich als Einstiegspunkt zu einer wartelistengeführten kommerziellen Plattform unter graphify.com, die denselben Ansatz kontinuierlich auf den gesamten Arbeitskontext anwendet.

## Anti-patterns

- **Lire la branche `main`.** Elle décrit un produit de l'ère v1, mono-client, avec un argument marketing (« 71,5× moins de tokens ») que la version courante n'utilise plus. La branche par défaut est `v8`.
- **Citer « graphify bat le RAG ».** Ses propres benchmarks le contredisent : il perd en exactitude QA sur LOCOMO et **égale** un RAG dense sur LongMemEval-S. L'argument défendable est le coût nul et la traçabilité.
- **Annoncer « fully local » sans nuance.** Seul le code et la transcription vidéo le sont. Documents, PDF et images partent vers un modèle, sauf backend Ollama explicite.
- **Déployer en contexte sensible sans couper le journal de requêtes.** `~/.cache/graphify-queries.log` enregistre chaque question par défaut ; poser `GRAPHIFY_QUERY_LOG_DISABLE=1`.
- **Laisser la chaîne de priorité choisir le backend** dans un contexte à contrainte de résidence des données : la détection automatique peut router vers Kimi, donc vers des serveurs en Chine. Passer un `--backend` explicite.
- **Graphifier un corpus minuscule** en attendant un gain de tokens : en dessous de la taille d'une fenêtre de contexte, l'apport est structurel, pas économique.
- **Traiter 103 000 étoiles comme une mesure d'adoption.** C'est un signal d'attention sur quatre mois, rien de plus.

## Artefacts

**Sorties principales**, dans `graphify-out/` :
- `graph.html` — graphe interactif, nœuds cliquables, filtres par communauté, recherche
- `GRAPH_REPORT.md` — god nodes, connexions surprenantes avec leur justification en clair, 4-5 questions suggérées, étiquettes de confiance
- `graph.json` — le graphe complet, persistant et interrogeable

**Sorties optionnelles** : `wiki/` (articles par communauté avec `index.md`, pour navigation par un agent), `obsidian/` (coffre Obsidian), `graph.svg`, `graph.graphml` (Gephi, yEd), `cypher.txt` (Neo4j), serveur MCP stdio, `converted/` (passerelles markdown pour Google Workspace).

**Sous-produits** : `cache/` (empreintes SHA256 par fichier) et `~/.cache/graphify-queries.log` (journal des requêtes, actif par défaut).

## Commentaire

**En une phrase** : graphify parie que, pour du code, **un graphe déterministe construit gratuitement bat un index vectoriel payant** — et publie les chiffres qui le nuancent.

**L'idée centrale** tient dans une asymétrie que le projet exploite bien. Le code a une structure formelle : un analyseur syntaxique sait dire, sans deviner, que telle fonction en appelle telle autre. Le RAG vectoriel jette cette information pour la remplacer par une proximité statistique, et paie des tokens pour le faire. graphify garde la structure là où elle existe (le code, en AST local) et ne convoque un modèle que là où elle manque (la prose, les images). D'où les trois propriétés qui découlent l'une de l'autre : le déterminisme rend l'extraction gratuite, la gratuité rend la reconstruction fréquente possible, et la reconstruction fréquente rend le graphe fiable au lieu de périmé.

**Le second principe est la traçabilité.** Étiqueter chaque arête `EXTRACTED` ou `INFERRED` paraît mineur et change tout : on peut faire confiance différemment à deux relations selon leur origine, et un agent qui traverse le graphe sait quand il marche sur du solide. C'est la même discipline épistémique que les types de source dans une fiche de veille, ou que la distinction entre lecture et substitution dans [[skill-gibbs-hyperresearch-2026-08-03]].

**En résumé** : l'outil est utile, ses chiffres sont honnêtes, et son argument le plus fort est économique avant d'être qualitatif. Sa faiblesse tient à sa documentation — un dépôt dont la branche `main` décrit un produit périmé et dont le site officiel affiche 3 700 étoiles quand GitHub en compte 103 000 n'inspire pas confiance sur sa capacité à tenir sa propre cartographie à jour.

## Déclencheur

**Quand la skill s'active** : sur `/graphify <chemin>` dans un assistant de codage, après `uv tool install graphifyy && graphify install`. En dehors d'un assistant, la CLI `graphify extract` fait le même travail en mode headless, avec une clé d'API pour la partie sémantique.

**Entrées attendues** : un **répertoire quelconque** — dépôt de code, dossier de notes, corpus de PDF, mélange des trois. Aucune structure préalable n'est requise.

**Options qui changent le comportement** : `--code-only` (n'indexe que le code, donc aucun appel réseau), `--update` (ne retraite que les fichiers modifiés), `--watch` (reconstruction continue), `--wiki` (sortie navigable par un agent), `--mcp` (serveur MCP stdio), `--backend ollama` (tout en local, y compris la partie sémantique).

**Quand ne pas la déclencher** : sur un corpus de quelques fichiers qui tient déjà dans une fenêtre de contexte — le README le dit lui-même à propos de son exemple à 6 fichiers, *« graph value there is structural clarity, not compression »*. Et sur un corpus dont les documents sont confidentiels sans backend local configuré, puisque la passe sémantique les enverrait à un modèle distant.

## Fonctionnement

**Le pipeline se lit en quatre temps.**

1. **Extraction, par type de fichier.** Le code passe par tree-sitter : AST, graphe d'appels, docstrings, le tout déterministe et local. La prose, les PDF et les images passent par un modèle. La vidéo et l'audio sont transcrits localement par faster-whisper, puis traités comme de la prose. Les commentaires d'intention (`# WHY:`, `# HACK:`) sont extraits comme nœuds distincts.
2. **Résolution et fusion.** Les nœuds et arêtes sont fusionnés dans un graphe NetworkX. Les liens inter-fichiers (`calls`, `imports`, `inherits`, `mixes_in`) sont résolus à travers ~40 langages. Un paquet référencé depuis plusieurs manifestes devient **un seul nœud canonique**, donc un hub.
3. **Structuration.** L'algorithme **Leiden** découpe le graphe en communautés, **labellisées sans LLM**. Les nœuds de plus fort degré sont désignés *god nodes*. Les connexions inattendues sont classées par un score composite, une arête code-article pesant plus qu'une arête code-code.
4. **Restitution.** Trois artefacts, plus les exports optionnels. Chaque arête conserve son étiquette de provenance jusqu'à la sortie.

**La boucle de fraîcheur** est traitée à trois niveaux de coût croissant : le cache SHA256 évite tout retraitement inutile ; `--watch` reconstruit instantanément sur sauvegarde d'un fichier de code, **sans appel LLM** ; le hook post-commit reconstruit à chaque commit sans processus résident.

**L'interrogation** se fait ensuite contre `graph.json`, sans relire les fichiers sources : `query` pour une question ouverte, `path` pour une relation entre deux entités, `explain` pour un voisinage.

## Lecture commentée du SKILL.md

Le fichier commenté est le README de la branche `v8` (57 Ko), qui fait office de spécification publique de la skill, et le `skills/graphify/skill.md` qu'installe la commande `graphify install`.

**L'énoncé de mission, en une phrase, place le verbe au bon endroit** :

> *« Type `/graphify` in your AI coding assistant and it maps your entire project (code, docs, PDFs, images, videos) into a **knowledge graph** you can **query instead of grepping** through files. »*

*Glose* : la promesse n'est pas « comprendre votre code » mais **remplacer une opération précise** — le grep. Une skill qui se définit par le geste qu'elle supprime est plus facile à évaluer qu'une skill qui promet de la compréhension.

**Les trois puces qui suivent sont la spécification réelle** :

> *« **Code maps for free, fully local.** Code is parsed with tree-sitter AST: deterministic, no LLM, nothing leaves your machine. (Docs, PDFs, images and video use your assistant's model, or a configured API key, for a semantic pass.) »*

*Glose* : la parenthèse fait le travail honnête. Elle dit exactement où finit le local. Beaucoup d'outils annoncent « fully local » et laissent le lecteur découvrir l'exception.

> *« **Every edge is explained.** Each connection is tagged `EXTRACTED` (explicit in the source) or `INFERRED` (resolved by graphify), so you can tell what was read directly from what was inferred. »*

*Glose* : la définition des deux étiquettes est donnée **dans la même phrase** que leur nom. Un agent qui lit cette ligne sait comment pondérer une arête sans consulter d'autre documentation.

> *« **Not a vector index.** No embeddings, no vector store: a real graph you traverse. »*

*Glose* : positionnement par la négation, assumé. Le projet se situe dans un paysage où le RAG vectoriel est le défaut, et refuse d'y entrer.

**La sortie montrée avant d'être décrite** — choix de rédaction remarquable :

```text
$ graphify path "FastAPI" "ModelField"
Shortest path (3 hops):
  FastAPI --uses--> DefaultPlaceholder <--references-- get_request_handler() --references--> ModelField
```

*Glose* : trois sauts, le sens de chaque arête, son type. Le lecteur comprend en une ligne ce que « traverser un graphe » veut dire, sur un dépôt qu'il connaît. C'est plus efficace que n'importe quel paragraphe d'explication.

**La section qui trahit l'intention profonde** s'intitule *« Make your assistant always use the graph »*.

*Glose* : l'objectif n'est pas qu'un humain lance une commande, c'est que **l'agent consulte le graphe avant de lire les fichiers**. La skill vise à s'insérer dans la boucle par défaut de l'assistant, pas à rester un outil invoqué à la demande. C'est le même mouvement que la rule de routage vers les skills chez Hugo Lassiège : rendre le bon réflexe automatique.

**Choix de design à retenir** : l'**extraction hybride par type de fichier** (déterministe où la structure existe, sémantique ailleurs) est la décision qui produit toutes les autres propriétés ; le **cache SHA256** et le **hook post-commit** traitent la fraîcheur comme un problème d'ingénierie et non de discipline ; et la **sortie en wiki markdown** reconnaît qu'un agent lit mieux des fichiers qu'il ne parse du JSON.

## GrapheDeConnaissance

- Safi Shamsi —a_créé→ graphify (METHODOLOGIE, 0.97)
- Graphify Labs —publie→ graphify (METHODOLOGIE, 0.95)
- graphify —permet→ d'interroger un projet par traversée de graphe au lieu de grepper des fichiers (CITATION, 0.96)
- graphify —utilise→ tree-sitter (TECHNOLOGIE, 0.97)
- graphify —utilise→ NetworkX (TECHNOLOGIE, 0.93)
- graphify —utilise→ algorithme de Leiden (CONCEPT, 0.93)
- analyse AST locale —permet→ une extraction de code déterministe, sans appel de modèle et sans sortie de données (AFFIRMATION, 0.96)
- graphify —s_oppose_à→ l'index vectoriel, refusant embeddings et magasin de vecteurs (CITATION, 0.96)
- étiquetage EXTRACTED et INFERRED —permet→ de distinguer une relation lue dans la source d'une relation déduite (AFFIRMATION, 0.96)
- graphify —mesure→ un recall@10 de 0,497 sur LOCOMO contre 0,149 pour supermemory et 0,048 pour mem0 (MESURE, 0.93)
- graphify —mesure→ une exactitude QA de 45,3 % sur LOCOMO, inférieure aux 49,7 % de supermemory (MESURE, 0.93)
- graphify —mesure→ 76 % d'exactitude sur LongMemEval-S, à égalité avec un RAG dense (MESURE, 0.92)
- construction du graphe par AST —réduit→ le coût de construction à zéro crédit de modèle (MESURE, 0.95)
- graphe de code structuré —surpasse→ la récupération vectorielle pour la compréhension de code (AFFIRMATION, 0.85)
- graphify —s_applique_à→ code, documents, PDF, images, vidéo, configurations MCP et manifestes de paquets (AFFIRMATION, 0.94)
- commentaires d'intention —fait_partie_de→ le graphe, comme nœuds distincts reliés au code qu'ils expliquent (AFFIRMATION, 0.92)
- cache par empreinte et hook post-commit —résout→ la péremption du graphe face à un code qui change (AFFIRMATION, 0.92)
- sortie en wiki markdown —permet→ à un agent de naviguer la base de connaissance en lisant des fichiers plutôt qu'en analysant du JSON (CITATION, 0.92)
- graphify —utilise→ faster-whisper pour transcrire vidéo et audio localement (TECHNOLOGIE, 0.9)
- journal de requêtes local —s_oppose_à→ l'absence totale de trace, étant actif par défaut et désactivable par variable d'environnement (AFFIRMATION, 0.9)
- détection automatique de backend —s_oppose_à→ une contrainte de résidence des données, pouvant router vers des serveurs situés en Chine (AFFIRMATION, 0.88)
- graphify —converge_avec→ GitNexus (TECHNOLOGIE, 0.85)
- Graphify Labs —publie→ une plateforme commerciale appliquant la même approche en continu à tout le contexte de travail (AFFIRMATION, 0.9)
- branche main du dépôt —s_oppose_à→ la branche v8, en décrivant un produit de génération antérieure (AFFIRMATION, 0.92)

---
Canonical: https://www.thekb.eu/de/fiches/skill-shamsi-graphify-2026-08-06/