LAIN: Code-Graph im Speicher und MCP-Tools für Agenten

Was LAIN ist, nach eigener Darstellung im README

LAIN-mcp ist ein Open-Source-Projekt von spuentesp auf GitHub unter der MIT-Lizenz. Das README nennt es „eine persistente, leistungsfähige Engine für Code-Intelligenz und Koordination, die speziell für KI-Coding-Agenten gebaut wurde". Sie spricht über das Model Context Protocol (MCP) mit den Agenten. Als Beispielclients nennt das README Claude Code, Cursor, Copilot, Codex, Agy, Cline und Windsurf.

Die Idee ist einfach. Viele Coding-Agenten behandeln Code als flachen Text und suchen darin per Stichwort. LAIN indiziert stattdessen die Codebasis als typisierten, strukturellen Property-Graphen im Arbeitsspeicher. Den Graphen baut es aus Tree-sitter, Language Servern und der Git-Commit-Historie. Danach stellt es eine Reihe deterministischer MCP-Werkzeuge bereit, damit ein Agent strukturelle Fragen stellen und exakte Antworten bekommen kann. Laut README können Agenten so an komplexen Codebasen arbeiten, „ohne Halluzinationen, blinde Änderungen oder verschwendetes Kontextfenster". Das ist die Aussage des Projekts selbst. Dieser Artikel hat sie nicht geprüft.

Funktionsweise: die fünf Stufen im README

Das README beschreibt fünf Stufen. Erstens Indizierung und Parsing: LAIN durchsucht den Code mit Tree-sitter und Language Servern und überführt Funktionen, Klassen, Importe und Referenzen in einen Property-Graphen. Zweitens ein persistenter Graph-Speicher: Der Graph wird nach `.lain/graph.bin` serialisiert, die Kennungen werden deterministisch als UUID v5 abgeleitet, sodass er schnell neu geladen werden kann. Drittens zeitliches Mining: LAIN liest die Git-Commit-Logs und baut ein „Co-Change-Kopplungsradar", das Module findet, die sich gemeinsam entwickeln, auch ohne expliziten Import. Viertens beratende Präsenz: Register im Speicher und auf der Platte verfolgen Agentensitzungen und Dateibelegungen, um überlappende Änderungen zu verhindern. Fünftens universelle MCP-Auslieferung: Die Werkzeuge werden über stdio oder HTTP angeboten.

Das Architekturdiagramm liefert weitere Einzelheiten. Es gibt zwei Transporte: stdio für ein einzelnes Repository und HTTP auf Port 9999 mit JSON-RPC und SSE. Dahinter liegt ein Kern aus einem einheitlichen Werkzeug-Dispatcher, einer Graph-Engine im Speicher auf Basis von Petgraph, einem Präsenz- und Belegungsregister, das als „beratende Leases und Sperren" beschrieben wird, und einer Föderations-Engine für N Repositories.

Die Werkzeugoberfläche

Das README ordnet die MCP-Werkzeuge in sechs Familien.

• **Auswirkungsradius und Abhängigkeitsverfolgung:** `get_blast_radius`, `get_call_chain`, `trace_dependency` und `get_coupling_radar`. Sie liefern die nachgelagerten Folgen einer Symboländerung, den kürzesten Pfad zwischen zwei Funktionen, vorgelagerte Abhängigkeiten und Dateien, die sich häufig gemeinsam ändern.
• **Architekturerkundung:** `find_anchors`, `list_entry_points`, `get_context_depth` und `explore_architecture`. Sie finden die meistaufgerufenen und stabilsten Symbole, Einstiegspunkte wie `main()`, HTTP-Routen und Event-Handler sowie einen hierarchischen Modulbaum.
• **Koordination mehrerer Agenten, „Multiplayer Mode" genannt:** `register_agent`, `heartbeat`, `claim_files`, `release_files`, `detect_overlap`, `list_active_agents` und `who_am_i`.
• **Suche und tiefe Abfragen:** `semantic_search`, `query_graph` und `explain_symbol`. `query_graph` ist eine zusammensetzbare JSON-Pipeline mit den Operationen `find`, `connect`, `filter`, `semantic_filter`, `sort` und `limit`.
• **Föderation mehrerer Repositories:** `list_repos`, `get_repo_info`, `get_federation_health`, `get_cross_repo_blast_radius`, `get_cross_repo_blast_radius_for_repo` und `search_org`.
• **Code-Gesundheit:** `find_dead_code`, `suggest_refactor_targets`, `get_agent_strategy` und `get_world_state`.

`semantic_search` braucht ein optionales ONNX-Embedding-Modell. Das README empfiehlt BAAI/bge-small-en-v1.5 (384 Dimensionen, etwa 120 MB) und verweist über die Variable `LAIN_EMBEDDING_MODEL` darauf. Ohne Modell wird das Werkzeug aus `tools/list` entfernt, sodass Agenten nie ein unbrauchbares Werkzeug sehen. Laut README funktionieren alle Werkzeuge für Graph, Auswirkungsradius, Navigation und Koordination auch ohne das Modell.

Installation und Anbindung

Das README bietet einen Einzeiler zur Installation: `curl -fsSL https://raw.githubusercontent.com/spuentesp/lain/main/install.sh | bash`, danach `lain --version`. Für Homebrew und manuelle Builds verweist es auf die QUICKSTART. Zum Bauen ist Rust 1.75 oder neuer nötig. Git wird für die Co-Change-Analyse benötigt.

Einen Agenten anzubinden ist ein kurzer Schritt. Für Claude Code lautet der Befehl `claude mcp add lain -- lain mcp`. Für Cursor und Windsurf schreibt `lain setup --agent cursor` die Datei `~/.cursor/mcp.json`. Derselbe Befehl `setup` unterstützt auch VS Code, Codex, Continue und eine generische `.mcp.json`. Als gemeinsamer Dienst für mehrere Repositories startet `lain server --config ./repos.yaml --transport http --port 9999` den HTTP-Modus.

Command Center, CLI und Hot Reload

Im HTTP-Modus liefert der Server unter `GET /` ein Browser-Dashboard namens Command Center aus. Es hat fünf Tabs: Overview (Knoten- und Kantenzahlen, Speicherbedarf, Gesundheit der Föderation), Graph (eine D3-Ansicht mit Kräftelayout), Repos, Query und Tools. Im Tab Tools lässt sich jedes MCP-Werkzeug über ein Formular ausführen; dazu erzeugt er ein „Copy as cURL"-Snippet.

Die CLI hat viele Befehle. `lain mcp` startet einen stdio-Server für ein Repository, `lain server` den Server für mehrere Repositories. `lain doctor` diagnostiziert das Repository, ohne Dateien zu ändern; die Exit-Codes sind 0 für bereit, 1 für nutzbar, aber eingeschränkt, und 2 für unbrauchbar. `lain hooks` liefert Pre-Edit-Hooks, um Dateien zu belegen und Überlappungen zu prüfen. `lain schema` gibt das Werkzeugschema aus, damit die CI Abweichungen erkennt. `scripts/demo.sh` gleicht die Antworten des Servers mit einem synthetischen Repository ab, dessen Aufrufgraph konstruktionsbedingt bekannt ist, und misst danach die Werkzeuge am Repository selbst mit etwa 3,5k Knoten. Das README nennt keine Benchmark-Zahlen.

Hot Reload ist ein bemerkenswertes Betriebsmerkmal. Der Server überwacht `repos.yaml` und `workspaces.yaml` und aktualisiert seinen Zustand ohne Neustart und ohne aktive Agentensitzungen zu trennen. CLI-Befehle sprechen über einen lokalen Unix-Socket mit dem laufenden Server.

Unsere Analyse

Der Entwurf trifft eine echte Schwäche von Agenten, die nur Text sehen: Ein Stichworttreffer sagt wenig darüber, wer eine Funktion aufruft oder was bei einer Änderung bricht. Ein vorgebauter Graph mit Aufrufketten und Auswirkungsradius gibt dem Agenten einen günstigeren und genaueren Weg, eine Änderung vor dem Schreiben zu prüfen. Das Co-Change-Radar ist ein nützliches zweites Signal, weil die Git-Historie Kopplungen zeigt, die statische Importe übersehen.

Die Mehr-Agenten-Seite ist die seltenere Idee. Belegungen, Heartbeats und Überlappungserkennung behandeln mehrere Agenten in einem Arbeitsbereich als Koordinationsproblem. Das README nennt die Sperren sorgsam „beratend", und wir lesen das wörtlich: Sie wirken, wenn sich jeder Agent an das Protokoll hält. Einen Agenten, der sich nicht daran hält, scheinen sie nicht zum Stoppen zu zwingen.

Auch die Lieferketten-Badges verdienen eine Erwähnung. Das README zeigt einen OpenSSF Scorecard, OpenSSF Best Practices, ein CycloneDX-SBOM, SLSA-L2-Build-Herkunft und einen SafeSkill-Wert von 88/100 mit dem Vermerk „Passes with Notes". Das sind Hinweise für eine Sicherheitsprüfung, kein Beweis für Sicherheit.

Grenzen und offene Fragen

Alles hier stammt aus dem README. Wir haben LAIN weder installiert noch ausgeführt. Mehrere Aussagen sind von uns ungeprüft: Antworten „in Millisekunden", die Freiheit von Halluzinationen und der Benchmark mit etwa 3,5k Knoten, zu dem keine Zahlen gezeigt werden.

Das README sagt nicht, für welche Sprachen der volle Graph entsteht; es nennt nur `rust-analyzer` und `pylsp` als Beispiele für Language Server. Es sagt auch nicht, wie große Repositories der Entwurf im Arbeitsspeicher fassen kann. Die eigenen Hinweise zur Fehlersuche deuten Grenzen an: Auf großen Arbeitsverzeichnissen mit kaltem Cache kann die Indizierung in eine Zeitüberschreitung laufen, und die Abhilfe ist, `LAIN_REINDEX_TIMEOUT` über die Standardwerte von 300 Sekunden insgesamt und 60 Sekunden je Repository zu erhöhen. Außerdem warnt es, dass ein langlebiger stdio-Prozess nach einem Neubau veraltete Antworten liefern kann, bis der Client neu gestartet wird.

Praktische Hinweise

Entwickler mit MCP-fähigen Agenten können zuerst den Weg mit einem Repository probieren: installieren, `lain doctor` ausführen und den Server dann mit dem Befehl für ihren Client hinzufügen. Teams mit mehreren Repositories können sich die Föderationswerkzeuge und den HTTP-Modus ansehen.

Teams, die mehrere Agenten gleichzeitig laufen lassen, sollten `docs/multiplayer.md` und `docs/hooks.md` lesen, bevor sie sich auf Belegungen verlassen. Sicherheitsbewusste Leser lesen das Installationsskript, bevor sie es in eine Shell leiten, und prüfen die Herkunftshinweise in `docs/VERIFICATION.md`. Behandeln Sie jede Genauigkeitsbehauptung als Hypothese, bis Sie `scripts/demo.sh` und Ihre eigenen Aufgaben ausgeführt haben.