Hanzo Brain: एजेंटों के लिए स्थानीय-प्रथम ज्ञान ग्राफ

आपका एजेंट तेज़ है पर भुलक्कड़। हमने वह ठीक किया। आज हम Hanzo Brain भेज रहे हैं: एक बाइनरी, ~/.hanzo/brain/brain.db पर एक SQLite फ़ाइल, और TypeScript, Python, Rust, Go, तथा C++ में वही एल्गोरिथ्म सतह। ~/.hanzo/workspace/ में एक markdown फ़ाइल डालें। दिमाग उसे ग्रहण करता है, टाइप की हुई कोर निकालता है, और मिश्रित पुनर्प्राप्ति के लिए सामग्री अनुक्रमित करता है। कोई भाषा मॉडल नहीं बुलाया जाता। ग्राफ बढ़ता रहता है।

यह हर Hanzo रनटाइम की स्मृति परत है: बॉट, MCP सर्वर, Hanzo नोड, और जो कुछ भी आप अपने होस्ट में गाड़ें।

दिमाग क्या है

दिमाग एक प्रक्रिया में तीन चीज़ें है:

पृष्ठ — स्लग से संबोधित सामग्री, कहीं से भी लिखी, डिस्क पर देखी जाती हुई।
कोर — टाइप किए संबंध (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 नोड, 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`	बैकअप के लिए SQLite का WAL S3 पर प्रवाहित
`vfs`	S3 पर स्ट्रीमिंग ब्लॉक FS, असीमित आकार
`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.

एक फ़ाइल। पाँच रनटाइम। ग्राफ क्रियाओं के लिए शून्य भाषा-मॉडल कॉल। स्थानीय-प्रथम, डिज़ाइन से।