Cérebro: Um Sistema de Memória de Erros Persistente para Claude Code via MCP

O que o Brain faz

Brain é um servidor MCP que fornece ao Claude Code memória persistente e entre projetos. Ele armazena todos os erros encontrados, todas as soluções que funcionaram ou não, e todos os módulos de código em todos os projetos. Com o tempo, ele aprende fortalecendo conexões entre conceitos relacionados através de uma rede de sinapses Hebbiana, revelando padrões e sugerindo soluções proativamente.

Como funciona

Quando o Claude encontra um erro, o Brain:

• Captura o contexto completo — mensagem de erro, rastreamento da pilha, diretório de trabalho, branch do git, diff atual e o comando que o causou
• Compara-o com todos os erros que já viu usando uma busca híbrida de triplo sinal (TF-IDF + embeddings vetoriais + proximidade de sinapses)
• Sugere soluções comprovadas com pontuações de confiança baseadas em Intervalos de Pontuação Wilson
• Rastreia cadeias de erros — detecta quando erros se propagam a partir de tentativas de correção
• Aprende com o resultado — se a correção funciona, a conexão se fortalece; se falha, o Brain também se lembra disso

A ideia principal: erros do Projeto A ajudam a resolver bugs no Projeto B. Aquele problema de condição de corrida async/await que você corrigiu no seu backend? O Brain sugerirá o mesmo padrão quando vir um erro semelhante em um projeto completamente diferente.

A Rede de Sinapses

O Brain constrói um grafo ponderado conectando:

• Erros ↔ Soluções
• Erros ↔ Módulos de Código
• Módulos ↔ Dependências
• Tudo ↔ Conceitos

As conexões se fortalecem com o uso repetido (aprendizado Hebbiano) e enfraquecem com o tempo se não forem usadas. Você pode explorar conhecimento relacionado através da ativação por propagação:

brain explore "ENOENT file not found"

Isso pode revelar: uma solução de 3 meses atrás, um módulo relacionado que lida com caminhos de arquivo e uma regra preventiva sobre verificar a existência de arquivos antes de leituras.

A rede atual do criador: 18.138 módulos de código conectados por 37.215 sinapses em todos os projetos — e 3.870 insights ativos gerados automaticamente pelo mecanismo de pesquisa.

Arquitetura

O Brain é construído como um sistema modular com múltiplos pontos de acesso:

+------------------+ +------------------+ +------------------+
| 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 principais, todos alimentando um banco de dados SQLite (21,8 MB para a configuração do criador).

Principais Recursos

Detecção Automática de Erros: Um hook PostToolUse captura erros automaticamente da saída do Bash — códigos de saída, TypeError, ENOENT, npm ERR!, BUILD FAILED, etc. Você nunca precisa relatar nada manualmente.

Prevenção Proativa: O Brain não apenas reage — ele alerta você ANTES que bugs aconteçam. Um hook PostWrite verifica o novo código contra antipadrões conhecidos.

Fonte: github.com/timmeck/brain