J’ai construit une mémoire graphique pour tous mes projets

Après plusieurs années de projets accumulés, chaque nouvelle session d’IA recommence souvent par la même tâche : parcourir les dossiers, ouvrir les fichiers importants, retrouver les choix d’architecture et reconstruire une compréhension du projet. Graphify propose une autre approche : transformer les fichiers en graphe de connaissances que l’on peut interroger.

Le problème : une collection de projets n’est pas encore une mémoire

Un dossier contient des fichiers. Un projet contient des relations. Une fonction appelle une autre fonction, une table alimente un service, un écran dépend d’un hook, une image documente une interface et un README explique pourquoi une décision a été prise.

Une recherche classique retrouve des mots. Elle ne comprend pas toujours le chemin entre deux éléments. C’est précisément ce que je voulais conserver : non seulement les fichiers, mais les connexions qui donnent du sens à l’ensemble.

Graphify, en quelques mots

Graphify est un outil open source qui transforme un dossier de code, de documentation, de PDF ou d’images en graphe interrogeable. Les fonctions, classes, fichiers et concepts deviennent des nœuds. Les appels, imports, références et relations sémantiques deviennent des arêtes.

La distinction importante est la suivante :

• Le code est analysé localement avec Tree-sitter : les fonctions, classes, imports et appels sont extraits de manière structurelle.
• Les documents et les images passent par une analyse sémantique avec le modèle configuré.
• Le graphe est stocké sur le disque, dans un fichier JSON que l’on peut requêter sans relire toute la base de fichiers.
• Chaque relation garde une indication de confiance : EXTRACTED, INFERRED ou AMBIGUOUS.

Graphify ne remplace donc pas un moteur de recherche plein texte ni une base vectorielle pour tous les usages. Son intérêt est ailleurs : préserver la structure et permettre à l’IA de suivre des chemins entre les éléments d’un système.

La page officielle de Graphify présente le projet comme un knowledge graph multimodal pour les assistants de programmation.

L’installation de base

La première étape consiste à installer le paquet Python et à enregistrer la compétence auprès de l’assistant de développement :

uv tool install graphifyy
graphify install

Le nom du paquet est graphifyy, mais la commande installée s’appelle bien graphify. Dans mon environnement, la CLI est disponible en version 0.8.49 et la compétence Claude Code est installée dans ~/.claude/skills/graphify/.

Pour un projet isolé, la commande ressemble ensuite à ceci :

cd /chemin/vers/mon-projet
graphify extract .

Cette opération produit notamment un graph.json, un rapport lisible et, selon les options utilisées, une visualisation interactive. Une fois le graphe créé, on peut poser des questions directement :

graphify query "Quels sont les éléments principaux du système d’authentification ?"
graphify explain "NomDuService"
graphify path "NomDuService" "NomDeLaBase"

Pourquoi j’ai ajouté Ollama

Le code peut être analysé structurellement sans appeler un modèle. Les images, elles, doivent être regardées. Un nom de fichier comme screen_03.png ne dit pas grand-chose ; une capture d’écran contient une interface, un parcours, des états et parfois des informations utiles pour comprendre le projet.

J’ai donc utilisé Ollama comme backend local pour la partie sémantique et vision. L’idée est simple : faire tourner un modèle multimodal sur ma machine, lui transmettre les images pendant l’extraction, puis enregistrer dans le graphe les descriptions et les liens que Graphify en déduit.

La configuration reproductible ressemble à ceci :

uv tool install "graphifyy[ollama]"
ollama serve
ollama pull llama3.2-vision

export OLLAMA_BASE_URL=http://localhost:11434
export OLLAMA_MODEL=llama3.2-vision
export GRAPHIFY_OLLAMA_VISION=1

Le nom du modèle vision peut naturellement changer. Le point essentiel est de choisir un modèle qui accepte les images et d’activer explicitement le mode vision de Graphify. Le modèle textuel par défaut d’Ollama ne suffit pas pour cette étape.

Graphify traite les images raster comme des entrées séparées. Il peut transmettre leurs pixels au backend vision, dans les limites de taille du modèle et de l’API. Une image trop volumineuse peut toutefois rester un nœud de référence sans être réellement interprétée. C’est une limite importante à garder en tête.

Construire un graphe global

Un graphe par projet est déjà utile. Mais mon travail est réparti entre plusieurs applications, sites, cours et expérimentations. J’ai donc enregistré les graphes dans un graphe global :

graphify global add /chemin/vers/meetlux/graphify-out/graph.json --as meetlux
graphify global add /chemin/vers/sillages/graphify-out/graph.json --as sillages
graphify global add /chemin/vers/trajeo/graphify-out/graph.json --as trajeo

graphify global list
graphify global path

Le fichier partagé est situé ici :

~/.graphify/global-graph.json

Le manifeste séparé conserve la liste des projets enregistrés, leur chemin d’origine, la date d’ajout et les compteurs de nœuds et de relations. Cela permet de reconstruire ou de mettre à jour un projet sans perdre la vue d’ensemble.

Ce que contient mon graphe

Au moment où j’écris cet article, mon graphe global contient :

Les projets enregistrés sont meetlux, ucc-app, ucc-site, myrugby, sillages, weggup, oneeuropuzzle, techniques-graphiques, cours-2026-2027, trajeo, leago et dashboard.

Le chiffre qui m’intéresse le plus n’est pas le nombre de nœuds en lui-même. C’est la possibilité de poser une question au-dessus de plusieurs projets et de retrouver les connexions pertinentes sans repartir de zéro.

Comment Claude Code utilise cette mémoire

L’installation de la skill Graphify ajoute une règle simple à mon environnement de travail : lorsqu’une question porte sur l’architecture ou les relations entre fichiers, l’assistant doit consulter le graphe avant de parcourir aveuglément tout le dépôt.

Je peux aussi interroger directement le graphe global :

graphify query "Quels projets utilisent Firebase et pour quels usages ?" \
  --graph ~/.graphify/global-graph.json

graphify query "Quels sont les liens entre mes applications mobiles et leurs services backend ?" \
  --graph ~/.graphify/global-graph.json

Dans la pratique, ce n’est pas magique : le graphe ne remplace pas la lecture du code lorsqu’il faut modifier une ligne précise. Il sert de couche de contexte. Il aide à savoir où chercher, quels composants sont liés et quelles hypothèses méritent d’être vérifiées.

Ce que les images ajoutent vraiment

Les images ne sont pas seulement des fichiers annexes. Dans mes projets, elles peuvent représenter une maquette, une capture d’application, un logo, un écran de cours ou un diagramme. Les intégrer au même graphe que le code permet de rapprocher une interface visible de la structure qui la produit.

L’intérêt est particulièrement évident pour les projets conçus avec Figma, Claude Design ou des workflows de prototypage rapide. Une capture d’écran peut devenir un point de référence relié aux fichiers qui implémentent l’écran correspondant.

Il faut cependant rester prudent : une description générée par un modèle vision est une interprétation, pas une preuve. C’est pour cela que Graphify distingue les relations extraites des relations inférées. Le graphe devient une carte de navigation, pas une autorité qui dispense de vérifier.

Confidentialité et limites

• L’analyse structurelle du code est locale.
• Avec Ollama, l’analyse des documents et images peut rester sur la machine.
• Le graphe global est un fichier local, pas un index hébergé.
• Les performances dépendent fortement du modèle vision, de la mémoire disponible et de la taille des images.
• Le graphe doit être mis à jour quand les projets évoluent.

La confidentialité dépend donc du backend choisi. Ollama réduit le nombre de données qui doivent sortir de la machine, mais il faut toujours savoir quel assistant ou quel modèle est utilisé pour chaque étape. Une configuration locale n’est pas une garantie automatique : c’est une décision d’architecture qu’il faut vérifier.

Le bilan

Graphify m’a permis de passer d’une collection de projets à une mémoire structurée. Ollama ajoute une brique intéressante : les images peuvent être décrites et reliées au reste du système sans dépendre nécessairement d’un service cloud.

Le résultat n’est pas un bouton magique qui rend l’IA omnisciente. C’est plus utile que cela : une couche de contexte persistante, consultable, inspectable et mise à jour au fil du travail.

Pour moi, c’est une nouvelle pièce dans la manière de travailler avec l’IA : le contexte n’est plus seulement un long fichier de consignes ou une conversation passée. Il devient une structure navigable, partagée entre les projets et suffisamment concrète pour être confrontée au code réel.