Cerveau : Un système de mémoire d'erreurs persistantes pour le code Claude via MCP

Ce que Brain fait

Brain est un serveur MCP qui fournit à Claude Code une mémoire persistante et inter-projets. Il stocke chaque erreur rencontrée, chaque solution qui a fonctionné ou non, et chaque module de code à travers tous les projets. Au fil du temps, il apprend en renforçant les connexions entre concepts apparentés via un réseau de synapses Hebbien, révélant des motifs et suggérant proactivement des solutions.

Comment il fonctionne

Lorsque Claude rencontre une erreur, Brain :

• Capture le contexte complet — message d'erreur, trace d'exécution, répertoire de travail, branche git, diff actuel, et la commande qui l'a provoquée
• La compare à chaque erreur qu'il a jamais vue en utilisant une recherche hybride à triple signal (TF-IDF + plongements vectoriels + proximité synaptique)
• Suggère des solutions éprouvées avec des scores de confiance basés sur les Intervalles de Score Wilson
• Trace les chaînes d'erreurs — détecte quand les erreurs s'enchaînent suite à des tentatives de correction
• Apprend du résultat — si le correctif fonctionne, la connexion se renforce ; s'il échoue, Brain s'en souvient aussi

L'idée clé : les erreurs du Projet A aident à résoudre les bogues du Projet B. Cette condition de concurrence async/await que vous avez corrigée dans votre backend ? Brain suggérera le même motif quand il verra une erreur similaire dans un projet complètement différent.

Le Réseau de Synapses

Brain construit un graphe pondéré connectant :

• Erreurs ↔ Solutions
• Erreurs ↔ Modules de Code
• Modules ↔ Dépendances
• Tout ↔ Concepts

Les connexions se renforcent avec une utilisation répétée (apprentissage Hebbien) et s'affaiblissent avec le temps si inutilisées. Vous pouvez explorer les connaissances apparentées via l'activation propagée :

brain explore "ENOENT file not found"

Cela pourrait révéler : une solution d'il y a 3 mois, un module apparenté qui gère les chemins de fichiers, et une règle préventive concernant la vérification de l'existence des fichiers avant lecture.

Le réseau actuel du créateur : 18 138 modules de code connectés par 37 215 synapses à travers tous les projets — et 3 870 insights actifs générés automatiquement par le moteur de recherche.

Architecture

Brain est construit comme un système modulaire avec de multiples points d'accès :

+------------------+ +------------------+ +------------------+
| 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 composants principaux, tous alimentant une base de données SQLite (21,8 Mo pour la configuration du créateur).

Fonctionnalités Clés

Détection Automatique d'Erreurs : Un crochet PostToolUse capture automatiquement les erreurs depuis la sortie Bash — codes de sortie, TypeError, ENOENT, npm ERR!, BUILD FAILED, etc. Vous n'avez jamais à signaler quoi que ce soit manuellement.

Prévention Proactive : Brain ne fait pas que réagir — il vous avertit AVANT que les bogues ne surviennent. Un crochet PostWrite vérifie le nouveau code contre les anti-modèles connus.

Source : github.com/timmeck/brain