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

## Veille

**Skill** entry (not an article): **graphify** by **Safi Shamsi** (Graphify Labs, **Y Combinator S26**) turns an entire project — code, docs, PDFs, images, videos — into a **queryable knowledge graph**, invoked via `/graphify` from Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, and about fifteen other clients. Observed on **August 6, 2026**: **103,187 stars**, **10,024 forks**, repository created on **April 3, 2026** — an extraordinary trajectory in four months. **Apache-2.0**, Python 3.10+, default branch **v8**. **The three design commitments fit in three lines of the README**: *« Code maps for free, fully local »* (code is parsed into **tree-sitter AST**, deterministic, no LLM, **nothing leaves the machine**); *« Every edge is explained »* (each edge is tagged **`EXTRACTED`** — explicit in the source — or **`INFERRED`** — resolved by graphify —, with a third value `AMBIGUOUS` appearing in the report); and *« Not a vector index »* — *« no embeddings, no vector store: a real graph you traverse »*. **Three outputs**: `graph.html` (interactive graph), `GRAPH_REPORT.md` (god nodes, surprising connections, suggested questions), and `graph.json` (persistent graph, queryable weeks later without re-reading the files). **Three query modes** replace grep: `query` (subgraph for a natural-language question), `path A B` (shortest path between two entities), and `explain` (neighborhood of a concept). **Coverage**: 36 tree-sitter grammars (~40 languages), plus Terraform, Apex, **MCP configurations**, package manifests, Office, Google Workspace, PDFs, images, and video/audio transcribed **locally** by faster-whisper. Communities detected via **Leiden**, labeled **without an LLM**. ⭐ **The most interesting benchmark result is not a win but a free one**: on LOCOMO, graphify achieves a **recall@10 of 0.497** versus 0.149 for supermemory and 0.048 for mem0, but **loses on QA accuracy** (45.3% versus 49.7%); on LongMemEval-S it scores **76%, tied with a dense RAG**; and the line that matters is *« Graph build — LLM credits: **0** »* where the field typically bills per token. ⚠️ **Points to record**: the `main` branch carries a v1-era README describing a different product (Claude Code skill only, the « 71.5× fewer tokens » claim); the PyPI package is named **`graphifyy`** with two *y*'s, until the `graphify` name is reclaimed; and a **query log** is written by default to `~/.cache/graphify-queries.log`, which can be disabled via an environment variable.

## 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, knowledge graph, knowledge graph, AST, tree-sitter, deterministic static analysis, local extraction, no LLM, NetworkX, Leiden, community detection, god node, surprising connections, EXTRACTED, INFERRED, AMBIGUOUS, edge provenance, confidence, no vectors, no embeddings, no vector store, graph traversal, query, path, explain, graph.json, graph.html, GRAPH_REPORT, SHA256 cache, incremental update, watch, post-commit hook, agent-crawlable wiki, MCP stdio, Neo4j, GraphML, Obsidian, multimodal, PDF, vision, faster-whisper, local transcription, Terraform, Apex, MCP configurations, package manifests, Google Workspace, LOCOMO, LongMemEval, recall, mem0, supermemory, dense RAG, zero LLM credits, data residency, Ollama, Bedrock, query log, telemetry, 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

**Profile**: dense open source project documentation, written to be read by a developer in a hurry **and** by an agent. Technical register, very few promises, many tables — file types, grammars, environment variables, a full command reference.

**Style**: **demonstration precedes argument**. The README shows a real output before explaining anything — a `graphify explain "APIRouter"` command with its neighborhood annotated line by line, then a `graphify path "FastAPI" "ModelField"` displaying the three-hop path. The product is shown working on a repository the reader already knows (FastAPI) before a single commercial argument is made.

**Three notable traits**:

1. **The position is defined by a deliberate negation.** *« Not a vector index. No embeddings, no vector store: a real graph you traverse. »* The project positions itself **against** vector RAG, now the standard, and this opposition structures everything else — determinism, zero cost, edge traceability.
2. **Honesty about its own benchmarks.** The table publishes a **loss**: 45.3% QA accuracy on LOCOMO versus 49.7% for supermemory. Few projects publish the column where they lose.
3. **The privacy boundary is drawn by file type, not by principle.** Code stays local, so does video (transcribed via faster-whisper), documents and images go to the model. The *Privacy* section enumerates cases rather than promising locality.

**Operational register imposed on the agent** (the "tone" in the sense used for skill entries): the tool dictates nothing to the agent, it **provides a substrate**. The README devotes an entire section to *« Make your assistant always use the graph »* — the goal is for the agent to consult the graph **before** reading files.

**Marker phrases**: *« 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

- **Nature**: `/graphify` skill + Python CLI, Apache-2.0, distributed on PyPI under the name **`graphifyy`** (two *y*'s, until `graphify` is reclaimed). Install via `uv tool install graphifyy && graphify install`. Works in Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, and about fifteen other clients.
- **⭐⭐ The three design commitments, and they hold together**: 1. **Code is parsed locally, with no LLM.** tree-sitter AST, deterministic, *« nothing leaves your machine »*. A purely-code corpus requires **no API key** and runs offline. Documents, PDFs, and images, however, go through a model. 2. **Every edge carries its provenance.** `EXTRACTED` = explicit in the source; `INFERRED` = resolved by graphify; `AMBIGUOUS` in the report. *« You always know what was found vs guessed. »* 3. **No vector index.** No embeddings, no vector store: a graph you traverse. → **The three reinforce each other**: determinism makes the cost zero, zero cost makes frequent rebuilding possible, and edge labeling makes the result auditable. Same family of reasoning as the executable that beats the brief in [[lassiege-usine-logicielle-heure-ia-2026-07-28]].
- **⭐ The graph replaces grep, and that's the usage argument**: `query "<question>"` returns a subgraph for a natural-language question, `path A B` traces the path between two entities, `explain X` unpacks the neighborhood of a concept. The README's example makes the point: `path "FastAPI" "ModelField"` returns a three-hop path with the type of each edge. **One asks for a relationship, not a string match.** This is exactly the benefit Hugo Lassiège attributes to GitNexus in [[lassiege-usine-logicielle-heure-ia-2026-07-28]] — *« searching for an execution flow rather than grepping a function name »*, and *« the real point isn't speed, it's detecting all the side effects »*.
- **⭐⭐ The benchmark table, read correctly — the line that matters isn't a win**: | Benchmark | Metric | graphify | Field | |---|---|---|---| | LOCOMO (n=300) | recall@10 | **0.497** | supermemory 0.149 · mem0 0.048 | | LOCOMO (n=300) | QA accuracy | 45.3% | **supermemory 49.7%** · mem0 27.3% | | LongMemEval-S (n=50) | QA accuracy | 76% | **tied** with a dense RAG | | Graph construction | LLM credits | **0** | billed per token elsewhere | → **graphify largely dominates recall, loses on QA accuracy, ties dense RAG on the second benchmark, and builds its graph for free.** The defensible differentiator is therefore **cost and traceability, not answer quality**. Presenting graphify as « better than RAG » would be an overinterpretation its own numbers contradict. Credited protocol: same harness, same model, same budgets, judge validated blind against a second judge (**90.6% agreement, Cohen's kappa 0.81**).
- **⭐ Worth comparing with the corpus's only comparable figure**: Compare the Market measured an AST graph at **~70%** versus **~58%** for a vector RAG on 79 merge requests, with RAG performing **worse than no context at all** (cf. [[comparethemarket-context-retrieval-ai-code-review-gkg-rag-2026-03-06]], revisited in [[sfeir-code-review-anneau-contraintes-2026-07-30]]). **Two independent measurements converge on the superiority of the structured graph for code** — and graphify adds that construction costs nothing.
- **Source coverage — broader than "just code"**: 36 tree-sitter grammars covering ~40 languages (down to CUDA, Metal, Zig, Elixir, Julia, Dart, SystemVerilog, Delphi, Fortran), plus **SQL**, **Terraform/HCL**, **Apex Salesforce**, **MCP configurations** (`.mcp.json`, `claude_desktop_config.json` — extracts servers, packages, and required environment variables), **package manifests** (`pyproject.toml`, `go.mod`, `pom.xml` — one canonical node per package, hence a single hub), Office, Google Workspace, PDFs, images, video, and audio. ⭐ **Graphifying one's own MCP configurations** is an unexpected and immediately useful way to map one's tooling surface.
- **The "why" extracted as a first-class object**: `# NOTE:`, `# WHY:`, `# HACK:` comments, docstrings, and design reasoning found in documentation become **separate nodes linked to the code they explain**. → **Intent is treated as a graph entity**, which directly addresses the comprehension debt: one can ask *why*, not just *what*.
- **Graph freshness, three mechanisms**: SHA256 cache (only changed files are reprocessed), `--watch` (instant rebuild on saving a code file, **AST only, no LLM**; documents and images flag that an `--update` is needed), and `graphify hook install` (**post-commit hook**, no background process). The `--watch` mode is explicitly justified for multi-agent workflows: *« the graph stays current between waves automatically »*.
- **Outputs for agents**: `--wiki` produces encyclopedia-style articles per community with an `index.md`, *« point any agent at index.md and it can navigate the knowledge base by reading files instead of parsing JSON »*. And `--mcp` starts an MCP stdio server. Exports to Obsidian, GraphML (Gephi, yEd), Neo4j (cypher), SVG. → **The graph is built to be read by a machine, with several entry points depending on the tool.** Same intent as the markdown served to agents in [[martinho-allen-cloudflare-markdown-for-agents-2026-02-12]].
- **⚠️ Privacy — the boundary is subtle, worth knowing**:
- **Local**: code (tree-sitter), video and audio (faster-whisper). A code-only corpus runs **offline**, and `--code-only` forces this mode on a mixed repository.
- **Sent to the model**: documents, PDFs, images. In headless mode, an API key is required, with an **automatic priority chain** (Gemini → Kimi → Claude → OpenAI → DeepSeek → Azure → Bedrock → Ollama). ⚠️ **Kimi routes to Moonshot AI servers in China** — the README flags this, and `--backend ollama` gives a fully local mode.
- **No telemetry**, no usage tracking.
- ⚠️ **But a query log is written by default** to `~/.cache/graphify-queries.log` (timestamp, question, corpus, nodes returned, duration). Subgraphs are not stored. Disable via `GRAPHIFY_QUERY_LOG_DISABLE=1`. **Local, but active without opt-in**: worth knowing before deployment in a sensitive context.
- **⚠️ Two documentation traps in the repository itself**: 1. **The `main` branch is stale.** It carries a **v1**-era README (7 KB) describing *« a Claude Code skill »* for a single client, highlighting the **« 71.5× fewer tokens »** claim on a 52-file Karpathy corpus, and still pointing to `safishamsi/graphify`. The default branch is **v8** (57 KB), which describes a multi-client product and highlights the LOCOMO/LongMemEval benchmarks. **Read v8, never `main`.** 2. **The package name**: `pip install graphifyy` (two *y*'s). The CLI and skill command remain `graphify`.
- **Business model, to watch**: the open source skill is the entry point to a **commercial platform** at `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 »*, currently waitlisted, with a free trial announced. **Local open source on one side, continuously hosted service on the other**: a classic pattern, to factor into any adoption decision.
- **⚠️ Traction requires a cautious reading**: **103,187 stars in four months** is an exceptional pace, even for a viral tool. The figure is what the GitHub API returns on August 6, 2026; it says nothing about actual usage, and the project's official site still displays **3,700** (cf. [[graphify-net-annuaire-ia-coding-2026-08-06]]), a sign that communication hasn't kept pace. **Cite the star count as a signal of attention, never as a measure of adoption.**
- **Meta / cross-references**: same family as [[skill-gibbs-hyperresearch-2026-08-03]] (persistent store, provenance, agent-readable output), but for code rather than documentary research; realizes in product form what Hugo Lassiège gets from GitNexus in [[lassiege-usine-logicielle-heure-ia-2026-07-28]]; numeric convergence with [[comparethemarket-context-retrieval-ai-code-review-gkg-rag-2026-03-06]] and [[sfeir-code-review-anneau-contraintes-2026-07-30]] on AST graph versus vector RAG; fits within the codified context of [[vasilopoulos-codified-context-infrastructure-ai-agents-2026-02-24]] and the context platforms of [[memodb-acontext-context-data-platform-agents-2025-12-11]]; formal kinship with other skill entries, [[skill-pocock-grill-with-docs-2026-06]]; skill mechanics in [[agent-skills-anthropic-2025-10-16]], [[shihipar-claude-code-lessons-building-skills-2026-06-03]], and [[vincent-superpowers-agentic-skills-framework-github-2026-04-02]]. ⚠️ **Disambiguation**: the site `graphify.net` is a property distinct from `graphify.com` (the commercial platform) — see the dedicated entry.

## RésuméDe400mots

**graphify** (Safi Shamsi, Graphify Labs, Y Combinator S26) turns an entire project into a **queryable knowledge graph**, invoked via `/graphify` from Claude Code, Cursor, Codex, Gemini CLI, and about fifteen other clients. Observed on August 6, 2026: **103,187 stars** for a repository created on April 3, Apache-2.0, Python.

**Three commitments underpin the project.** **Code is parsed locally** into tree-sitter AST, with no LLM: deterministic, nothing leaves the machine, no API key required for a purely-code corpus. **Every edge carries its provenance** — `EXTRACTED` if explicit in the source, `INFERRED` if graphify resolved it —, *« so you can tell what was read directly from what was inferred »*. And the project defines itself **against vector RAG**: *« Not a vector index. No embeddings, no vector store: a real graph you traverse. »*

**Usage replaces grep.** `query` returns a subgraph for a natural-language question, `path A B` traces the path between two entities, `explain` unpacks a concept. Three outputs: an interactive graph, a readable report (god nodes, surprising connections, suggested questions), and a persistent `graph.json`, queryable weeks later.

**Coverage extends beyond code**: 36 tree-sitter grammars, but also SQL, Terraform, Apex, **MCP configurations**, package manifests, Office, PDFs, images, and locally transcribed video. `# WHY:` comments and design reasoning become **full-fledged nodes linked to the code they explain**.

**The benchmarks deserve a careful reading.** On LOCOMO, graphify dominates recall (0.497 versus 0.149 and 0.048) but **loses on QA accuracy** (45.3% versus 49.7%); on LongMemEval-S it **ties a dense RAG** at 76%. The line that matters lies elsewhere: *« Graph build — LLM credits: 0 »*. The defensible differentiator is **cost and traceability, not answer quality**.

⚠️ **Three caveats.** The `main` branch carries a stale v1-era README describing a different product: read `v8`. The PyPI package is named `graphifyy`, until the name is reclaimed. And a **local query log** is active by default, disabled via an environment variable.

The skill also serves as an entry point to a waitlisted commercial platform at graphify.com, which applies the same approach continuously to the entire working context.

## 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/en/fiches/skill-shamsi-graphify-2026-08-06/