Cerebro: Un Sistema de Memoria de Errores Persistente para Claude Code mediante MCP

Qué hace Brain

Brain es un servidor MCP que proporciona a Claude Code memoria persistente y entre proyectos. Almacena cada error encontrado, cada solución que funcionó o no, y cada módulo de código en todos los proyectos. Con el tiempo, aprende fortaleciendo las conexiones entre conceptos relacionados a través de una red de sinapsis hebbiana, detectando patrones y sugiriendo soluciones de manera proactiva.

Cómo funciona

Cuando Claude encuentra un error, Brain:

• Captura el contexto completo — mensaje de error, traza de la pila, directorio de trabajo, rama de git, diff actual y el comando que lo causó
• Lo compara con cada error que ha visto usando una búsqueda híbrida de triple señal (TF-IDF + incrustaciones vectoriales + proximidad de sinapsis)
• Sugiere soluciones probadas con puntuaciones de confianza basadas en Intervalos de Puntuación de Wilson
• Rastrea cadenas de errores — detecta cuando los errores se propagan por intentos de corrección
• Aprende del resultado — si la corrección funciona, la conexión se fortalece; si falla, Brain también lo recuerda

La idea clave: los errores del Proyecto A ayudan a resolver errores en el Proyecto B. ¿Esa condición de carrera async/await que solucionaste en tu backend? Brain sugerirá el mismo patrón cuando vea un error similar en un proyecto completamente diferente.

La Red de Sinapsis

Brain construye un gráfico ponderado que conecta:

• Errores ↔ Soluciones
• Errores ↔ Módulos de Código
• Módulos ↔ Dependencias
• Todo ↔ Conceptos

Las conexiones se fortalecen con el uso repetido (aprendizaje hebbiano) y se debilitan con el tiempo si no se usan. Puedes explorar conocimientos relacionados mediante activación por propagación:

brain explore "ENOENT file not found"

Esto podría mostrar: una solución de hace 3 meses, un módulo relacionado que maneja rutas de archivos y una regla preventiva sobre verificar la existencia de archivos antes de leerlos.

La red actual del creador: 18,138 módulos de código conectados por 37,215 sinapsis en todos los proyectos — y 3,870 ideas activas generadas automáticamente por el motor de investigación.

Arquitectura

Brain está construido como un sistema modular con múltiples puntos de acceso:

+------------------+ +------------------+ +------------------+
| 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 componentes principales, todos alimentando una base de datos SQLite (21.8 MB para la configuración del creador).

Características Clave

Detección Automática de Errores: Un gancho PostToolUse detecta errores automáticamente de la salida de Bash — códigos de salida, TypeError, ENOENT, npm ERR!, BUILD FAILED, etc. Nunca tienes que reportar nada manualmente.

Prevención Proactiva: Brain no solo reacciona — te advierte ANTES de que ocurran errores. Un gancho PostWrite verifica el código nuevo contra antipatrones conocidos.

Source: github.com/timmeck/brain