Comment Graphify transforme le code en graphe de connaissances pour les agents IA en 2026

Les assistants IA de code (Claude Code, Codex, OpenClaw) parcourent les fichiers un par un avec des commandes grep et glob. Sur un projet de 50 000 lignes, cette approche consomme des dizaines de milliers de tokens et manque les relations architecturales entre modules. Graphify, publié le 6 avril 2026, construit un graphe de connaissances persistant à partir du code source, des documents, des PDF et même des captures d’écran, puis le met à disposition de l’agent via un simple fichier GRAPH_REPORT.md. Le projet dépasse 13 500 étoiles GitHub en trois jours.

Temps de lecture : 14 min

Pourquoi les agents IA de code se perdent-ils dans les grandes bases de code ?

Un agent IA de code sans cartographie structurelle parcourt les fichiers de manière séquentielle, en lançant des commandes grep sur l’ensemble du projet. Cette méthode brute force consomme des milliers de tokens par requête et passe à côté des relations invisibles entre composants.

Le problème du grep aveugle

Claude Code, Codex et OpenClaw utilisent des outils Glob et Grep pour localiser du code. Sur un monorepo de 200 fichiers, une recherche d’architecture déclenche des dizaines de lectures de fichiers. Chaque fichier lu consomme des tokens de contexte. Le développeur paie en latence et en coût API pour des lectures souvent non pertinentes.

Le fichier CLAUDE.md ou AGENTS.md contient des instructions statiques. Il ne reflète pas l’architecture réelle du code, les dépendances entre modules ou les décisions de conception enfouies dans les commentaires et les pull requests. L’agent travaille sans carte.

Les entreprises qui adoptent Claude Code pour la maintenance de leurs applications rencontrent ce problème quotidiennement. L’agent oublie l’architecture entre deux sessions. Le développeur doit rappeler les conventions, les dépendances critiques et les décisions passées à chaque démarrage. Ce temps perdu en contexte représente entre 15 et 30 minutes par session sur un projet de taille moyenne.

Le coût financier est direct : chaque token de contexte consommé pour relire des fichiers non pertinents est un token qui ne sert pas à résoudre le problème posé. Sur un abonnement Claude Pro à 20 euros par mois, cette inefficacité réduit la capacité effective de l’outil.

L’inspiration Andrej Karpathy

Andrej Karpathy, ancien directeur IA chez Tesla, conserve un dossier /raw dans lequel il dépose articles, tweets, captures d’écran et notes. Graphify résout exactement ce problème : transformer un ensemble hétérogène de fichiers en un graphe structuré et interrogeable, persistant entre les sessions. Le créateur Safi Shamsi a conçu le projet comme un skill pour assistants IA, pas comme un outil standalone.

La tendance aux skills agentiques progresse en 2026. Le dépôt officiel d’Anthropic dépasse 112 000 étoiles, et des frameworks comme l’écosystème de skills Claude deviennent des composants essentiels des flux de travail IA.

Comment Graphify construit-il un graphe de connaissances à partir du code ?

Graphify est un outil Python qui analyse le code source via tree-sitter pour extraire les structures (classes, fonctions, imports, graphes d’appels), puis utilise Claude Vision en parallèle pour les documents non-code, et fusionne le tout dans un graphe NetworkX clusterisé par l’algorithme de Leiden.

La double passe : AST déterministe puis LLM

La première passe est entièrement déterministe. Tree-sitter analyse la syntaxe de 20 langages (Python, JavaScript, TypeScript, Go, Rust, Java, C, C++, Ruby, C#, Kotlin, Scala, PHP, Swift, Lua, Zig, PowerShell, Elixir, Objective-C, Julia) et extrait les structures sans appel à un LLM. Les classes, fonctions, imports, graphes d’appels, docstrings et commentaires de raisonnement sont capturés.

La seconde passe utilise des sous-agents Claude en parallèle pour les fichiers non-code : documents Markdown, PDF, images, captures d’écran de tableaux blancs, diagrammes. Claude Vision extrait les concepts, relations et raisonnements de conception. Les résultats des deux passes fusionnent dans un graphe unique.

Le clustering par topologie de Leiden

Le graphe est clusterisé via l’algorithme de communautés de Leiden, qui regroupe les nœuds par densité de liens, sans embeddings ni base vectorielle. Les liens sémantiques extraits par Claude (marqués INFERRED) sont directement intégrés dans le graphe et influencent la détection des communautés.

L’export produit quatre fichiers : graph.json (le graphe interrogeable), GRAPH_REPORT.md (résumé lisible par l’agent), graph.html (visualisation interactive) et un répertoire cache/ avec les hachages SHA256 pour l’incrémentalité. Le rapport identifie les « god nodes » (nœuds centraux) et les connexions surprenantes entre modules.

La visualisation HTML interactive permet aux développeurs non familiers avec le graphe de l’explorer visuellement. Les nœuds sont colorés par communauté, les arêtes montrent les relations (imports, appels, dépendances sémantiques). Un clic sur un nœud affiche ses connexions directes et les fichiers sources associés.

Comment Graphify extrait-il des connaissances depuis les PDF et les images ?

Graphify est multimodal par conception. Les dossiers de projet contiennent souvent des PDF de spécifications, des captures d’écran de maquettes, des photos de tableaux blancs et des diagrammes d’architecture. Graphify intègre tous ces formats dans le même graphe que le code source.

Le pipeline multimodal

Claude Vision analyse chaque image et extrait les concepts visuels, les relations entre composants et les annotations textuelles. Un diagramme d’architecture photographié sur un tableau blanc devient un ensemble de nœuds et d’arêtes dans le graphe, relié aux fichiers de code qui implémentent ces composants.

Les PDF de spécifications sont traités de la même manière. Les concepts métier, les exigences fonctionnelles et les décisions de conception sont extraits et connectés au code correspondant. Le résultat : un graphe qui lie le « pourquoi » (dans les documents) au « comment » (dans le code).

Le support des 20 langages via tree-sitter

Tree-sitter fournit un parseur AST (Abstract Syntax Tree) unifié pour 20 langages de programmation. Cette couverture permet d’utiliser Graphify sur des monorepos polyglottes sans installer d’indexeurs séparés pour chaque langage. Le backend Python, le frontend TypeScript et les scripts Shell d’un même projet sont analysés dans un graphe unique.

Un fichier .graphifyignore (syntaxe gitignore) exclut les dossiers non pertinents : vendor/, node_modules/, dist/, fichiers générés. Cette exclusion évite de polluer le graphe avec des artefacts de build et des dépendances tierces.

Évaluez votre maturité IA en 5 minutes avec notre Diagnostic IA gratuit.

Comment installer Graphify sur Claude Code, Codex ou OpenClaw ?

Graphify s’installe via pip (le package PyPI s’appelle temporairement graphifyy) et se configure pour chaque plateforme en une commande. Le système s’intègre comme un skill dans le flux de travail de l’agent, pas comme un outil séparé.

Installation par plateforme

Pour Claude Code, la commande graphify install écrit une section dans CLAUDE.md et installe un hook PreToolUse. Ce hook intercepte chaque appel Glob et Grep : si un graphe existe, Claude voit un rappel « graphify: Knowledge graph exists. Read GRAPH_REPORT.md » avant de chercher dans les fichiers bruts. L’agent navigue via le graphe au lieu de parcourir chaque fichier.

Pour Codex, OpenClaw et Factory Droid, l’installation écrit les instructions dans AGENTS.md (ces plateformes ne supportent pas les hooks PreToolUse). Le trigger est /graphify dans Claude Code et $graphify dans Codex. Trae et Gemini CLI sont supportés depuis la version 3.

Mode always-on vs mode explicite

Le hook always-on montre GRAPH_REPORT.md, un résumé d’une page des god nodes, des communautés et des connexions surprenantes. L’agent consulte ce résumé avant chaque recherche. Le mode explicite (/graphify) lance une analyse complète du graphe pour répondre à une question d’architecture spécifique.

La différence de consommation de tokens est significative. Le mode always-on charge le rapport (quelques centaines de tokens), tandis que la recherche brute dans les fichiers peut consommer des dizaines de milliers de tokens. Cette économie rend les sessions Claude Code considérablement plus efficaces sur les grands projets.

Quelles économies de tokens Graphify génère-t-il en pratique ?

Graphify revendique une réduction de 71,5x du nombre de tokens par requête par rapport à la lecture brute des fichiers sources. Ce chiffre provient de la comparaison entre la lecture directe d’un corpus et la consultation du graphe pour répondre à la même question d’architecture.

Mesure de l’économie sur un projet réel

Sur un projet de 22 000 lignes de code avec 150 fichiers, une question d’architecture (« comment les modules auth et billing communiquent-ils ? ») nécessite la lecture de 30 à 50 fichiers en mode grep. Avec Graphify, la même question se résout en consultant GRAPH_REPORT.md puis en suivant 2 à 3 chemins dans le graphe.

L’incrémentalité via le cache SHA256 accélère les analyses suivantes. Seuls les fichiers modifiés depuis la dernière analyse sont retraités. La commande graphify --update élague les nœuds fantômes des fichiers supprimés avant de fusionner les nouvelles extractions.

Limites et cas non couverts

Graphify mélange intentionnellement extraction déterministe (AST) et inférence LLM (pour les documents et images). Les environnements qui nécessitent une analyse statique exacte uniquement ne trouveront pas leur compte. Le système ne remplace pas un outil de trace d’exécution (comme OpenTrace) pour les questions sur le comportement runtime du code.

Le projet Penpax, en cours de développement par l’équipe Graphify, vise à étendre le concept au-delà du code : connecter réunions, historique de navigation, emails et fichiers dans un graphe de connaissances personnel, entièrement sur l’appareil de l’utilisateur.

Le choix d’une approche basée sur les graphes plutôt que sur les embeddings vectoriels reflète une tendance observée dans plusieurs projets open source en 2026. Les graphes préservent les relations explicites entre composants, tandis que les embeddings capturent des similarités sémantiques plus floues. Pour les questions d’architecture logicielle (« quels modules dépendent de auth ? »), les graphes fournissent des réponses exactes là où les embeddings proposent des approximations.

L’adoption rapide du projet (13 500 étoiles en trois jours, 131 issues ouvertes, 72 pull requests en une semaine) confirme un besoin réel dans la communauté des développeurs qui utilisent des agents IA au quotidien. Les contributions couvrent déjà l’ajout de plateformes (Trae, Gemini CLI, OB-1) et la correction de bugs sur Windows et PowerShell.

Quels cas d’usage Graphify ouvre-t-il pour les équipes de développement ?

Graphify transforme la manière dont les équipes interagissent avec leur base de code via les assistants IA. Le graphe persistant élimine le besoin de réexpliquer l’architecture à chaque session.

Onboarding et compréhension de code legacy

Un nouveau développeur qui rejoint un projet de 100 000 lignes peut demander à son agent : « Montre-moi les god nodes et les communautés principales. » Le rapport identifie les fichiers centraux, les clusters fonctionnels et les dépendances critiques. Cette cartographie remplace des jours de lecture de code par quelques minutes d’exploration guidée.

Pour le code legacy sans documentation, Graphify extrait les relations architecturales directement depuis la structure du code. Les commentaires de raisonnement (« rationale comments ») sont capturés et liés aux composants correspondants, reconstituant une partie de l’intention de conception originale.

Revue de code et refactoring assistés

Le projet code-review-graph (5 800 étoiles GitHub), un outil complémentaire, utilise un graphe de connaissances local spécifiquement pour les revues de code avec Claude Code. Ce projet revendique une réduction de 6,8x des tokens sur les revues et jusqu’à 49x sur les tâches de codage quotidiennes.

Pour les équipes qui déploient des agents IA autonomes, la combinaison Graphify + Claude Code permet de lancer des sous-agents spécialisés qui comprennent l’architecture globale sans recharger tout le code source. L’agent de refactoring sait quels modules seront impactés par un changement grâce au graphe de dépendances.

Les équipes qui publient du contenu automatisé via des pipelines IA bénéficient également de Graphify. L’agent qui génère un article technique sur une fonctionnalité du produit peut interroger le graphe pour vérifier les spécifications réelles du code avant de rédiger. La précision factuelle du contenu s’améliore sans intervention humaine supplémentaire.

Pour les architectes logiciels, Graphify fournit une vue actualisée des dépendances entre services dans une architecture microservices. La détection automatique des god nodes signale les points de défaillance uniques et les modules qui nécessitent un refactoring prioritaire. Lancez un audit de votre architecture IA avec notre accompagnement création de site web optimisé dès la conception.

• Graphify supporte 20 langages de programmation via tree-sitter sans configuration supplémentaire
• La double passe (AST déterministe + LLM multimodal) combine fiabilité du parsing et richesse sémantique
• L’algorithme de Leiden regroupe les modules par densité de liens, sans embeddings
• Le cache SHA256 permet des analyses incrémentales rapides sur les projets qui évoluent
• Le hook PreToolUse oriente Claude Code vers le graphe avant chaque recherche dans les fichiers
• L’export HTML interactif permet de visualiser l’architecture dans un navigateur

Questions fréquentes sur Graphify et les graphes de connaissances pour le code

Graphify fonctionne-t-il avec tous les langages de programmation ?

Graphify supporte 20 langages via tree-sitter : Python, JavaScript, TypeScript, Go, Rust, Java, C, C++, Ruby, C#, Kotlin, Scala, PHP, Swift, Lua, Zig, PowerShell, Elixir, Objective-C et Julia. Les fichiers dans des langages non supportés sont traités par la passe LLM (Claude Vision) qui extrait les concepts et relations de manière sémantique.

Quelle est la différence entre Graphify et un simple fichier CLAUDE.md ?

CLAUDE.md est un fichier texte statique qui contient des instructions pour l’agent. Graphify analyse dynamiquement le code source et les documents pour construire un graphe de relations entre composants. CLAUDE.md décrit ce que l’agent doit faire, Graphify lui montre comment le code est structuré. Les deux sont complémentaires, pas concurrents.

Combien de tokens Graphify économise-t-il par rapport à la lecture brute ?

Graphify revendique une réduction de 71,5x du nombre de tokens par requête d’architecture. Sur un projet de 22 000 lignes, une question d’architecture consomme 15 000 à 50 000 tokens en mode grep contre 200 à 700 tokens via le graphe. L’économie est proportionnelle à la taille du projet analysé.

Graphify envoie-t-il des données vers le cloud ?

L’extraction AST (passe 1) est entièrement locale et déterministe. La passe 2 utilise Claude Vision pour analyser les documents et images, ce qui implique un appel API vers Anthropic. Le graphe résultant, les fichiers JSON et le cache SHA256 restent sur la machine locale. La passe 2 peut être désactivée pour un fonctionnement 100 % hors ligne.

Graphify est-il compatible avec Gemini CLI et les autres assistants ?

Graphify supporte Claude Code, Codex, OpenCode, OpenClaw, Factory Droid, Trae et Gemini CLI. La compatibilité Gemini CLI a été ajoutée dans la version 3 via une pull request communautaire. Gemini CLI présente une limitation : pas de support des sous-agents, les skills fonctionnent en mode executing-plans plutôt qu’en mode subagent.

Comment Graphify gère-t-il les mises à jour du code source ?

Le cache SHA256 stocke un hash de chaque fichier analysé. La commande graphify –update compare les hashes actuels aux hashes en cache et ne retraite que les fichiers modifiés. Les nœuds fantômes (fichiers supprimés) sont élagués automatiquement avant la fusion. Cette incrémentalité rend les analyses suivantes rapides même sur de grands projets.

Peut-on utiliser Graphify sur un monorepo avec plusieurs langages ?

Graphify est conçu pour les monorepos polyglottes. Tree-sitter analyse chaque fichier selon son langage, et les résultats fusionnent dans un graphe unique. Un monorepo avec un backend Python, un frontend TypeScript et des scripts Shell produit un graphe cohérent qui révèle les dépendances cross-langage entre les modules.

Quel est le coût d’utilisation de Graphify ?

Graphify est open source et gratuit (MIT). Le coût se limite aux appels API Claude pour la passe 2 (analyse des documents et images). Sur un projet de taille moyenne, la construction initiale du graphe consomme quelques dollars d’API. Les analyses incrémentales suivantes sont quasi gratuites grâce au cache. La passe 1 (AST) ne consomme aucun token API.

Graphify peut-il analyser des images et des captures d’écran ?

Graphify utilise Claude Vision pour extraire des concepts et relations depuis les images. Les captures d’écran de tableaux blancs, les diagrammes d’architecture, les maquettes UI et les photos de documents physiques sont analysés et intégrés dans le graphe. Le support couvre les images dans d’autres langues grâce à la capacité multilingue de Claude Vision.

Quelle est la différence entre Graphify et code-review-graph ?

Graphify est un outil généraliste qui construit un graphe de connaissances complet à partir de n’importe quel dossier (code, docs, images). Code-review-graph (5 800 étoiles GitHub) est spécialisé dans les revues de code avec Claude Code. Les deux utilisent des graphes de connaissances, mais code-review-graph optimise spécifiquement le flux de relecture et revendique 6,8x moins de tokens sur les revues.

Diag IA gratuit
Nous contacter
Parler à Eric