Hanzo Brain: ein Local-First-Wissensgraph für Agenten

Dein Agent ist klug, aber vergesslich. Das haben wir behoben. Heute liefern wir Hanzo Brain aus — ein einzelnes Binary, eine einzelne SQLite-Datei unter ~/.hanzo/brain/brain.db, und dieselbe Algorithmusfläche in TypeScript, Python, Rust, Go und C++. Leg eine Markdown-Datei nach ~/.hanzo/workspace/. Das Brain nimmt sie auf, extrahiert typisierte Kanten und indiziert den Inhalt für hybride Suche. Kein LLM wird gerufen. Der Graph zinst sich auf.

Das ist die Speicherschicht für jede Hanzo-Laufzeit — der Bot, der MCP-Server, der Hanzo Node und alles, was du in deinen eigenen Host einbettest.

Was das Brain ist

Das Brain sind drei Dinge in einem Prozess:

1. Seiten — Inhalt, adressiert über den Slug, von überall geschrieben, auf der Platte beobachtet.
2. Kanten — typisierte Beziehungen (mentions, attended, works_at, invested_in, founded, advises), bei jedem Schreiben per Regex und Rolleninferenz extrahiert. Null LLM.
3. Fakten — Tupel (subject, predicate, object, ts, confidence), in Echtzeit über Sitzungen hinweg abfragbar.

Seiten bekommen einen FTS5-Index. Kanten bekommen einen Primärschlüssel über (source, target, type). Fakten bekommen eine Id und einen Zeitstempel. Das Schema ist kurz genug, um es im Kopf zu behalten:

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

Das ist der ganze Vertrag. Jedes Backend hält ihn ein. Jede Laufzeit schreibt eine byte-identische Datei.

Warum Extraktion ohne LLM zählt

LLM-Extraktoren verbrennen bei jedem Schreiben Tokens, Latenz und Geld. Sie erzeugen Drift zwischen Läufen. Sie machen den Graphen nicht-deterministisch.

Das Brain extrahiert Kanten mit Regex und Rolleninferenz zur Schreibzeit. Es ist schnell, es ist gratis, und es liefert bei gleicher Eingabe jedes Mal dieselben Kanten. Wenn du „Alice hat Acme gegründet. Sie hat in Foobar investiert“ aufnimmst, bekommst du:

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

Jedes Mal. Auf jeder Laufzeit. Keine Rundreise.

Wenn du LLM-Anreicherung obendrauf willst — Entitätsauflösung, Prüfung von Behauptungen, Zusammenfassung — rufst du dein Modell auf dem deterministischen Graphen auf. Der Graph ist das Substrat. Das LLM ist der optionale Abschluss.

Eine Datei. Jede Laufzeit.

Dieselbe brain.db öffnet sich in TypeScript, Python, Rust, Go und C++. Keine Formatübersetzung, keine Migration. Wenn du von hanzobot/go auf einem Server schreibst und aus @hanzo/bot-memory in einem Browser-Worker liest, liest du die Datei, die der Server geschrieben hat.

Funktion	TS	Python	Rust	Go	C++
BrainStore-Schnittstelle	ja	ja	ja	ja	ja
SQLite (Standard)	ja	ja	ja	ja	ja
Hybride FTS5-Suche	ja	ja	trait	ja	ja
Graph-Links-Extraktor	ja	ja	ja	ja	ja
Rezeptlader	ja	ja	ja	ja	ja
Austauschbare Backends	ja	ja	ja	ja	ja

Testsummen über die Laufzeiten zum Start: 121 TS + 53 Python + 58 Go + 38 Rust (mcp) + 38 Rust (node) + 98 C++ = 406 Tests, alle grün. Jede Laufzeit liefert dieselbe Fusion, dasselbe Rerank (MMR), dasselbe RRF, dieselbe Slug-Normalisierung, denselben Kanten-Extraktor.

Abfragbar über MCP

Das Brain liegt über MCP als drei Werkzeuge offen:

• brain.recall <entity> — jeder Fakt, der je über eine Entität behauptet wurde, mit Zeitstempeln.
• brain.search <query> — hybrides FTS plus Vektor, fusioniert mit RRF, optionales MMR-Rerank.
• brain.ingest <slug> <content> — schreibt eine Seite, extrahiert Kanten von selbst, aktualisiert FTS.

Jeder Agent, der mit einem Hanzo Node, dem Hanzo-MCP-Server oder einem Bot auf hanzobot/* spricht, bekommt diese Werkzeuge umsonst. Kein Sidecar, kein Extra-Dienst, keine separate Datenbank zum Betreiben.

Für den Weg des einzelnen Go-Binary:

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"

Für Python:

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

Für Rust, eingebettet in hanzo-mcp:

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

Tauschbarer Speicher, derselbe Vertrag

SQLite ist der Standard. Es reicht für die ersten hunderttausend Seiten auf einem Laptop. Wenn du darüber hinauswächst, registrierst du ein anderes Backend, ohne Anwendungscode zu ändern:

Backend	Wann
sqlite	allein, < 100K Seiten
qdrant	Vektor-ANN im großen Maßstab
meilisearch	Schlüsselwort-FTS im großen Maßstab
zapdb	kanonischer mehrsprachiger nativer Speicher
replicate	SQLite-WAL nach S3 gestreamt, als Backup
vfs	S3-Streaming-Blockdateisystem, unbegrenzte Größe
postgres	Mehrmandanten-Team-Deployments

Für verteilte Semantik in SQLite-Form über mehrere Maschinen nutzen wir ZAP-Transport, Quasar-Konsens und zapdb. Das Brain bleibt dasselbe. Der Vertrag Bytes rein, Bytes raus hält.

Sich aufzinzendes Gedächtnis

Der Sinn des Brain ist keine Datenbank. Es ist der Wechsel der Annahme. Dein Agent startet nicht jede Sitzung leer. Markdown, das du vor einem Jahr geschrieben hast, ist schon ein Graph. Gespräche von gestern haben Kanten und Fakten erzeugt, die die Sitzung von heute abfragen kann, ohne Tokens dafür zu zahlen. Zwei Agenten auf zwei Maschinen können brain.db über replicate teilen und auf dieselbe Sicht konvergieren.

Das meinen wir mit sich aufzinzendem Gedächtnis. Der Graph wächst. Das Modell wird billiger. Der Nutzer sieht einen Assistenten, der sich erinnert.

Hol dir das Brain

• TypeScript-Kanon (kommt mit dem Bot): npm install -g @hanzo/bot && hanzo-bot serve
• Python: pip install hanzo-memory
• Einzelnes Go-Binary: go install github.com/hanzobot/go/cmd/hanzo-bot@latest
• Rust: Workspace-Mitglied von hanzoai/node und hanzoai/mcp
• C++: nur Header unter hanzobot/cpp/include/hanzo/brain/

Quelle: github.com/hanzoai/brain. Lizenz: MIT.

---

Eine Datei. Fünf Laufzeiten. Null LLM-Aufrufe für Graph-Operationen. Local-first, von Entwurf her.