Gehirn: Ein persistentes Fehlerspeichersystem für Claude Code über MCP

Was Brain tut

Brain ist ein MCP-Server, der Claude Code mit persistentem, projektübergreifendem Speicher versorgt. Er speichert jeden aufgetretenen Fehler, jede Lösung, die funktioniert hat oder nicht, und jedes Codemodul über alle Projekte hinweg. Mit der Zeit lernt er, indem er Verbindungen zwischen verwandten Konzepten durch ein Hebb'sches Synapsennetzwerk stärkt, Muster aufdeckt und proaktiv Lösungen vorschlägt.

Wie es funktioniert

Wenn Claude auf einen Fehler stößt, tut Brain:

• Erfasst den vollständigen Kontext – Fehlermeldung, Stack-Trace, Arbeitsverzeichnis, Git-Branch, aktuelles Diff und den Befehl, der ihn verursacht hat
• Vergleicht ihn mit jedem jemals gesehenen Fehler mithilfe einer Triple-Signal-Hybridsuche (TF-IDF + Vektoreinbettungen + Synapsennähe)
• Schlägt bewährte Lösungen mit Zuverlässigkeitsbewertungen basierend auf Wilson-Score-Intervallen vor
• Verfolgt Fehlerketten – erkennt, wenn Fehler durch Lösungsversuche kaskadieren
• Lernt aus dem Ergebnis – wenn die Lösung funktioniert, wird die Verbindung gestärkt; wenn sie scheitert, merkt sich Brain das ebenfalls

Die entscheidende Erkenntnis: Fehler aus Projekt A helfen, Bugs in Projekt B zu lösen. Diese Async/Await-Race-Condition, die du in deinem Backend behoben hast? Brain wird das gleiche Muster vorschlagen, wenn es einen ähnlichen Fehler in einem völlig anderen Projekt sieht.

Das Synapsennetzwerk

Brain baut einen gewichteten Graphen auf, der verbindet:

• Fehler ↔ Lösungen
• Fehler ↔ Codemodule
• Module ↔ Abhängigkeiten
• Alles ↔ Konzepte

Verbindungen stärken sich bei wiederholter Nutzung (Hebbian Learning) und schwächen sich mit der Zeit ab, wenn sie ungenutzt bleiben. Du kannst verwandtes Wissen durch spreading activation erkunden:

brain explore "ENOENT file not found"

Dies könnte aufdecken: eine Lösung von vor 3 Monaten, ein verwandtes Modul, das Dateipfade verarbeitet, und eine präventive Regel zum Überprüfen der Dateiexistenz vor Lesevorgängen.

Das aktuelle Netzwerk des Erstellers: 18.138 Codemodule, verbunden durch 37.215 Synapsen über alle Projekte hinweg – und 3.870 aktive Erkenntnisse, automatisch generiert von der Research-Engine.

Architektur

Brain ist als modulares System mit mehreren Zugangspunkten aufgebaut:

+------------------+ +------------------+ +------------------+
| Claude Code      | | Cursor/Windsurf  | | Browser/CI/CD    |
| (MCP stdio)      | | (MCP HTTP/SSE)   | | (REST API)       |
+--------+---------+ +--------+---------+ +--------+---------+
         |                    |                    |
         v                    v                    v
+--------+---------+ +--------+---------+ +--------+---------+
| MCP Server       | | MCP HTTP/SSE    | | REST API         |
| (stdio)          | | (port 7778)     | | (port 7777)      |
+--------+---------+ +--------+---------+ +--------+---------+
         |                    |                    |
         +----------+-------------+------------------------+
                    v
          +----------+-----------+
          | BrainCore            |
          | (Daemon / Services)  |
          +----------+-----------+
                    +-------+-------+--------+--------+
                    |       |       |        |        |
                    v       v       v        v        v
           Error    Code    Synapse Git      Embedding
           Memory   Brain   Network Intel    Engine
                    |       |       |        |        |
                    v       v       v        v        v
           Learn    Module  Hebbian Commit   Vector
           Engine   Score   Learn   Track    Search
                    |
                    v
           SQLite (DB)
           better-sqlite3

10 Kernkomponenten, die alle in eine SQLite-Datenbank fließen (21,8 MB für das Setup des Erstellers).

Hauptmerkmale

Automatische Fehlererkennung: Ein PostToolUse-Hook fängt Fehler automatisch aus der Bash-Ausgabe ab – Exit-Codes, TypeError, ENOENT, npm ERR!, BUILD FAILED usw. Du musst nie etwas manuell melden.

Proaktive Prävention: Brain reagiert nicht nur – es warnt dich, BEVOR Bugs auftreten. Ein PostWrite-Hook überprüft neuen Code gegen bekannte Antipatterns.

Source: github.com/timmeck/brain