Hanzo Brain: grafo de conhecimento local-first para agentes

O seu agente é esperto, mas esquecido. A gente resolveu isso. Hoje lançamos o Hanzo Brain — um único binário, um único arquivo SQLite em ~/.hanzo/brain/brain.db, e a mesma superfície de algoritmos em TypeScript, Python, Rust, Go e C++. Solte um arquivo markdown em ~/.hanzo/workspace/. O cérebro ingere, extrai arestas tipadas e indexa o conteúdo para busca híbrida. Nenhum LLM é chamado. O grafo vai se acumulando.

Esta é a camada de memória de todo runtime Hanzo — o bot, o servidor MCP, o Hanzo Node e qualquer coisa que você embute no seu próprio host.

O que o cérebro é

O cérebro são três coisas num processo só:

1. Páginas — conteúdo endereçado por slug, escrito de qualquer lugar, observado em disco.
2. Arestas — relações tipadas (mentions, attended, works_at, invested_in, founded, advises) extraídas em toda escrita por regex e inferência de papel. Zero LLM.
3. Fatos — tuplas (subject, predicate, object, ts, confidence) consultáveis em tempo real entre sessões.

As páginas ganham um índice FTS5. As arestas ganham uma chave primária sobre (source, target, type). Os fatos ganham um id e um carimbo de tempo. O esquema é curto o bastante para caber na cabeça:

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);

Esse é o contrato inteiro. Todo backend honra isso. Todo runtime escreve um arquivo idêntico byte a byte.

Por que a extração sem LLM importa

Extratores baseados em LLM queimam tokens, latência e dinheiro em toda escrita. Produzem deriva entre execuções. Tornam o grafo não determinístico.

O cérebro extrai arestas com regex e inferência de papel na hora da escrita. É rápido, é de graça e produz as mesmas arestas toda vez, dada a mesma entrada. Quando você ingere «Alice fundou a Acme. Ela investiu na Foobar», você recebe:

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

Toda vez. Em todo runtime. Sem ida e volta.

Se você quer enriquecimento de LLM por cima — desambiguação de entidades, verificação de afirmações, resumo — chama o seu modelo em cima do grafo determinístico. O grafo é o substrato. O LLM é o acabamento opcional.

Um arquivo. Todo runtime.

O mesmo brain.db abre em TypeScript, Python, Rust, Go e C++. Sem traduzir formato, sem migração. Se você escreve a partir de hanzobot/go num servidor e lê de @hanzo/bot-memory num worker do navegador, você lê o arquivo que o servidor escreveu.

Recurso	TS	Python	Rust	Go	C++
Interface BrainStore	sim	sim	sim	sim	sim
SQLite (padrão)	sim	sim	sim	sim	sim
Busca híbrida FTS5	sim	sim	trait	sim	sim
Extrator de links do grafo	sim	sim	sim	sim	sim
Carregador de receitas	sim	sim	sim	sim	sim
Backends plugáveis	sim	sim	sim	sim	sim

Totais de testes entre runtimes no lançamento: 121 TS + 53 Python + 58 Go + 38 Rust (mcp) + 38 Rust (node) + 98 C++ = 406 testes, todos verdes. Cada runtime entrega a mesma fusão, o mesmo rerank (MMR), o mesmo RRF, a mesma normalização de slug, o mesmo extrator de arestas.

Consultável pelo MCP

O cérebro fica exposto pelo MCP como três ferramentas:

• brain.recall <entity> — todo fato já afirmado sobre uma entidade, com carimbos de tempo.
• brain.search <query> — FTS híbrido mais vetor, fundidos com RRF, rerank MMR opcional.
• brain.ingest <slug> <content> — escreve uma página, extrai arestas sozinho, atualiza o FTS.

Todo agente que fala com um Hanzo Node, com o servidor MCP de Hanzo ou com um bot construído em hanzobot/* ganha essas ferramentas de graça. Sem sidecar, sem serviço extra, sem um banco separado para operar.

Para o caminho do binário único em 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, embutido dentro de hanzo-mcp:

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

Armazenamento plugável, o mesmo contrato

SQLite é o padrão. Dá para as primeiras cem mil páginas num notebook. Quando você passar disso, registra outro backend sem mudar o código da aplicação:

Backend	Quando
sqlite	solo, < 100K páginas
qdrant	ANN vetorial em escala
meilisearch	FTS por palavra-chave em escala
zapdb	store nativo canônico e multilíngue
replicate	WAL do SQLite transmitido para o S3 como backup
vfs	sistema de arquivos em blocos com streaming no S3, tamanho sem limite
postgres	deploys de equipe multi-inquilino

Para semântica distribuída no formato SQLite entre várias máquinas usamos transporte ZAP, consenso Quasar e zapdb. O cérebro continua o mesmo. O contrato de bytes que entram e bytes que saem se mantém.

Memória que se acumula

O ponto do cérebro não é um banco de dados. É a troca de premissa. O seu agente não começa toda sessão em branco. O markdown que você escreveu há um ano já é um grafo. As conversas de ontem produziram arestas e fatos que a sessão de hoje consulta sem pagar tokens por isso. Dois agentes em duas máquinas podem compartilhar brain.db via replicate e convergir para a mesma visão.

É isso que queremos dizer com memória que se acumula. O grafo cresce. O modelo fica mais barato. O usuário vê um assistente que lembra.

Pegue o cérebro

• Cânone TypeScript (vem com o bot): npm install -g @hanzo/bot && hanzo-bot serve
• Python: pip install hanzo-memory
• Binário único em Go: go install github.com/hanzobot/go/cmd/hanzo-bot@latest
• Rust: membro do workspace de hanzoai/node e de hanzoai/mcp
• C++: só headers em hanzobot/cpp/include/hanzo/brain/

Fonte: github.com/hanzoai/brain. Licença: MIT.

---

Um arquivo. Cinco runtimes. Zero chamadas de LLM para operações de grafo. Local-first, por projeto.