Hanzo Brain: el grafo de conocimiento que el agente tiene primero en la computadora

Su agente es inteligente, pero se le olvida todo. Eso ya lo arreglamos. Hoy lanzamos Hanzo Brain — un solo binario, un solo archivo SQLite en ~/.hanzo/brain/brain.db, y la misma superficie de algoritmos en TypeScript, Python, Rust, Go y C++. Suelten un archivo markdown en ~/.hanzo/workspace/. El cerebro lo ingiere, extrae aristas tipadas e indexa el contenido para búsqueda híbrida. No se llama a ningún LLM. El grafo se va sumando.

Esta es la capa de memoria de cada runtime de Hanzo — el bot, el servidor MCP, el Hanzo Node y lo que ustedes embeben en su propio host.

Qué es el cerebro

El cerebro son tres cosas en un mismo proceso:

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

Las páginas ganan un índice FTS5. Las aristas ganan una clave primaria sobre (source, target, type). Los hechos ganan un id y una marca de tiempo. El esquema es tan corto que cabe 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 honra. Cada runtime escribe un archivo idéntico byte por byte.

Por qué la extracción sin LLM importa

Los extractores basados en LLM queman tokens, latencia y dinero en cada escritura. Generan deriva entre corridas. Vuelven el grafo no determinista.

El cerebro extrae las aristas con regex e inferencia de rol al momento de escribir. Es rápido, sale gratis y produce las mismas aristas siempre, con la misma entrada. Cuando ingieren «Alice fundó Acme. Ella invirtió en Foobar», obtienen:

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

Siempre. En cada runtime. Sin viaje de ida y vuelta.

Si quieren enriquecimiento con LLM encima — desambiguar entidades, verificar afirmaciones, resumir — llaman a su modelo encima del grafo determinista. El grafo es el sustrato. El LLM es el acabado opcional.

Un archivo. Cada runtime.

El mismo brain.db abre en TypeScript, Python, Rust, Go y C++. Sin traducir el formato, sin migración. Si escriben desde hanzobot/go en un servidor y leen desde @hanzo/bot-memory en un worker del navegador, leen el archivo que escribió el servidor.

Capacidad	TS	Python	Rust	Go	C++
Interfaz de BrainStore	sí	sí	sí	sí	sí
SQLite (predeterminado)	sí	sí	sí	sí	sí
Búsqueda híbrida con 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 conectables	sí	sí	sí	sí	sí

Totales de tests entre runtimes en el lanzamiento: 121 TS + 53 Python + 58 Go + 38 Rust (mcp) + 38 Rust (node) + 98 C++ = 406 tests, todos en verde. Cada runtime trae 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 que alguna vez se afirmó sobre una entidad, con marcas de tiempo.
• brain.search <query> — FTS híbrido más vector, fusionados 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 armado sobre hanzobot/* recibe estas herramientas gratis. Sin sidecar, sin servicio extra, sin una base de datos aparte para operar.

Para el camino 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, embebido adentro de hanzo-mcp:

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

Almacenamiento conectable, el mismo contrato

SQLite es el predeterminado. Alcanza para las primeras cien mil páginas en una computadora portátil. Cuando se les queda chico, registran otro backend sin cambiar el código de la aplicación:

Backend	En qué caso
sqlite	uso individual, < 100K páginas
qdrant	ANN de vectores a escala
meilisearch	FTS de palabras clave a escala
zapdb	store nativo canónico y multilingüe
replicate	WAL de SQLite streameado a S3 para backup
vfs	sistema de archivos de bloques en streaming sobre S3, tamaño sin límite
postgres	deploys de equipo multitenant

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 sostiene.

Memoria que se compone

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

A eso le llamamos memoria que se compone. El grafo crece. El modelo sale más barato. El usuario ve un asistente que se acuerda.

Llévense el cerebro

• Canon de TypeScript (viene 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 workspace de hanzoai/node y de hanzoai/mcp
• C++: solo encabezados en hanzobot/cpp/include/hanzo/brain/

Código: github.com/hanzoai/brain. Licencia: MIT.

---

Un archivo. Cinco tiempos de ejecución. Cero llamadas al LLM en las operaciones del grafo. Local primero, a propósito.