Hanzo Brain: กราฟความรู้ที่เริ่มจากเครื่องท้องถิ่นสำหรับเอเจนต์

เอเจนต์ของคุณฉลาดแต่ขี้ลืม เราแก้เรื่องนั้นแล้ว วันนี้เราส่ง Hanzo Brain ไบนารีเดียว ไฟล์ SQLite เดียวที่ ~/.hanzo/brain/brain.db และผิวอัลกอริทึมเดียวกันใน TypeScript, Python, Rust, Go, และ C++ วางไฟล์ markdown ลงใน ~/.hanzo/workspace/ สมองกลืนมัน สกัดขอบที่มีชนิด และทำดัชนีเนื้อหาเพื่อค้นคืนแบบผสม ไม่มีการเรียกโมเดลภาษา กราฟทบต้น

นี่คือชั้นความจำของทุกรันไทม์ Hanzo ทั้งบอต เซิร์ฟเวอร์ MCP, Hanzo Node และสิ่งที่คุณฝังในโฮสต์ของคุณเอง

สมองคืออะไร

สมองเป็นสามสิ่งในกระบวนการเดียว:

หน้า — เนื้อหาที่อ้างด้วยสลัก เขียนได้จากที่ใดก็ได้ และถูกเฝ้าบนดิสก์
ขอบ — ความสัมพันธ์ที่มีชนิด (mentions, attended, works_at, invested_in, founded, advises) สกัดทุกครั้งที่เขียนด้วยเรเกกซ์และการอนุมานบทบาท ไม่มีโมเดลภาษา
ข้อเท็จจริง — ทูเพิล (subject, predicate, object, ts, confidence) ที่สอบถามได้แบบเวลาจริงข้ามเซสชัน

หน้าได้ดัชนี FTS5 ขอบได้คีย์หลักเหนือ (source, target, type) ข้อเท็จจริงได้ตัวระบุและตราเวลา สกีมาสั้นพอจะจำไว้ในหัว:

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

นั่นคือสัญญาทั้งหมด ทุกแบ็กเอนด์เคารพมัน ทุกรันไทม์เขียนไฟล์ที่เหมือนกันทีละไบต์

ทำไมการสกัดโดยไม่มีโมเดลภาษาจึงสำคัญ

ตัวสกัดที่อิงโมเดลภาษาเผาโทเคน ความหน่วง และเงินทุกครั้งที่เขียน มันทำให้ผลล่องระหว่างรอบ และทำให้กราฟไม่กำหนดได้

สมองสกัดขอบด้วยเรเกกซ์และการอนุมานบทบาทตอนเขียน มันเร็ว มันฟรี และให้ขอบชุดเดิมทุกครั้งเมื่ออินพุตเดิม เมื่อคุณกลืน "Alice founded Acme. She invested in Foobar," คุณได้:

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

ทุกครั้ง บนทุกรันไทม์ ไม่มีการไปกลับ

ถ้าต้องการเสริมด้วยโมเดลภาษาด้านบน ทั้งการแยกแยะเอนทิตี การตรวจข้ออ้าง และการสรุป ให้เรียกโมเดลของคุณบนกราฟที่กำหนดได้ กราฟคือฐาน โมเดลภาษาคือขั้นเก็บงานที่เป็นทางเลือก

ไฟล์เดียว ทุกรันไทม์

brain.db ไฟล์เดียวกันเปิดได้ใน TypeScript, Python, Rust, Go, และ C++ ไม่มีการแปลรูปแบบ ไม่มีการย้าย ถ้าคุณเขียนจาก hanzobot/go บนเซิร์ฟเวอร์แล้วอ่านจาก @hanzo/bot-memory ในเวิร์กเกอร์ของเบราว์เซอร์ คุณอ่านไฟล์ที่เซิร์ฟเวอร์เขียน

คุณสมบัติ	TS	Python	Rust	Go	C++
ส่วนต่อประสาน BrainStore	ใช่	ใช่	ใช่	ใช่	ใช่
SQLite (ค่าเริ่มต้น)	ใช่	ใช่	ใช่	ใช่	ใช่
การค้นหาผสมด้วย FTS5	ใช่	ใช่	เทรต	ใช่	ใช่
ตัวสกัดลิงก์กราฟ	ใช่	ใช่	ใช่	ใช่	ใช่
ตัวโหลดสูตร	ใช่	ใช่	ใช่	ใช่	ใช่
แบ็กเอนด์ถอดเปลี่ยนได้	ใช่	ใช่	ใช่	ใช่	ใช่

ยอดทดสอบข้ามรันไทม์ตอนเปิดตัว: 121 TS + 53 Python + 58 Go + 38 Rust (mcp) + 38 Rust (node) + 98 C++ = 406 การทดสอบ เขียวทั้งหมด ทุกรันไทม์ส่งฟิวชันเดียวกัน การจัดอันดับใหม่เดียวกัน (MMR) RRF เดียวกัน การทำให้สลักเป็นมาตรฐานเดียวกัน และตัวสกัดขอบเดียวกัน

สอบถามได้จาก MCP

สมองถูกเปิดผ่าน MCP เป็นสามเครื่องมือ:

brain.recall <entity> — ทุกข้อเท็จจริงที่เคยยืนยันเกี่ยวกับเอนทิตี พร้อมตราเวลา
brain.search <query> — FTS ผสมกับเวกเตอร์ รวมด้วย RRF และจัดอันดับใหม่ด้วย MMR ได้ตามต้องการ
brain.ingest <slug> <content> — เขียนหน้า สกัดขอบอัตโนมัติ อัปเดต FTS

ทุกเอเจนต์ที่คุยกับ Hanzo Node, เซิร์ฟเวอร์ Hanzo MCP, หรือบอตที่สร้างบน hanzobot/* ได้เครื่องมือเหล่านี้ฟรี ไม่มีไซด์คาร์ ไม่มีบริการเพิ่ม ไม่มีฐานข้อมูลแยกให้เดินเครื่อง

สำหรับเส้นทางไบนารีเดียวของ 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"

สำหรับ Python:

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

สำหรับ Rust ที่ฝังอยู่ใน hanzo-mcp:

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

ที่เก็บถอดเปลี่ยนได้ สัญญาเดียวกัน

SQLite เป็นค่าเริ่มต้น มันพอสำหรับแสนหน้าแรกบนแล็ปท็อป เมื่อคุณโตเกิน ให้ลงทะเบียนแบ็กเอนด์อื่นโดยไม่เปลี่ยนโค้ดแอปพลิเคชัน:

แบ็กเอนด์	เมื่อใด
`sqlite`	คนเดียว, < 100K หน้า
`qdrant`	ANN เวกเตอร์ในขนาดใหญ่
`meilisearch`	FTS คำสำคัญในขนาดใหญ่
`zapdb`	ที่เก็บเนทีฟหลายภาษาที่เป็นฉบับหลัก
`replicate`	WAL ของ SQLite สตรีมไปยัง S3 เพื่อสำรอง
`vfs`	ระบบไฟล์บล็อกแบบสตรีมบน S3 ขนาดไม่จำกัด
`postgres`	การติดตั้งทีมแบบหลายผู้เช่า

สำหรับความหมายแบบกระจายที่มีรูป SQLite ข้ามเครื่อง เราใช้การขนส่ง ZAP กับฉันทามติ Quasar และ zapdb สมองยังเหมือนเดิม สัญญาไบต์เข้าไบต์ออกยังอยู่

ความจำที่ทบต้น

ประเด็นของสมองไม่ใช่ฐานข้อมูล มันคือการเปลี่ยนสมมติฐาน เอเจนต์ของคุณไม่เริ่มทุกเซสชันแบบว่างเปล่า markdown ที่คุณเขียนเมื่อปีก่อนเป็นกราฟอยู่แล้ว บทสนทนาเมื่อวานสร้างขอบและข้อเท็จจริงที่เซสชันวันนี้สอบถามได้โดยไม่จ่ายโทเคน เอเจนต์สองตัวบนสองเครื่องแชร์ brain.db ผ่าน replicate แล้วมาบรรจบที่มุมมองเดียวกัน

นั่นคือความหมายของความจำที่ทบต้น กราฟโต โมเดลถูกลง ผู้ใช้เห็นผู้ช่วยที่จำได้

รับสมอง

ฉบับ TypeScript (มากับบอต): npm install -g @hanzo/bot && hanzo-bot serve
Python: pip install hanzo-memory
ไบนารีเดียวของ Go: go install github.com/hanzobot/go/cmd/hanzo-bot@latest
Rust: สมาชิกเวิร์กสเปซของ hanzoai/node และ hanzoai/mcp
C++: มีแต่เฮดเดอร์ที่ hanzobot/cpp/include/hanzo/brain/

ซอร์ส: github.com/hanzoai/brain สัญญาอนุญาต: MIT.

ไฟล์เดียว ห้ารันไทม์ ไม่มีการเรียกโมเดลภาษาเพื่องานกราฟ เริ่มจากเครื่องท้องถิ่น โดยการออกแบบ