CRBRO

Memoria local persistente para agentes de IA: hechos almacenados como archivos JSON en tu máquina, con un ciclo de vida explícito de reemplazo y retiro para que una memoria desactualizada deje de servirse.

GitHub

Prueba este MCPPatrocinado

Documentación

🧠 CRBRO — Memoria Neural Persistente para IA

CRBRO es un servidor MCP (Protocolo de Contexto de Modelo) local que le da a tu asistente de IA memoria a largo plazo persistente entre sesiones. Utiliza una arquitectura neuronal biológica — corteza, sinapsis, hipocampo — para almacenar, conectar y recuperar conocimiento automáticamente.

CRBRO demo

Gratis y de código abierto (MIT). Las 15 herramientas incluidas — sin licencia, sin cuenta, sin niveles.

⭐ Si CRBRO le da a tu IA una memoria que vale la pena conservar, una estrella en GitHub es la mejor manera de apoyarlo.

Características

🧬 Arquitectura Biológica — Conocimiento organizado como neuronas (corteza), conexiones (sinapsis) y memoria de sesión (hipocampo)
🔍 Búsqueda a Nivel de Hecho — Impulsada por Orama. Cada hecho se indexa por separado, por lo que un tema con cientos de hechos sigue siendo tan localizable como uno con tres. Cada resultado incluye la línea exacta que coincidió, cuándo se registró, una etiqueta confidence (weak = poca parte de la pregunta fue cubierta) y, para los mejores resultados, las siguientes mejores líneas del tema. Una tabla breve de sinónimos bilingües amplía la pregunta sin inventar términos (v1.13+)
🗣️ El modelo en el circuito — Dos palancas que ningún modelo de incrustación reemplaza, medidas a ciegas: palabras clave escritas al guardar (quien llama conoce los sinónimos: una línea sobre Hetzner obtiene hosting, alojamiento, servidor) y varias frases buscadas a la vez, fusionadas por rango. Cero disco, cero RAM; números en la tabla a continuación (v1.15+)
🧭 Recuerdo semántico — npx crbro-memory init instala un modelo de incrustación local (multilingual-e5-small, int8) fusionado con el motor de palabras clave, para que las paráfrasis que las palabras no cubren comiencen a aterrizar. Medido: +8 puntos de recall@1 sobre el motor de palabras clave, +2 a +5 además de las palabras clave al guardar. Cuesta ~500 MB en disco una vez por máquina y ~0.5 GB de RAM mientras un servidor se ejecuta; init --no-semantic lo omite, CRBRO_SEMANTIC=0 lo desactiva (v1.14+, instalado por defecto desde v1.16)
🔥 Puntuaciones de Calor — Seguimiento automático de relevancia basado en frecuencia, actualidad y conectividad. Los temas escritos en la misma sesión se vinculan en la consolidación, por lo que el grafo se completa solo (v1.13+)
✏️ Corregible — El conocimiento puede ser reemplazado o retractado, no solo acumulado — hechos, y desde 2.0 decisiones, patrones, errores y deudas también. Una memoria que solo añade sigue sirviendo la respuesta de ayer con la confianza de hoy. Lo retirado permanece en el archivo y puede volver (status=active); lo que no debe existir en disco pasa por crbro_forget, copia de cuarentena primero
🔐 Consciente de Credenciales — Claves API, tokens y contraseñas se reemplazan con un marcador antes de tocar el disco. La oración a su alrededor sobrevive; el secreto no — y crbro_secret pone el valor real en el llavero del propio sistema operativo, para que negarse no te deje sin dónde ponerlo
👥 Seguro con dos editores abiertos — Las escrituras se serializan por neurona, por lo que ejecutar CRBRO en dos IDEs a la vez no pierde hechos silenciosamente
🤝 Compartible por proyecto — Pon un proyecto en un espacio de equipo y se mantiene sincronizado en las máquinas de todos. Todo lo demás en tu cerebro nunca sale de él
🗺️ Mapas Vivos — Cada tema puede llevar un mapa siempre actualizado de cómo funciona su sistema (crbro_map), reemplazado por completo en cada cambio — además de un mapa global de clústeres y puentes entre dominios
📓 Registro de Errores — type: "error" almacena cada error real CON su corrección, en el tema donde ocurrió, para que el mismo error no se cometa dos veces. Con fecha desde 1.13, por lo que la corrección más reciente gana en el recuerdo
⚖️ Registro de Deudas — type: "debt" registra lo que deliberadamente NO construiste — con techo y disparador de revisión incluidos — para que las ideas muertas dejen de proponerse de nuevo (v1.11+)
🏷️ Definiciones de herramientas honestas — Cada herramienta lleva anotaciones MCP (readOnlyHint, destructiveHint, idempotentHint, openWorldHint), un título y, para los lectores, un esquema de salida — para que un cliente sepa qué lee, qué escribe y qué puede destruir antes de llamar (v1.13+)
🧰 15 herramientas, un ciclo de vida — Cada lectura es una vista de crbro_inspect; crbro_learn, crbro_revise y crbro_forget son las tres etapas de una regla (una verdad nueva reemplaza a la antigua, una desactualizada se retira, una peligrosa se elimina), y cada descripción dice en su primera frase si lee o escribe y qué vecino hace el trabajo adyacente. Reducido de 23 en 1.x sin tocar el cerebro en disco; crbro_boot mapea los nombres antiguos a las nuevas llamadas (v2.0+)
🛡️ Gancho de Subagente (opt-in) — npx crbro-memory install-hooks --inject conecta un gancho de Claude Code que entrega tus protocolos de comportamiento a los subagentes generados. La inyección está desactivada por defecto desde 1.12 — tres ejecuciones de referencia de control limpio no encontraron beneficio medido en ningún modelo y daño real en los pequeños, y enviar un valor predeterminado no medido no es lo que este proyecto hace
⛏️ Minero de Conocimiento — Opcionalmente escanea tus notas locales de .md/.txt y las alimenta al cerebro
🔒 Totalmente Local — Se ejecuta solo con Node.js: sin Python, sin Docker, sin bases de datos, sin servicios externos. Tu memoria nunca sale de tu máquina. La única descarga es el modelo de incrustación en init, desde Hugging Face, una vez por máquina; nada llama hacia afuera después
💾 Basado en Archivos — Todos los datos se almacenan como archivos JSON legibles en ~/.crbro/ — inspeccionables, comparables y versionables con git
🔌 Nativo MCP — Funciona con Claude Desktop, Claude Code, Cursor, Windsurf y cualquier cliente compatible con MCP

Medido, no prometido

Cada número a continuación proviene de un punto de referencia determinista en benchmarks/ que se ejecuta en CI — sin llamadas API, reproducible en tu máquina con node benchmarks/<name>/run.mjs. Los poco favorecedores se publican a propósito.

Qué	Resultado	La parte honesta
Recuperación (48 consultas parafraseadas a ciegas, escritas por alguien que nunca vio el texto almacenado)	recall@1 71% · recall@3 77% · MRR 0.74 — y 79% / 85% contando las líneas `also_matched` de la neurona	Era 56% / 69% en 1.12. De los 13 fallos, 8 fueron la neurona correcta respondiendo con la línea incorrecta (su fragmento de nombre, o un hecho hermano) — corregido en el motor; el resto son brechas de vocabulario, que una tabla breve de sinónimos bilingües ahora cierra en parte. Una búsqueda ingenua de subcadenas puntúa 38% / 58%. Aún sin modelo semántico: los fallos restantes se enumeran en la salida del punto de referencia
Recuperación con la capa semántica (mismas 48 consultas)	recall@1 79% · recall@3 83% · MRR 0.81 — 88% / 92% contando `also_matched`	Vectores de `multilingual-e5-small` (int8) fusionados con BM25 por rango recíproco. Solo, el modelo puntúa 60% / 83%; fusionado, añade 8 puntos en recall@1 y ningún señuelo alcanza la puntuación de un acierto real (0 de 14; 12 devuelven algo, 11 de ellos etiquetados `weak`). El suelo de coseno bajo el cual un candidato solo-vector se descarta (0.84) se eligió en este mismo conjunto — un número ajustado, no ciego. Cuesta ~500 MB en disco, ~0.5 GB de RAM mientras el servidor se ejecuta, una pasada de incrustación única (~3 min para un cerebro de 4k líneas) y ~13 s de carga del modelo por proceso. Instalado por `init` desde 1.16; `CRBRO_SEMANTIC=0` lo desactiva (v1.14+)
Recuperación con el modelo en el circuito (mismas 48 consultas; palabras clave y reescrituras escritas a ciegas por un modelo que vio solo la mitad de la prueba)	solo palabras clave: recall@1 83% · recall@3 90% — todo activado (palabras clave + reescrituras + capa semántica): 90% / 92%, y 96% / 98% contando `also_matched`	La palanca más grande no cuesta nada: 2-5 palabras clave escritas cuando se guarda un hecho cierran exactamente las brechas que ningún modelo de incrustación cerró. Las reescrituras solas apenas mueven el motor de palabras clave (71% → 71% / 79%); se acumulan además de las palabras clave. Cada configuración y las tres preguntas aún falladas están en `benchmarks/README.md` (v1.15+)
Recuperación — falsa confianza (14 preguntas sobre cosas que NO están almacenadas)	11 devuelven algo; 2 a la puntuación de un acierto real; 10 de 11 etiquetados `weak`	Una memoria de palabras clave responde casi cualquier cosa. Cada resultado ahora lleva `confidence`, y la etiqueta atrapa casi todos los señuelos — al precio de también llamar débiles a 18 de 48 aciertos reales. Débil significa "poca parte de la pregunta fue cubierta", no "incorrecto"
Redacción de secretos (20 credenciales en disfraces adversariales, 19 inocentes casi-acertados)	100% detectados · 0% falsos positivos	100% en este conjunto congelado — un piso, no una prueba de seguridad. El conjunto crece a medida que aparecen nuevas formas de evasión; cuatro de sus entradas fueron fallos en la primera ejecución y se corrigieron, no se ocultaron
Costo (lo que CRBRO añade a una sesión)	~750 tokens al arrancar · ~6.5k tokens de definiciones de herramientas · <1 ms de recuperación local sobre 300 hechos	El bloque de arranque se paga una vez. Las 15 definiciones de herramientas (25,866 caracteres de descripción + esquema de entrada, medidos con un `tools/list` real y divididos por 4; 34,047 contando los esquemas de salida de los tres lectores, ~8.5k tokens) se pagan en cada solicitud por los clientes que cargan todas las herramientas (Claude Desktop, Cursor); Claude Code las difiere y paga solo por las que usa. Menos herramientas, no menos caracteres: las 23 de 1.13 midieron 21,662 (~5.4k tokens), porque el texto de cada parámetro ahora vive en la herramienta que lo absorbió

Lo que estos puntos de referencia deliberadamente no afirman — productividad humana, "te conoce", comparaciones con otros sistemas de memoria — está escrito en benchmarks/LIMITS.md.

Inicio Rápido

1. Inicializar

Crea el cerebro en ~/.crbro/ y, desde 1.16, instala el recuerdo semántico: un modelo de incrustación local, ~500 MB una vez por máquina, unos minutos. Añade --no-semantic para omitirlo.

npx crbro-memory init

2. Añadir a tu configuración MCP

Registra CRBRO a nivel de usuario, no por proyecto. Tu cerebro vive en ~/.crbro/ y se comparte en cada carpeta — pero si registras el servidor dentro de un solo proyecto, otras carpetas no tendrán las herramientas y parecerá que la memoria se ha ido. El registro a nivel de usuario lo hace disponible en todas partes, que es el punto principal.

Claude Code (un comando, disponible en cada carpeta):

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 — el de tu carpeta de inicio, no el .cursor/ de un proyecto):

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

Docker (el cerebro vive en /root/.crbro; monta un volumen para conservarlo. La imagen no lleva runtime semántico, por lo que el recuerdo es solo de palabras clave allí):

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

3. Comienza a usarlo

Tu IA ahora tendrá acceso a 15 herramientas de memoria. Inicia cualquier sesión con crbro_boot.

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

npx crbro-memory install-hooks --inject

El contexto de sesión nunca llega a los subagentes generados por Task, por lo que este gancho puede inyectar el mismo bloque de protocolo que crbro_boot carga — una única fuente de verdad, construida para nunca bloquear una sesión (cualquier fallo degrada a un conjunto de reglas de respaldo y sale limpiamente).

La inyección es opt-in desde 1.12, y la razón es medida, no cautelosa. Tres ejecuciones de referencia con controles verificados limpios, jueces ciegos y umbrales pre-registrados encontraron: modelos frontera en un techo perfecto en cada sonda agéntica medible con o sin el bloque (nada que añadir); modelos pequeños en tareas de un solo disparo dañados por él (disciplina de alcance 10/10 sin vs 0/10 con inyección); y en modo agéntico el único comportamiento diferencial fue contra — agentes de modelos pequeños CON el bloque manipularon una suite de pruebas fallida e informaron éxito 2/5 veces, 0/5 sin él. Un valor predeterminado que no compra comportamiento medido y puede inducir cumplimiento fabricado no es un valor predeterminado que este proyecto envíe. Si lo habilitas, delimítalo con CRBRO_SUBAGENT_MATCHER y mantén a los subagentes de modelos pequeños fuera.

Herramientas

Herramienta	Descripción
`crbro_boot`	Inicia el cerebro al comienzo de la sesión: carga temas candentes, contexto, las últimas tres sesiones y el mapa `retired_tools`
`crbro_inspect`	Vistas de solo lectura por id o nombre: `view=status`, `neuron`, `neurons`, `sessions`, `global_map`
`crbro_learn`	Almacena un hecho, decisión, patrón, preferencia, error o deuda, con las palabras clave que una pregunta futura pueda usar. `supersedes` retira la versión anterior en la misma llamada
`crbro_recall`	Busca en cada línea almacenada, no solo en los nombres de los temas: devuelve qué coincidió, con qué confianza y las siguientes mejores líneas del tema. Varias formulaciones a la vez se fusionan por rango
`crbro_revise`	Retira hechos (y decisiones, patrones, errores, deudas mediante `entries`) como superados o retractados, los reactiva con `status=active` y edita resumen, dominio, etiquetas o nombre
`crbro_forget`	Elimina definitivamente, guardando primero una copia en `.quarantine/`: entradas de una neurona, una neurona completa (en dos pasos con `confirm_token`), un registro de sesión; también `restore` y `merge_into`
`crbro_connect`	Crea, fortalece, establece la fuerza de o elimina (`action=disconnect`) una conexión entre neuronas
`crbro_context`	Lee (sin argumentos) o actualiza el contexto de trabajo activo: temas, elementos abiertos, descartar o limpiar
`crbro_map`	Mantiene un mapa vivo de cómo funciona el sistema de un tema: se reemplaza por completo, nunca se parchea
`crbro_consolidate`	Consolidación al final de la sesión: la única forma de registrar una sesión; vincula los temas que escribió y sincroniza espacios
`crbro_maintenance`	Mantenimiento del cerebro: calor, poda, integridad, `repair`, `unarchive`, reconstrucción del índice
`crbro_audit`	Encuentra credenciales almacenadas en el cerebro, incluidos los registros de sesión: informa el tipo, nunca el valor
`crbro_secret`	Coloca una credencial en el llavero del sistema operativo y guarda solo su nombre en el cerebro
`crbro_space`	Crea, únete, `sync` o `leave` un espacio de equipo: un repositorio git privado para proyectos compartidos
`crbro_share`	Coloca un proyecto en un espacio, después de mostrar exactamente qué se enviaría; `unshare` deja de seguirlo

Actualización desde 1.x

2.0 pasó de 23 herramientas a 15 sin tocar el cerebro en disco: un cerebro de 1.x se abre tal cual, y el índice de búsqueda se reconstruye solo una vez. Las siete herramientas de lectura se convirtieron en vistas de crbro_inspect, el registro de sesión vive solo en crbro_consolidate, y crbro_sync ahora es crbro_space action=sync. Los ocho verbos que enseñan las tarjetas (boot, learn, recall, revise, forget, connect, context, consolidate) conservaron sus nombres y sus parámetros. crbro_boot devuelve la tabla siguiente como retired_tools en cada llamada, de modo que un modelo que aprendió la superficie anterior encuentre su camino sin leer la documentación; un cliente que llame directamente a un nombre retirado recibe el error MCP de "herramienta desconocida".

Retirada	Usar en su lugar
`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` (filas) y `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 los ids de neuronas que solo lees (además de `crbro_context set_topics=[...]` para reemplazar los temas activos)
`crbro_sync`	`crbro_space action=sync [name]`

Si usas los hooks de Claude Code, elimina mcp__crbro__crbro_session_log de cualquier matcher en ~/.claude/settings.json y del texto de inicio de sesión: de lo contrario, cada inicio de sesión ordenaría una llamada a una herramienta que ya no existe. ¿No puedes migrar aún? 1.x sigue instalable con npx -y crbro-memory@1; no recibe nuevas funciones. Lo que cambió dentro de cada herramienta superviviente está en CHANGELOG.md.

Credenciales

Una memoria no debería contener tus contraseñas, y CRBRO se niega a hacerlo: cualquier cosa con forma de credencial se reemplaza con un marcador antes de llegar al disco. Pero negarse por sí solo no ayuda mucho: la contraseña sigue existiendo y termina de nuevo en un archivo de configuración en texto plano.

Así que crbro_secret le da un lugar al que ir: el almacén de credenciales que tu máquina ya incluye.

Plataforma	Dónde vive realmente el valor
macOS	Llavero, mediante `security`
Linux	Secret Service, mediante `secret-tool`
Windows	Sellado con DPAPI a tu cuenta de Windows

En una máquina sin almacén de credenciales (un servidor sin interfaz gráfica, un runner de CI, un llavero bloqueado por SSH), crbro_secret lo dice en palabras claras en lugar de fallar. Las variables de entorno siguen funcionando y el resto de CRBRO no se ve afectado.

CRBRO no guarda copias ni escribe criptografía propia. El almacén está fuera del cerebro, así que ninguna sincronización, espacio de equipo ni crbro_share puede alcanzarlo. Lo que entra en el cerebro es el nombre:

"La contraseña de WordPress para example.com está en WP_EXAMPLE_APP_PASSWORD."

Que es todo lo que un asistente necesita para encontrarla de nuevo la próxima semana, e inútil para cualquiera que lea tus archivos de memoria.

Una variable de entorno con el mismo nombre siempre gana, así que CI y anulaciones puntuales funcionan sin tocar el llavero. En una máquina sin interfaz gráfica y sin almacén de credenciales, crbro_secret lo dice claramente en lugar de fallar: las variables de entorno siguen funcionando y el resto de CRBRO no se ve afectado.

Memoria de equipo

Dos personas trabajando en lo mismo no deberían tener que decirle a sus asistentes las mismas cosas dos veces. Un espacio es uno o más proyectos compartidos con compañeros, transportado por un repositorio git privado que tú posees: sin servidor, sin cuenta, nada que 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"

Después de eso es invisible: las notas se intercambian al inicio y al final de cada sesión. Lo que cada persona aprende sobre ese proyecto, los asistentes de los demás lo saben la próxima vez que se sientan.

Cómo se mantiene fuera de tu camino

Nadie escribe jamás en el archivo de otro. Cada persona añade a su propio registro y cada máquina reconstruye el proyecto a partir de todos ellos, así que no hay conflicto que resolver, ni ahora ni después de una semana de distancia.
Si alguien marca un hecho como ya no verdadero, eso gana. El conocimiento retractado no puede volver a la vida porque una copia obsoleta todavía lo llamara actual.
Ninguna conexión es una respuesta normal, no un error. Tu memoria funciona sin conexión y lo que guardes sale en la siguiente sincronización.

Lo que nunca sale de tu máquina

Cada proyecto que no compartiste explícitamente.
Preferencias: no se pueden compartir en absoluto, en ningún ajuste. Son el campo con más probabilidades de contener una clave.
Credenciales. crbro_share se niega rotundamente si encuentra una y te dice dónde. No la redactará y enviará el resto.

Lo que se envió, se envió. crbro_share unshare:true deja de seguir un proyecto: no salen más notas y la siguiente sincronización lo ignora, pero una vez que un compañero lo ha extraído, está en su disco. Quitar su acceso al repositorio detiene que llegue algo nuevo; no recupera lo que ya tienen. Eso es cierto en cualquier sistema de sincronización: vale la pena saberlo antes de compartir, no después.

Arquitectura

~/.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 puntuación de calor

Cada neurona tiene una puntuación de calor (0.0 - 1.0) calculada a partir de:

Frecuencia (35%) — Con qué frecuencia se accede a la neurona
Recencia (40%) — Cuándo se accedió por última vez (hoy = 1.0, >3 meses = 0.05)
Conectividad (25%) — Cuántas sinapsis se conectan a ella

Minero de conocimiento

El minero es un asistente opcional, totalmente local que escanea un directorio en busca de archivos .md y .txt (notas, documentos, diarios) y extrae conocimiento al cerebro, para que CRBRO pueda aprender de lo que ya escribiste, no solo de conversaciones. Nunca toca la red y nunca sale de tu 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 sobre el nombre: "minero" aquí significa minería de conocimiento: extraer hechos de tus propios archivos de texto. No tiene nada que ver con criptomonedas.

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

Recuperación semántica

El motor de palabras clave no tiene sinónimos, y el benchmark ciego muestra exactamente dónde duele: paráfrasis — "dónde están alojados los sitios" para un hecho sobre un VPS de Hetzner. Las palabras clave escritas al guardar cierran la mayor parte de esa brecha de forma gratuita (arriba); un pequeño modelo de embeddings cierra un poco más. Desde 1.16 npx crbro-memory init lo instala por defecto, una vez por máquina, y la capa está activa dondequiera que su runtime esté presente. Lo que cuesta, medido: ~500 MB en disco (runtime ~380 MB + modelo 118 MB), ~0.5 GB de RAM mientras un servidor corre, ~13 s de carga del modelo por proceso (en segundo plano) y una pasada de embedding única. Omítelo con init --no-semantic; apágalo en cualquier momento con CRBRO_SEMANTIC=0 en el entorno del 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 nueva línea se embebe cuando se guarda (los ids son hashes de contenido, así que nada se embebe dos veces), el modelo se calienta en segundo plano después del arranque, y crbro_recall fusiona ambos rankings por rango recíproco. Los resultados que los vectores clasificaron llevan semantic_score; una coincidencia solo por vectores es strong desde coseno 0.86. Con CRBRO_SEMANTIC=0, o sin el runtime, no se leen vectores y no se carga ningún modelo: la recuperación es el motor de palabras clave byte por byte.

El modelo es multilingual-e5-small y sigue siéndolo a propósito. CRBRO_SEMANTIC_MODEL acepta cualquier modelo de la familia e5, y e5-base y e5-large se midieron en el mismo benchmark: el grande es el mejor modelo por sí solo (71% vs 63% recall@1) pero fusionado con el motor de palabras clave puntúa igual o peor (75% / 85% vs 79% / 83%) por 4× el disco, 1.2 GB de RAM y 6× el tiempo por línea. La tabla está en benchmarks/README.md.

Lo que compra en el benchmark congelado, y lo que no, está en la tabla anterior y en benchmarks/README.md — incluido el hecho de que el piso de coseno 0.84 se eligió en ese mismo conjunto. Un límite que vale la pena conocer antes de instalar 500 MB: el modelo no entiende la pregunta. Las consultas que no comparten ninguna palabra concreta con la línea almacenada ("qué máquina sirve las páginas" para un hecho sobre un VPS de Hetzner) caen en una banda plana de coseno 0.80–0.84 con orden casi aleatorio — medido, y la razón por la que existe el piso. Lo que añade es tolerancia a la variación de vocabulario y a las entidades, que es de donde viene la ganancia del benchmark.

Medición de la recuperación

eval está ahí para que puedas distinguir una corrección de una sensación. Escribe ~/.crbro/.eval/queries.json como una lista de preguntas que realmente harías, cada una nombrando la neurona que debería responderla:

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

Luego npx crbro-memory eval informa con qué frecuencia la neurona correcta vuelve primero, con qué frecuencia entra en los tres primeros y MRR — además de cada fallo, para que puedas ver qué salió mal en lugar de adivinar.

Licencia

MIT — ver LICENSE. Construido por Octonove.