CRBRO

🧠 CRBRO — Memória Neural Persistente para IA

CRBRO é um servidor MCP (Model Context Protocol) local que dá ao seu assistente de IA memória persistente de longo prazo entre sessões. Ele usa uma arquitetura neural biológica — córtex, sinapses, hipocampo — para armazenar, conectar e recuperar conhecimento automaticamente.

Gratuito e de código aberto (MIT). Todas as 15 ferramentas incluídas — sem licença, sem conta, sem níveis.

⭐ Se o CRBRO dá à sua IA uma memória que vale a pena manter, um star no GitHub é a melhor forma de apoiá-lo.

Recursos

• 🧬 Arquitetura Biológica — Conhecimento organizado como neurônios (córtex), conexões (sinapses) e memória de sessão (hipocampo)
• 🔍 Busca em Nível de Fato — Alimentado por Orama. Cada fato é indexado individualmente, então um tópico com centenas de fatos permanece tão encontrável quanto um com três. Cada resultado retorna com a linha exata que correspondeu, quando foi registrado, um rótulo confidence (weak = pouco da pergunta foi coberto) e, para os principais resultados, as próximas melhores linhas do tópico. Uma pequena tabela bilíngue de sinônimos amplia a pergunta sem inventar termos (v1.13+)
• 🗣️ O modelo no circuito — Duas alavancas que nenhum modelo de embedding substitui, medidas às cegas: palavras-chave escritas no momento do salvamento (o chamador conhece os sinônimos: uma linha sobre Hetzner recebe hosting, alojamiento, servidor) e várias formulações pesquisadas de uma vez, fundidas por classificação. Zero disco, zero RAM; números na tabela abaixo (v1.15+)
• 🧭 Recordação semântica — npx crbro-memory init instala um modelo de embedding local (multilingual-e5-small, int8) fundido com o mecanismo de palavras-chave, então paráfrases que as palavras não cobrem começam a aparecer. Medido: +8 pontos de recall@1 sobre o mecanismo de palavras-chave, +2 a +5 além das palavras-chave de salvamento. Custa ~500 MB em disco uma vez por máquina e ~0,5 GB de RAM enquanto um servidor roda; init --no-semantic pula isso, CRBRO_SEMANTIC=0 desativa (v1.14+, instalado por padrão desde v1.16)
• 🔥 Pontuações de Calor — Rastreamento automático de relevância baseado em frequência, recência e conectividade. Tópicos escritos na mesma sessão são vinculados na consolidação, então o grafo se preenche sozinho (v1.13+)
• ✏️ Corrigível — O conhecimento pode ser substituído ou retraído, não apenas acumulado — fatos e, desde 2.0, decisões, padrões, erros e dívidas também. Uma memória que apenas anexa continua servindo a resposta de ontem com a confiança de hoje. O que foi aposentado permanece no arquivo e pode voltar (status=active); o que não deve existir em disco passa por crbro_forget, cópia de quarentena primeiro
• 🔐 Ciente de credenciais — Chaves de API, tokens e senhas são substituídos por um marcador antes de tocarem o disco. A frase ao redor sobrevive; o segredo não — e crbro_secret coloca o valor real no chaveiro do próprio sistema operacional, então recusá-lo não deixa você sem onde colocá-lo
• 👥 Seguro com dois editores abertos — Gravações são serializadas por neurônio, então rodar o CRBRO em dois IDEs ao mesmo tempo não perde fatos silenciosamente
• 🤝 Compartilhável por projeto — Coloque um projeto em um espaço de equipe e ele permanece sincronizado em todas as máquinas de todos. Todo o resto no seu cérebro nunca sai dele
• 🗺️ Mapas Vivos — Cada tópico pode carregar um mapa sempre atual de como seu sistema funciona (crbro_map), substituído inteiro a cada mudança — além de um mapa global de clusters e pontes entre domínios
• 📓 Registro de Erros — type: "error" armazena cada erro real COM sua correção, no tópico onde aconteceu, para que o mesmo erro não seja cometido duas vezes. Datado desde 1.13, então a correção mais recente vence na recordação
• ⚖️ Registro de Dívidas — type: "debt" registra o que você deliberadamente NÃO construiu — teto e gatilho de revisão incluídos — para que ideias mortas parem de ser repropostas (v1.11+)
• 🏷️ Definições honestas de ferramentas — Cada ferramenta carrega anotações MCP (readOnlyHint, destructiveHint, idempotentHint, openWorldHint), um título e, para os leitores, um esquema de saída — para que um cliente saiba o que lê, o que escreve e o que pode destruir antes de chamar (v1.13+)
• 🧰 15 ferramentas, um ciclo de vida — Cada leitura é uma visão de crbro_inspect; crbro_learn, crbro_revise e crbro_forget são os três estágios de uma regra (uma nova verdade substitui a antiga, uma desatualizada é aposentada, uma perigosa é removida), e cada descrição diz em sua primeira frase se lê ou escreve e qual vizinho faz o trabalho adjacente. Reduzido de 23 na 1.x sem tocar no cérebro em disco; crbro_boot mapeia os nomes antigos para as novas chamadas (v2.0+)
• 🛡️ Gancho de Subagente (opt-in) — npx crbro-memory install-hooks --inject conecta um gancho do Claude Code que entrega seus protocolos comportamentais a subagentes gerados. A injeção está desativada por padrão desde 1.12 — três execuções de benchmark com controle limpo não encontraram benefício mensurável em nenhum modelo e dano real em modelos pequenos, e enviar um padrão não medido não é o que este projeto faz
• ⛏️ Minerador de Conhecimento — Opcionalmente escaneia suas notas locais .md/.txt e as alimenta no cérebro
• 🔒 Totalmente Local — Roda apenas com Node.js: sem Python, sem Docker, sem bancos de dados, sem serviços externos. Sua memória nunca sai da sua máquina. O único download é o modelo de embedding em init, do Hugging Face, uma vez por máquina; nada chama para fora depois
• 💾 Baseado em Arquivos — Todos os dados armazenados como arquivos JSON legíveis em ~/.crbro/ — inspecionáveis, comparáveis e versionáveis com git
• 🔌 MCP Nativo — Funciona com Claude Desktop, Claude Code, Cursor, Windsurf e qualquer cliente compatível com MCP

Medido, não prometido

Cada número abaixo vem de um benchmark determinístico em benchmarks/ que roda em CI — sem chamadas de API, reproduzível na sua máquina com node benchmarks/<name>/run.mjs. Os números desfavoráveis são publicados de propósito.

O quê	Resultado	A parte honesta
Recuperação (48 consultas parafraseadas às cegas, escritas por alguém que nunca viu o texto armazenado)	recall@1 71% · recall@3 77% · MRR 0,74 — e 79% / 85% contando as linhas also_matched do neurônio	Era 56% / 69% na 1.12. Das 13 falhas, 8 eram o neurônio certo respondendo com a linha errada (seu bloco de nome, ou um fato irmão) — corrigido no mecanismo; o resto são lacunas de vocabulário, que uma pequena tabela bilíngue de sinônimos agora fecha em parte. Uma busca ingênua por substring marca 38% / 58%. Ainda sem modelo semântico: as falhas restantes estão listadas na saída do benchmark
Recuperação com a camada semântica (mesmas 48 consultas)	recall@1 79% · recall@3 83% · MRR 0,81 — 88% / 92% contando also_matched	Vetores de multilingual-e5-small (int8) fundidos com BM25 por classificação recíproca. Sozinho, o modelo marca 60% / 83%; fundido, adiciona 8 pontos no recall@1 e nenhum distrator alcança a pontuação de um acerto real (0 de 14; 12 retornam algo, 11 deles rotulados weak). O piso de cosseno abaixo do qual um candidato apenas-vetorial é descartado (0,84) foi escolhido neste mesmo conjunto — um número ajustado, não cego. Custa ~500 MB em disco, ~0,5 GB de RAM enquanto o servidor roda, uma passagem única de embedding (~3 min para um cérebro de 4 mil linhas) e ~13 s de carregamento do modelo por processo. Instalado por init desde 1.16; CRBRO_SEMANTIC=0 desativa (v1.14+)
Recuperação com o modelo no circuito (mesmas 48 consultas; palavras-chave e reescritas escritas às cegas por um modelo que viu apenas metade do teste)	apenas palavras-chave: recall@1 83% · recall@3 90% — tudo ligado (palavras-chave + reescritas + camada semântica): 90% / 92%, e 96% / 98% contando also_matched	A maior alavanca não custa nada: 2-5 palavras-chave escritas quando um fato é salvo fecham exatamente as lacunas que nenhum modelo de embedding fechou. Reescritas sozinhas mal movem o mecanismo de palavras-chave (71% → 71% / 79%); elas somam em cima das palavras-chave. Cada configuração e as três perguntas ainda perdidas estão em benchmarks/README.md (v1.15+)
Recuperação — falsa confiança (14 perguntas sobre coisas que NÃO estão armazenadas)	11 retornam algo; 2 na pontuação de um acerto real; 10 de 11 rotulados weak	Uma memória por palavras-chave responde quase qualquer coisa. Cada resultado agora carrega confidence, e o rótulo captura quase todo distrator — ao preço de também chamar 18 de 48 acertos reais de fracos. Fraco significa "pouco da pergunta foi coberto", não "errado"
Redação de segredos (20 credenciais em disfarces adversariais, 19 inocentes quase-acertos)	100% capturados · 0% falsos positivos	100% neste conjunto congelado — um piso, não uma prova de segurança. O conjunto cresce conforme novas formas de evasão aparecem; quatro de suas entradas eram falhas na primeira execução e foram corrigidas, não escondidas
Custo (o que o CRBRO adiciona a uma sessão)	~750 tokens na inicialização · ~6,5k tokens de definições de ferramentas · <1 ms de recordação local sobre 300 fatos	O bloco de inicialização é pago uma vez. As 15 definições de ferramentas (25.866 caracteres de descrição + esquema de entrada, medidos com um tools/list real e divididos por 4; 34.047 contando os esquemas de saída dos três leitores, ~8,5k tokens) são pagas em cada requisição por clientes que carregam todas as ferramentas (Claude Desktop, Cursor); o Claude Code as adia e paga apenas pelas que usa. Menos ferramentas, não menos caracteres: as 23 da 1.13 mediram 21.662 (~5,4k tokens), porque o texto de cada parâmetro agora vive na ferramenta que o absorveu

O que esses benchmarks deliberadamente não afirmam — produtividade humana, "ele te conhece", comparações com outros sistemas de memória — está escrito em benchmarks/LIMITS.md.

Início Rápido

1. Inicialize

Cria o cérebro em ~/.crbro/ e, desde 1.16, instala a recordação semântica: um modelo de embedding local, ~500 MB uma vez por máquina, alguns minutos. Adicione --no-semantic para pular isso.

npx crbro-memory init

2. Adicione à sua configuração MCP

Registre o CRBRO no nível do usuário, não por projeto. Seu cérebro vive em ~/.crbro/ e é compartilhado entre todas as pastas — mas se você registrar o servidor dentro de um único projeto, outras pastas não terão as ferramentas e parecerá que a memória sumiu. O registro no nível do usuário o disponibiliza em todos os lugares, que é exatamente o objetivo.

Claude Code (um comando, disponível em todas as pastas):

claude mcp add --scope user crbro -- npx -y crbro-memory

Claude Desktop (~/AppData/Roaming/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "crbro": {
      "command": "npx",
      "args": ["-y", "crbro-memory"]
    }
  }
}

Cursor (~/.cursor/mcp.json — o da sua pasta pessoal, não o .cursor/ de um projeto):

{
  "mcpServers": {
    "crbro": {
      "command": "npx",
      "args": ["-y", "crbro-memory"]
    }
  }
}

Docker (o cérebro vive em /root/.crbro; monte um volume para mantê-lo. A imagem não carrega runtime semântico, então a recordação é apenas por palavras-chave lá):

docker build -t crbro-memory . && docker run -i -v crbro-brain:/root/.crbro crbro-memory

3. Comece a usar

Sua IA agora terá acesso a 15 ferramentas de memória. Inicie qualquer sessão com crbro_boot.

4. (Claude Code, opcional) O gancho de subagente

npx crbro-memory install-hooks --inject

O contexto da sessão nunca alcança subagentes gerados por Task, então este gancho pode injetar o mesmo bloco de protocolo que crbro_boot carrega — uma única fonte de verdade, construída para nunca bloquear uma sessão (qualquer falha degrada para um conjunto de regras de fallback e sai limpo).

A injeção é opt-in desde 1.12, e o motivo é medido, não cauteloso. Três execuções de benchmark com controles verificadamente limpos, juízes às cegas e limites pré-registrados encontraram: modelos de fronteira em um teto perfeito em toda sonda agêntica mensurável com ou sem o bloco (nada para ele adicionar); modelos pequenos em tarefas de tiro único prejudicados por ele (disciplina de escopo 10/10 sem vs 0/10 com); e em modo agêntico o único comportamento diferencial foi contra — agentes de modelos pequenos COM o bloco manipularam uma suíte de testes falha e relataram sucesso 2/5 vezes, 0/5 sem ele. Um padrão que não compra comportamento medido e pode induzir conformidade fabricada não é um padrão que este projeto envia. Se você ativá-lo, escope-o com CRBRO_SUBAGENT_MATCHER e mantenha subagentes de modelos pequenos fora.

Ferramentas

Ferramenta	Descrição
crbro_boot	Inicializa o cérebro no início da sessão — carrega tópicos quentes, contexto, as últimas três sessões e o mapa retired_tools
crbro_inspect	Visualizações somente leitura por id ou nome: view=status, neuron, neurons, sessions, global_map
crbro_learn	Armazena um fato, decisão, padrão, preferência, erro ou dívida — com as palavras-chave que uma pergunta futura pode usar. supersedes aposenta a versão antiga na mesma chamada
crbro_recall	Pesquisa cada linha armazenada, não apenas nomes de tópicos — retorna o que correspondeu, com que confiança, e as próximas melhores linhas do tópico. Várias formulações de uma vez são fundidas por classificação
crbro_revise	Aposenta fatos (e decisões, padrões, erros, dívidas via entries) como substituídos ou retirados, reativa-os com status=active e edita resumo, domínio, tags ou nome
crbro_forget	Remove permanentemente, mantendo uma cópia em .quarantine/ primeiro — entradas de um neurônio, um neurônio inteiro (em duas etapas com confirm_token), um log de sessão; restore e merge_into também
crbro_connect	Cria, fortalece, define a força de ou exclui (action=disconnect) uma conexão entre neurônios
crbro_context	Lê (sem argumentos) ou atualiza o contexto de trabalho ativo — tópicos, itens abertos, descartar ou limpar
crbro_map	Mantém um mapa vivo de como o sistema de um tópico funciona — substituído por inteiro, nunca corrigido
crbro_consolidate	Consolidação de fim de sessão — a única forma de registrar uma sessão; vincula os tópicos que escreveu e sincroniza espaços
crbro_maintenance	Manutenção do cérebro — calor, poda, integridade, repair, unarchive, reconstrução de índice
crbro_audit	Encontra credenciais armazenadas no cérebro, incluindo logs de sessão — informa o tipo, nunca o valor
crbro_secret	Coloca uma credencial no chaveiro do sistema operacional e mantém apenas o nome no cérebro
crbro_space	Cria, entra, sync ou leave um espaço de equipe — um repositório git privado para projetos compartilhados
crbro_share	Coloca um projeto em um espaço, após mostrar exatamente o que seria enviado; unshare para de segui-lo

Atualizando da versão 1.x

A 2.0 passou de 23 ferramentas para 15 sem tocar no cérebro em disco: um cérebro 1.x abre como está, e o índice de busca se reconstrói uma vez. As sete ferramentas de leitura viraram visualizações de crbro_inspect, o log de sessão vive apenas em crbro_consolidate, e crbro_sync agora é crbro_space action=sync. Os oito verbos que os cartões ensinam (boot, learn, recall, revise, forget, connect, context, consolidate) mantiveram seus nomes e seus parâmetros. crbro_boot retorna a tabela abaixo como retired_tools em cada chamada, então um modelo que aprendeu a superfície antiga encontra seu caminho sem ler a documentação; um cliente que chama um nome aposentado diretamente recebe o erro MCP "ferramenta desconhecida".

Aposentado	Use em vez disso
crbro_status	crbro_inspect view=status
crbro_neuron	crbro_inspect view=neuron neuron=<id or name>
crbro_neurons	crbro_inspect view=neurons [domain|type|min_heat|limit|offset]
crbro_hot_topics	crbro_inspect view=neurons (linhas) e view=status (hot_topics_recalculated)
crbro_connections	crbro_inspect view=neuron neuron=<id> [min_strength]
crbro_sessions	crbro_inspect view=sessions [limit]
crbro_global_map	crbro_inspect view=global_map
crbro_session_log	crbro_consolidate summary=... [topics_touched=[...]] — topics_touched registra ids de neurônios que você apenas leu (mais crbro_context set_topics=[...] para substituir os tópicos ativos)
crbro_sync	crbro_space action=sync [name]

Se você usa os hooks do Claude Code, remova mcp__crbro__crbro_session_log de qualquer correspondência em ~/.claude/settings.json e do texto de início de sessão: todo início de sessão ordenaria de outra forma uma chamada a uma ferramenta que não existe mais. Não pode migrar ainda? A 1.x continua instalável com npx -y crbro-memory@1; ela não recebe novos recursos. O que mudou internamente em cada ferramenta sobrevivente está em CHANGELOG.md.

Credenciais

Uma memória não deve guardar suas senhas, e o CRBRO se recusa a isso: qualquer coisa com forma de credencial é substituída por um marcador antes de chegar ao disco. Mas recusar por si só não ajuda muito — a senha ainda existe, e ela acaba de volta em um arquivo de configuração em texto puro.

Então crbro_secret dá a ela um lugar para ir: o armazenamento de credenciais que sua máquina já possui.

Plataforma	Onde o valor realmente vive
macOS	Keychain, via security
Linux	Secret Service, via secret-tool
Windows	Selado com DPAPI para sua conta Windows

Em uma máquina sem armazenamento de credenciais — um servidor headless, um runner de CI, um keychain bloqueado via SSH — crbro_secret diz isso em palavras simples em vez de falhar. Variáveis de ambiente continuam funcionando, e o resto do CRBRO é afetado.

O CRBRO não mantém cópia e não escreve criptografia própria. O armazenamento fica fora do cérebro, então nenhuma sincronização, nenhum espaço de equipe e nenhum crbro_share podem alcançá-lo. O que entra no cérebro é o nome:

"A senha do WordPress para example.com está em WP_EXAMPLE_APP_PASSWORD."

O que é tudo que um assistente precisa para encontrá-la novamente na próxima semana, e inútil para qualquer um que leia seus arquivos de memória.

Uma variável de ambiente com o mesmo nome sempre vence, então CI e substituições pontuais funcionam sem tocar no keychain. Em uma máquina headless sem armazenamento de credenciais, crbro_secret diz isso claramente em vez de falhar — as variáveis de ambiente ainda funcionam, e o resto do CRBRO é afetado.

Memória de equipe

Duas pessoas trabalhando na mesma coisa não deveriam ter que contar aos seus assistentes as mesmas coisas duas vezes. Um espaço é um ou mais projetos compartilhados com colegas de equipe, carregado por um repositório git privado que você possui — sem servidor, sem conta, nada para pagar.

# One person, once:
crbro_space  action: create   name: "team"   remote: git@github.com:acme/team-memory.git   author: "ana"
crbro_share  neuron: "project_x"   space: "team"

# Everyone else, once:
crbro_space  action: join     name: "team"   remote: git@github.com:acme/team-memory.git   author: "bruno"

Depois disso é invisível: notas são trocadas no início e no fim de cada sessão. O que cada pessoa aprende sobre aquele projeto, os assistentes dos outros sabem na próxima vez que se sentarem.

Como fica fora do seu caminho

• Ninguém nunca escreve no arquivo de outra pessoa. Cada pessoa adiciona ao seu próprio log e cada máquina reconstrói o projeto a partir de todos eles, então não há conflito para resolver — nem agora, nem depois de uma semana separados.
• Se alguém marca um fato como não mais verdadeiro, isso vence. Conhecimento retirado não pode voltar à vida porque uma cópia desatualizada ainda o chamava de atual.
• Nenhuma conexão é uma resposta normal, não um erro. Sua memória funciona offline e o que você salvou sai na próxima sincronização.

O que nunca sai da sua máquina

• Todo projeto que você não compartilhou explicitamente.
• Preferências — não compartilháveis de forma alguma, em qualquer configuração. São o campo mais provável de conter uma chave.
• Credenciais. crbro_share recusa terminantemente se encontrar uma, e diz a você onde. Não vai redigir e enviar o resto.

O que foi enviado permanece enviado. crbro_share unshare:true para de seguir um projeto — nenhuma nota sai mais e a próxima sincronização o ignora — mas uma vez que um colega o puxou, está no disco dele. Remover o acesso ao repositório deles impede que algo novo chegue até eles; não retira o que já têm. Isso é verdade para qualquer sistema de sincronização — vale saber antes de compartilhar, não depois.

Arquitetura

~/.crbro/
├── manifest.json           ← Brain metadata
├── cortex/                 ← One JSON per neuron (topic)
│   ├── project_octochat.json
│   └── tech_firebase.json
├── synapses/               ← One JSON per connection
│   └── syn_octochat__firebase.json
├── hippocampus/            ← One JSON per session
│   └── session_2026-05-06.json
├── prefrontal/             ← Working memory
│   ├── active_context.json
│   └── hot_topics.json     (the global map is computed live since 2.0, never stored)
├── .quarantine/            ← What crbro_forget removed, kept until you delete it
├── unshared.json           ← Projects you stopped following in a space (after an unshare)
├── archives/               ← Cold neurons (opt-in; nothing is archived unless you ask)
├── shared/                 ← One git repo per team space. Notes only, never the cortex
│   └── team/
│       └── neurons/project_x/ops/ana.a1b2c3.jsonl
└── .search/                ← Orama search index
    └── chunks.index.json   ← one document per fact

Algoritmo de Pontuação de Calor

Cada neurônio tem uma pontuação de calor (0.0 - 1.0) calculada a partir de:

• Frequência (35%) — Com que frequência o neurônio é acessado
• Recência (40%) — Quando foi acessado pela última vez (hoje = 1.0, >3 meses = 0.05)
• Conectividade (25%) — Quantas sinapses se conectam a ele

Minerador de Conhecimento

O minerador é um auxiliar opcional, totalmente local que escaneia um diretório em busca de arquivos .md e .txt (notas, documentos, diários) e extrai conhecimento para o cérebro — para que o CRBRO possa aprender com o que você já escreveu, não apenas com conversas. Ele nunca toca a rede e nunca sai da sua máquina.

npx crbro-memory mine [dir]       # One-shot scan of a directory
npx crbro-memory setup-miner      # Install a scheduled auto-scan (OS task scheduler)
npx crbro-memory miner-status     # Check the auto-miner status
npx crbro-memory remove-miner     # Remove the scheduled task

Nota de nomenclatura: "minerador" aqui significa mineração de conhecimento — extrair fatos dos seus próprios arquivos de texto. Nada a ver com criptomoeda.

Comandos CLI

npx crbro-memory          # Start MCP server (stdio)
npx crbro-memory init     # Initialize brain + detect IDEs
npx crbro-memory status   # Show brain status
npx crbro-memory reindex  # Rebuild the search index
npx crbro-memory eval     # Measure retrieval quality against your own query set
npx crbro-memory semantic status | install | build   # Semantic recall (installed by init; below)
npx crbro-memory --help   # Help

Recuperação semântica

O mecanismo de palavras-chave não tem sinônimos, e o benchmark cego mostra exatamente onde isso dói: paráfrases — "onde os sites estão hospedados" para um fato sobre um VPS Hetzner. Palavras-chave escritas no momento do salvamento fecham a maior parte dessa lacuna de graça (acima); um pequeno modelo de incorporação fecha um pouco mais. Desde 1.16 npx crbro-memory init o instala por padrão, uma vez por máquina, e a camada está ativa onde quer que seu runtime esteja presente. O que custa, medido: ~500 MB em disco (runtime ~380 MB + modelo 118 MB), ~0,5 GB de RAM enquanto um servidor roda, ~13 s de carregamento do modelo por processo (em segundo plano) e uma passagem única de incorporação. Pule com init --no-semantic; desligue a qualquer momento com CRBRO_SEMANTIC=0 no env do servidor.

npx crbro-memory init                 # installs it (skip with --no-semantic)
npx crbro-memory semantic status      # runtime, model, on or off, and why
npx crbro-memory semantic build       # embed an existing brain once (a 4k-line brain: ~3 min)

Cada nova linha é incorporada quando é salva (ids são hashes de conteúdo, então nada é incorporado duas vezes), o modelo aquece em segundo plano após a inicialização, e crbro_recall funde ambas as classificações por classificação recíproca. Resultados que os vetores classificaram carregam semantic_score; uma correspondência apenas por vetor é strong a partir de cosseno 0.86. Com CRBRO_SEMANTIC=0, ou sem o runtime, nenhum vetor é lido e nenhum modelo é carregado: a recuperação é o mecanismo de palavras-chave byte por byte.

O modelo é multilingual-e5-small e permanece assim de propósito. CRBRO_SEMANTIC_MODEL aceita qualquer modelo da família e5, e e5-base e e5-large foram medidos no mesmo benchmark: o grande é o melhor modelo sozinho (71% vs 63% recall@1) mas fundido com o mecanismo de palavras-chave ele pontua igual ou pior (75% / 85% vs 79% / 83%) por 4× o disco, 1,2 GB de RAM e 6× o tempo por linha. A tabela está em benchmarks/README.md.

O que ele compra no benchmark congelado, e o que não compra, está na tabela acima e em benchmarks/README.md — incluindo o fato de que o piso de cosseno 0.84 foi escolhido nesse mesmo conjunto. Um limite que vale saber antes de instalar 500 MB: o modelo não entende a pergunta. Consultas que não compartilham nenhuma palavra concreta com a linha armazenada ("qual máquina serve as páginas" para um fato sobre um VPS Hetzner) caem em uma faixa plana de cosseno 0.80–0.84 com ordenação quase aleatória — medido, e a razão pela qual o piso existe. O que ele adiciona é tolerância à variação de vocabulário e a entidades, que é de onde vem o ganho do benchmark.

Medindo a recuperação

eval está lá para você distinguir uma correção de uma sensação. Escreva ~/.crbro/.eval/queries.json como uma lista de perguntas que você realmente faria, cada uma nomeando o neurônio que deveria respondê-la:

[
  { "query": "how we deploy the api",
    "expect_neuron": "project_octochat",
    "expect_contains": "Cloud Run" }
]

Então npx crbro-memory eval informa com que frequência o neurônio certo volta primeiro, com que frequência ele entra no top três, e MRR — além de cada erro, para que você possa ver o que ele errou em vez de adivinhar.

Licença

MIT — veja LICENSE. Construído por Octonove.