Hanzo Brain: grafo de conocimiento que vive primero en local, para agentes

Tu agente es listo, pero olvidadizo. Eso ya está arreglado. Hoy publicamos Hanzo Brain — un único binario, un único fichero SQLite en ~/.hanzo/brain/brain.db, y la misma superficie de algoritmos en TypeScript, Python, Rust, Go y C++. Deja un fichero markdown en ~/.hanzo/workspace/. El cerebro lo ingiere, extrae aristas tipadas e indexa el contenido para una recuperación híbrida. No se llama a ningún LLM. El grafo se acumula.

Esta es la capa de memoria de cada entorno de ejecución de Hanzo — el bot, el servidor MCP, el Hanzo Node y cualquier cosa que incrustes en tu propio host.

Qué es el cerebro

El cerebro son tres cosas en un solo proceso:

1. Páginas — contenido con dirección por slug, escrito desde cualquier sitio, vigilado en disco.
2. Aristas — relaciones tipadas (mentions, attended, works_at, invested_in, founded, advises) extraídas en cada escritura por regex e inferencia de rol. Cero LLM.
3. Hechos — tuplas (subject, predicate, object, ts, confidence) consultables en tiempo real entre sesiones.

Las páginas reciben un índice FTS5. Las aristas reciben una clave primaria sobre (source, target, type). Los hechos reciben un id y una marca de tiempo. El esquema es lo bastante corto como para tenerlo en la cabeza:

CREATE TABLE pages (slug TEXT PRIMARY KEY, content TEXT, frontmatter TEXT, updated_at TEXT);
CREATE VIRTUAL TABLE pages_fts USING fts5(content, content='pages', content_rowid='rowid');
CREATE TABLE edges (source TEXT, target TEXT, type TEXT, evidence TEXT, PRIMARY KEY (source, target, type));
CREATE TABLE facts (id TEXT PRIMARY KEY, subject TEXT, predicate TEXT, object TEXT, source TEXT, ts TEXT, confidence REAL);

Ese es todo el contrato. Cada backend lo cumple. Cada entorno de ejecución escribe un fichero idéntico byte a byte.

Por qué importa la extracción sin LLM

Los extractores basados en LLM queman tokens, latencia y dinero en cada escritura. Producen deriva entre ejecuciones. Hacen el grafo no determinista.

El cerebro extrae las aristas con regex e inferencia de rol en el momento de escribir. Es rápido, es gratis y produce las mismas aristas cada vez, dado el mismo texto. Cuando ingieres «Alice fundó Acme. Ella invirtió en Foobar», obtienes:

people/alice -[founded]->     companies/acme
people/alice -[invested_in]-> companies/foobar

Cada vez. En cada entorno de ejecución. Sin ida y vuelta.

Si quieres enriquecimiento con LLM encima — desambiguación de entidades, verificación de afirmaciones, resumen — llamas a tu modelo encima del grafo determinista. El grafo es el sustrato. El LLM es el remate opcional.

Un fichero. Cada entorno de ejecución.

El mismo brain.db se abre en TypeScript, Python, Rust, Go y C++. Sin traducción de formato, sin migración. Si escribes desde hanzobot/go en un servidor y lees desde @hanzo/bot-memory en un worker del navegador, lees el fichero que escribió el servidor.

Función	TS	Python	Rust	Go	C++
Interfaz BrainStore	sí	sí	sí	sí	sí
SQLite (por defecto)	sí	sí	sí	sí	sí
Búsqueda híbrida FTS5	sí	sí	trait	sí	sí
Extractor de enlaces del grafo	sí	sí	sí	sí	sí
Cargador de recetas	sí	sí	sí	sí	sí
Backends enchufables	sí	sí	sí	sí	sí

Totales de pruebas entre entornos en el lanzamiento: 121 TS + 53 Python + 58 Go + 38 Rust (mcp) + 38 Rust (node) + 98 C++ = 406 pruebas, todas en verde. Cada entorno entrega la misma fusión, el mismo rerank (MMR), el mismo RRF, la misma normalización de slugs y el mismo extractor de aristas.

Consultable desde MCP

El cerebro se expone por MCP como tres herramientas:

• brain.recall <entity> — cada hecho jamás afirmado sobre una entidad, con marcas de tiempo.
• brain.search <query> — FTS híbrido más vector, fusionado con RRF, con rerank MMR opcional.
• brain.ingest <slug> <content> — escribe una página, extrae aristas solo y actualiza el FTS.

Cada agente que habla con un Hanzo Node, con el servidor MCP de Hanzo o con un bot construido sobre hanzobot/* recibe estas herramientas gratis. Sin sidecar, sin servicio extra, sin una base de datos aparte que operar.

Para la vía del binario único de Go:

go install github.com/hanzobot/go/cmd/hanzo-bot@latest

hanzo-bot brain init                  # opens ~/.hanzo/brain/brain.db
hanzo-bot brain ingest people/alice.md
hanzo-bot brain recall people/alice
hanzo-bot brain search "founded"

Para Python:

from hanzo_memory.graph_links import extract_edges
edges = extract_edges(slug="people/alice", content="Alice founded Acme.")

Para Rust, incrustado dentro de hanzo-mcp:

use hanzo_mcp::brain::{extract_edges, slugify};
let edges = extract_edges("people/alice", "Alice is CEO of Acme.", Some("person"));

Almacenamiento enchufable, el mismo contrato

SQLite es el valor por defecto. Basta para las primeras cien mil páginas en un ordenador portátil. Cuando te quedes corto, registras otro backend sin cambiar el código de la aplicación:

Backend	Cuándo
sqlite	en solitario, < 100K páginas
qdrant	ANN vectorial a escala
meilisearch	FTS por palabras clave a escala
zapdb	almacén nativo canónico y multilingüe
replicate	WAL de SQLite volcado a S3 como copia de seguridad
vfs	sistema de ficheros de bloques en streaming sobre S3, tamaño ilimitado
postgres	despliegues de equipo multiinquilino

Para una semántica distribuida con forma de SQLite entre varias máquinas usamos transporte ZAP, consenso Quasar y zapdb. El cerebro sigue igual. El contrato de bytes que entran y bytes que salen se mantiene.

Memoria que se acumula

El sentido del cerebro no es una base de datos. Es el cambio de supuesto. Tu agente no empieza cada sesión en blanco. El markdown que escribiste hace un año ya es un grafo. Las conversaciones de ayer han producido aristas y hechos que la sesión de hoy puede consultar sin pagar tokens por ello. Dos agentes en dos máquinas pueden compartir brain.db por replicate y converger en la misma vista.

A eso nos referimos con memoria que se acumula. El grafo crece. El modelo sale más barato. El usuario ve un asistente que recuerda.

Consigue el cerebro

• Canon de TypeScript (se entrega con el bot): npm install -g @hanzo/bot && hanzo-bot serve
• Python: pip install hanzo-memory
• Binario único de Go: go install github.com/hanzobot/go/cmd/hanzo-bot@latest
• Rust: miembro del espacio de trabajo de hanzoai/node y de hanzoai/mcp
• C++: solo cabeceras en hanzobot/cpp/include/hanzo/brain/

Fuente: github.com/hanzoai/brain. Licencia: MIT.

---

Un fichero. Cinco entornos de ejecución. Cero llamadas al LLM para las operaciones del grafo. Primero en local, por diseño.