LAIN : graphe de code en mémoire et outils MCP pour agents

Ce qu'est LAIN, selon son README

LAIN-mcp est un projet open source de spuentesp, publié sur GitHub sous licence MIT. Le README le décrit comme « un moteur d'intelligence de code et de coordination, persistant et performant, conçu spécialement pour les agents de codage IA ». Il parle aux agents via le Model Context Protocol (MCP). Le README cite comme clients Claude Code, Cursor, Copilot, Codex, Agy, Cline et Windsurf.

L'idée est simple. Beaucoup d'agents de codage traitent le code comme du texte plat et le cherchent par mots-clés. LAIN indexe plutôt la base de code sous forme d'un graphe de propriétés structurel, typé et résident en mémoire. Il le construit à partir de Tree-sitter, de serveurs de langage et de l'historique des commits Git. Il expose ensuite un ensemble d'outils MCP déterministes, afin qu'un agent pose des questions structurelles et obtienne des réponses exactes. Le README affirme que les agents peuvent ainsi travailler sur des bases de code complexes « sans hallucinations, sans modifications à l'aveugle et sans gaspillage de fenêtre de contexte ». C'est l'affirmation du projet lui-même. Cet article ne l'a pas testée.

Fonctionnement : les cinq étapes du README

Le README décrit cinq étapes. D'abord l'indexation et l'analyse : LAIN parcourt le code avec Tree-sitter et des serveurs de langage, puis extrait fonctions, classes, imports et références dans un graphe de propriétés. Ensuite le stockage persistant : le graphe est sérialisé dans `.lain/graph.bin`, avec des identifiants dérivés de façon déterministe en UUID v5, ce qui permet un rechargement rapide. Puis l'extraction temporelle : LAIN lit les journaux de commits git pour construire un « radar de couplage par co-changement », qui repère les modules évoluant ensemble même sans import explicite. Vient la présence consultative : des registres en mémoire et sur disque suivent les sessions d'agents et les réservations de fichiers, pour éviter les modifications qui se chevauchent. Enfin, la livraison MCP universelle : les outils sont servis par stdio ou HTTP.

Le schéma d'architecture ajoute des détails. Il y a deux transports : stdio pour un seul dépôt, et HTTP sur le port 9999 avec JSON-RPC et SSE. Derrière se trouve un noyau composé d'un répartiteur d'outils unifié, d'un moteur de graphe en mémoire fondé sur Petgraph, d'un registre de présence et de réservations décrit comme des « baux et verrous consultatifs », et d'un moteur de fédération pour N dépôts.

La surface d'outils

Le README range les outils MCP en six familles.

• **Rayon d'impact et traçage des dépendances :** `get_blast_radius`, `get_call_chain`, `trace_dependency` et `get_coupling_radar`. Ils donnent l'impact en aval d'un changement de symbole, le plus court chemin entre deux fonctions, les dépendances en amont et les fichiers qui changent ensemble.
• **Découverte de l'architecture :** `find_anchors`, `list_entry_points`, `get_context_depth` et `explore_architecture`. Ils repèrent les symboles les plus appelés et les plus stables, les points d'entrée comme `main()`, les routes HTTP et les gestionnaires d'événements, ainsi qu'une arborescence hiérarchique des modules.
• **Coordination multi-agents, appelée « Multiplayer Mode » :** `register_agent`, `heartbeat`, `claim_files`, `release_files`, `detect_overlap`, `list_active_agents` et `who_am_i`.
• **Recherche et requêtes approfondies :** `semantic_search`, `query_graph` et `explain_symbol`. `query_graph` est un pipeline JSON composable avec les opérations `find`, `connect`, `filter`, `semantic_filter`, `sort` et `limit`.
• **Fédération multi-dépôts :** `list_repos`, `get_repo_info`, `get_federation_health`, `get_cross_repo_blast_radius`, `get_cross_repo_blast_radius_for_repo` et `search_org`.
• **Santé du code :** `find_dead_code`, `suggest_refactor_targets`, `get_agent_strategy` et `get_world_state`.

`semantic_search` exige un modèle d'embeddings ONNX facultatif. Le README recommande BAAI/bge-small-en-v1.5 (384 dimensions, environ 120 Mo) et le désigne par la variable `LAIN_EMBEDDING_MODEL`. Sans modèle, l'outil est retiré de `tools/list`, si bien que les agents ne voient jamais un outil inutilisable. Le README précise que tous les outils de graphe, de rayon d'impact, de navigation et de coordination fonctionnent sans ce modèle.

Installation et connexion

Le README propose un installateur en une ligne : `curl -fsSL https://raw.githubusercontent.com/spuentesp/lain/main/install.sh | bash`, suivi de `lain --version`. Il renvoie aussi au QUICKSTART pour Homebrew et les compilations manuelles. La compilation demande Rust 1.75 ou plus récent. Git est nécessaire pour l'analyse de co-changement.

Connecter un agent tient en une courte étape. Pour Claude Code, la commande est `claude mcp add lain -- lain mcp`. Pour Cursor et Windsurf, `lain setup --agent cursor` écrit `~/.cursor/mcp.json`. La même commande `setup` gère aussi VS Code, Codex, Continue et un fichier `.mcp.json` générique. Pour un service partagé entre plusieurs dépôts, `lain server --config ./repos.yaml --transport http --port 9999` lance le mode HTTP.

Command Center, CLI et rechargement à chaud

En mode HTTP, le serveur sert un tableau de bord dans le navigateur, le Command Center, à l'adresse `GET /`. Il comporte cinq onglets : Overview (nombre de nœuds et d'arêtes, empreinte mémoire, santé de la fédération), Graph (une vue D3 à forces), Repos, Query et Tools. L'onglet Tools permet d'exécuter n'importe quel outil MCP depuis un formulaire et produit un extrait « Copy as cURL ».

La CLI compte de nombreuses commandes. `lain mcp` lance un serveur stdio pour un dépôt, `lain server` le serveur multi-dépôts. `lain doctor` diagnostique le dépôt sans modifier de fichier ; ses codes de sortie sont 0 pour prêt, 1 pour utilisable mais dégradé, et 2 pour inutilisable. `lain hooks` fournit des hooks de pré-édition pour réserver des fichiers et vérifier les chevauchements. `lain schema` exporte le schéma des outils pour que la CI détecte les dérives. `scripts/demo.sh` compare les réponses du serveur à un dépôt synthétique dont le graphe d'appels est connu par construction, puis mesure les outils sur le dépôt lui-même, à environ 3,5k nœuds. Le README ne donne aucun chiffre de benchmark.

Le rechargement à chaud est une fonction d'exploitation notable. Le serveur surveille `repos.yaml` et `workspaces.yaml` et met à jour son état sans redémarrage et sans couper les sessions d'agents actives. Les commandes CLI dialoguent avec le serveur en cours d'exécution par un socket Unix local.

Notre analyse

Cette conception répond à une faiblesse réelle des agents qui ne voient que du texte : une correspondance de mot-clé dit peu de choses sur qui appelle une fonction ou sur ce qui casse si elle change. Un graphe construit à l'avance, avec chaînes d'appels et rayon d'impact, offre à l'agent un moyen plus économique et plus précis de vérifier une modification avant de la faire. Le radar de co-changement est un second signal utile, car l'historique Git révèle des couplages que les imports statiques ne montrent pas.

Le volet multi-agents est l'idée la moins courante. Réservations, battements de cœur et détection de chevauchement traitent plusieurs agents d'un même espace de travail comme un problème de coordination. Le README prend soin d'appeler les verrous « consultatifs », et nous le lisons au sens littéral : ils fonctionnent quand chaque agent suit le protocole. Ils ne semblent pas contraindre un agent indiscipliné à s'arrêter.

Les badges de chaîne d'approvisionnement méritent aussi une mention. Le README affiche un OpenSSF Scorecard, OpenSSF Best Practices, un SBOM CycloneDX, une provenance de build SLSA L2 et un score SafeSkill de 88/100 marqué « Passes with Notes ». Ce sont des indices pour une revue de sécurité, pas une preuve d'innocuité.

Limites et questions ouvertes

Tout ce qui précède vient du README. Nous n'avons ni installé ni exécuté LAIN. Plusieurs affirmations ne sont pas vérifiées par nous : les réponses « en millisecondes », l'absence d'hallucinations, et le benchmark à environ 3,5k nœuds dont aucun chiffre n'est montré.

Le README ne dit pas quels langages obtiennent le graphe complet, il cite seulement `rust-analyzer` et `pylsp` comme exemples de serveurs de langage. Il ne dit pas non plus quelle taille de dépôt la conception en mémoire peut contenir. Ses propres notes de dépannage laissent deviner des limites : l'indexation peut expirer sur de grands arbres de travail avec un cache froid, et la solution consiste à relever `LAIN_REINDEX_TIMEOUT` par rapport aux valeurs par défaut de 300 secondes au total et 60 secondes par dépôt. Il prévient aussi qu'un processus stdio de longue durée peut donner des réponses périmées après une recompilation, tant que le client n'est pas redémarré.

Conseils pratiques

Les développeurs qui utilisent des agents compatibles MCP peuvent essayer d'abord le mode un seul dépôt : installer, lancer `lain doctor`, puis ajouter le serveur avec la commande de leur client. Les équipes qui gèrent plusieurs dépôts peuvent examiner les outils de fédération et le mode HTTP.

Celles qui font tourner plusieurs agents en même temps devraient lire `docs/multiplayer.md` et `docs/hooks.md` avant de compter sur les réservations. Les lecteurs attentifs à la sécurité liront le script d'installation avant de l'envoyer dans un shell, et consulteront les notes de provenance de `docs/VERIFICATION.md`. Traitez toute affirmation de précision comme une hypothèse, jusqu'à ce que vous ayez lancé `scripts/demo.sh` et vos propres tâches.