Octobrain: หน่วยความจำระยะยาวสำหรับผู้ช่วย AI

คุณใช้เวลาหนึ่งชั่วโมงในการดีบักร่วมกับ Claude คุณสำรวจโค้ดเบส ตัดสินใจเชิงสถาปัตยกรรม ค้นหากรณีขอบ คุณออกจากระบบ เซสชันถัดไปล่ะ? คุณต้องอธิบายโครงสร้างโปรเจกต์ของคุณตั้งแต่ต้นอีกครั้ง

AI ไม่ควรทำงานแบบนี้ งานวิจัยจาก Arize แสดงให้เห็นว่าประสิทธิภาพของ LLM ลดลงอย่างมากเมื่อเกิน 100K โทเค็น แม้แต่กับโมเดลที่โฆษณาว่ามีหน้าต่างขนาดล้านโทเค็น การทดสอบของ Diffray พบว่า 11 จาก 12 โมเดลมีความแม่นยำต่ำกว่า 50 % เพียงแค่ที่ 32K โทเค็น ปรากฏการณ์ "lost in the middle" ฝังข้อมูลไว้ในบริบทที่ยาว และ การสำรวจของ Qodo พบว่า 65 % ของนักพัฒนาระบุว่าบริบทที่ขาดหายไปเป็นอุปสรรคที่ใหญ่ที่สุดในการรีแฟกเตอร์

ปัญหาไม่ได้อยู่ที่ AI ลืม แต่อยู่ที่เราไม่มีวิธีที่ดีพอที่จะทำให้มันจดจำ

Octobrain คือหน่วยความจำระยะยาวสำหรับผู้ช่วย AI มันคงข้อมูลเชิงลึก การตัดสินใจ และความรู้ไว้ข้ามเซสชัน ไม่ใช่แค่ภายในเซสชันเดียว วันนี้เราเปิดตัวเวอร์ชัน 0.5.0 พร้อมการทำดัชนีไฟล์ในเครื่อง การล้างการอ้างอิงที่ล้าสมัยโดยตระหนักถึง git และความเข้ากันได้กับ MCP (Model Context Protocol) อย่างสมบูรณ์

Octobrain ทำอะไรจริง ๆ

Octobrain ทำงานเป็น MCP server ที่เปิดเผยเครื่องมือหน่วยความจำให้กับไคลเอนต์ที่เข้ากันได้ — Claude Desktop, Zed, Cursor หรืออะไรก็ตามที่พูด MCP ได้ และยังเป็น CLI เมื่อคุณต้องการการควบคุมโดยตรง

# เริ่ม MCP server
octobrain mcp

# หรือใช้โดยตรง
octobrain memory memorize --title "API Pattern" \
  --content "Use REST for CRUD, GraphQL for complex queries" \
  --memory-type architecture --tags "api,design"

เซิร์ฟเวอร์เปิดเผยเครื่องมือเจ็ดอย่าง: memorize, remember, forget, relate, auto_link, memory_graph และ knowledge_search AI ของคุณจัดเก็บข้อมูลเชิงลึกระหว่างการสนทนา ดึงมันมาในเซสชันถัด ๆ ไป และสำรวจการเชื่อมโยงระหว่างความทรงจำที่เกี่ยวข้อง

ไม่มีไฟล์สรุปแบบทำมือ ไม่มีการพองตัวของหน้าต่างบริบท แค่หน่วยความจำที่คงอยู่

ทำไมเราจึงสร้างสิ่งนี้

เราไม่ได้เริ่มต้นด้วยหน่วยความจำ เราเริ่มต้นด้วย Octomind — รันไทม์สำหรับเอเจนต์ AI ผู้เชี่ยวชาญที่ให้คุณได้นักพัฒนาระดับซีเนียร์ในห้าวินาทีผ่านระบบ tap: octomind run developer:general ไม่ต้องตั้งค่าใด ๆ มีเครื่องมือครบครัน

แต่เอเจนต์ของเรากลับชนกำแพงเดิมซ้ำ ๆ พวกมันใช้เวลาหลายชั่วโมงกับงานหนึ่ง — สำรวจโค้ดเบส ตัดสินใจเชิงสถาปัตยกรรม หาวิธีแก้ปัญหา จากนั้นเซสชันก็จบลง หน้าต่างบริบทเต็ม เซสชันถัดไปเริ่มจากศูนย์ รูปแบบเดิม ๆ ถูกค้นพบใหม่ การตัดสินใจเดิม ๆ ถูกทำซ้ำ Groundhog Day กับเทอร์มินัล

เราลองวิธีแก้ปัญหาชั่วคราว Memory bank แบบทำมือที่ต้องใช้วินัยที่เราไม่มี สรุปเซสชันที่สูญเสียความละเอียดอ่อนของ เหตุผล ที่ตัดสินใจ ฐานความรู้แบบสถิตที่ล้าสมัยทันทีที่เราเปลี่ยนชื่อไฟล์ Cursor rules, สคริปต์ที่กำหนดเอง, ส่วนขยายต่าง ๆ ทั้งหมดล้วนเป็นวิธีแก้ปัญหาแบบสถิตสำหรับปัญหาแบบไดนามิก

ดังนั้นเราจึงสร้าง Octobrain ขึ้นมา

เครื่องมือที่มีอยู่ทำผิดอะไร

เมื่อเราดูโซลูชันด้านหน่วยความจำ เราพบช่องว่างเดิม ๆ ซ้ำแล้วซ้ำเล่า:

ระบบกลยุทธ์เดียว เครื่องมือส่วนใหญ่เลือกแนวทางเดียว — vector search, BM25 หรือ graph traversal — แค่นั้น แต่คำค้นที่ต่างกันต้องการกลยุทธ์ที่ต่างกัน บางครั้งคุณต้องการความคล้ายคลึงเชิงความหมาย บางครั้งคุณต้องการการจับคู่คีย์เวิร์ดที่แน่นอน บางครั้งคุณต้องเดินทางผ่านความสัมพันธ์ เราต้องการทั้งหมด รวมกันอย่างชาญฉลาด

ความสำคัญแบบสถิต ระบบที่มีอยู่ปฏิบัติต่อทุกความทรงจำว่าสำคัญเท่ากันตลอดไป หน่วยความจำไม่ทำงานแบบนั้น บางสิ่งสำคัญแค่วันเดียว บางสิ่งสำคัญหลายปี เราต้องการ temporal decay — ความทรงจำที่จางลงตามธรรมชาติเว้นแต่จะถูกเสริมแรงด้วยการเข้าถึง

การสะสมการอ้างอิงที่ตายแล้ว เส้นทางไฟล์ในความทรงจำเน่าไป คุณรีแฟกเตอร์ เปลี่ยนชื่อ ลบ ระบบส่วนใหญ่ไม่สังเกตเห็น ความทรงจำคงอยู่ ชี้ไปยังผี เราต้องการการล้างที่ตระหนักถึง git ซึ่งตรวจจับการเปลี่ยนชื่อ ลงโทษการอ้างอิงที่ล้าสมัย และลบสิ่งที่ล้าสมัยอย่างแท้จริง

ไม่มีความสัมพันธ์ ความรู้จริงเชื่อมโยงกัน การตัดสินใจสื่อถึงการพึ่งพา การแก้บั๊กแทนที่วิธีแก้ปัญหาชั่วคราว รูปแบบหนึ่งใช้สถาปัตยกรรมหนึ่ง เราต้องการระบบที่สามารถจำลองความสัมพันธ์เหล่านี้ ไม่ใช่แค่เก็บข้อเท็จจริงที่แยกจากกัน

แนวทาง SOTA ที่เราใช้จริง ๆ

เราไม่ได้คิดค้นเทคนิคเหล่านี้ เรารวบรวมสิ่งที่ใช้งานได้จาก state of the art ทำให้มันกำหนดค่าได้ และให้กรณีการใช้งานเป็นผู้ตัดสินใจ

Hybrid Search พร้อม RRF แบบเนทีฟ

Octobrain รวม BM25 full-text search กับ vector similarity โดยใช้ Reciprocal Rank Fusion ผ่าน execute_hybrid() แบบเนทีฟของ LanceDB อัลกอริทึมเดียวกันที่ระบบค้นหาในโปรดักชันใช้ คุณค้นหา "authentication middleware" ได้เมื่อคุณค้นหา "auth layer" — แต่คุณก็พบการจับคู่ที่แน่นอนเมื่อคุณต้องการ

Reranking แบบเลือกได้

สำหรับการดึงข้อมูลที่สำคัญ เปิดใช้งาน cross-encoder reranker มันให้คะแนนคู่คำค้น-เอกสารด้วยโมเดลเฉพาะทาง เพิ่มความแม่นยำ 20–35 % ลดการ hallucinate 35 % ปิดอยู่โดยค่าเริ่มต้นเพราะความเร็วสำคัญ ใช้ได้เมื่อคุณต้องการความแม่นยำ

Temporal Decay (สไตล์ Ebbinghaus)

ความทรงจำจางหายไป มันไม่ใช่บั๊ก — แต่เป็นวิธีที่การรู้คิดทำงาน Octobrain ใช้เส้นโค้งการลืมแบบ Ebbinghaus: ความทรงจำเสื่อมไปตามธรรมชาติเว้นแต่จะถูกเข้าถึง ทุกครั้งที่ดึงข้อมูลจะเพิ่มความสำคัญ ความทรงจำที่ไม่ใช้จะลอยลง ความทรงจำที่สำคัญยังคงเห็นได้ กำหนดครึ่งชีวิต (ค่าเริ่มต้น: 90 วัน) และค่าต่ำสุด

Auto-Linking (Zettelkasten สำหรับ AI)

เมื่อคุณเก็บความทรงจำ Octobrain จะค้นหาความทรงจำที่คล้ายกันเชิงความหมายและสร้างความสัมพันธ์แบบสองทิศทาง ผลลัพธ์คือกราฟความรู้ที่ผุดขึ้น ค้นหาความทรงจำเดียว ได้บริบทของมัน — ความทรงจำที่ขยายมัน ขัดแย้งกับมัน นำมันไปใช้ พึ่งพามัน

การล้างการอ้างอิงที่ล้าสมัยแบบ Git-Aware

ระบบหน่วยความจำสะสมการอ้างอิงไปยังไฟล์ที่ไม่มีอยู่อีกต่อไป Octobrain ตรวจจับสิ่งนี้เมื่อเริ่มต้น: ถ้าไฟล์ที่เกี่ยวข้องทั้งหมดหายไป ความทรงจำจะถูกลบ ถ้าบางไฟล์หายไป ความสำคัญจะถูกลงโทษ ไฟล์ถูกเปลี่ยนชื่อ? เราตรวจจับผ่านประวัติ git และอัปเดตการอ้างอิง

หน่วยความจำของคุณยังคงสะอาดเหมือนโค้ดเบสของคุณ

มีอะไรใหม่ใน 0.5.0

รีลีสนี้สะท้อนสิ่งที่เราเรียนรู้จากการรันหน่วยความจำในสเกล:

การทำดัชนีไฟล์ในเครื่อง: ระบบความรู้ตอนนี้ทำดัชนีไฟล์ในเครื่อง ไม่ใช่แค่ URL ชี้ไปที่เอกสาร, PDF, Markdown มันแบ่งเป็นชิ้นอย่างชาญฉลาด ติดตามเนื้อหาแม่สำหรับบริบท ทำดัชนีใหม่อัตโนมัติเมื่อเนื้อหาล้าสมัย

ที่จัดเก็บแบบขอบเขตเซสชัน: ชิ้นความรู้สามารถมีขอบเขตเซสชันได้ — ที่จัดเก็บชั่วคราวที่ล้างตัวเองหลัง 120 ชั่วโมง สำหรับการวิจัยครั้งเดียวที่ไม่ควรทำให้หน่วยความจำระยะยาวสกปรก

ประเภทหน่วยความจำ Product และ Workflow: สองหมวดหมู่ใหม่ product สำหรับสเปคของฟีเจอร์ ข้อกำหนด การตัดสินใจด้านการออกแบบ workflow สำหรับกระบวนการ playbook และรูปแบบที่เกิดซ้ำ

rmcp SDK อย่างเป็นทางการ: ย้ายจากการใช้งาน MCP ที่กำหนดเองไปยัง Rust SDK อย่างเป็นทางการ การปฏิบัติตามโปรโตคอลที่ดีขึ้น ความเสถียรที่ดีขึ้น พร้อมรับมือกับอนาคตได้ดีขึ้น

การล้างการอ้างอิงที่ล้าสมัย: การตรวจจับการอ้างอิงไฟล์ที่ตายแล้วโดยอัตโนมัติ พร้อมการติดตามการเปลี่ยนชื่อใน git

ทั้งหมดทำงานร่วมกันอย่างไร: Octomind + Octobrain

Octobrain ทำงานแบบสแตนด์อโลนได้ แต่ถูกออกแบบมาสำหรับ Octomind — รันไทม์ของเราสำหรับเอเจนต์ AI ผู้เชี่ยวชาญ

กระบวนการ: Octomind เขียนโค้ด ตัดสินใจ พบเจอบั๊ก ทุกข้อมูลเชิงลึกจะถูกเก็บใน Octobrain พร้อมแฮชคอมมิต git ปัจจุบัน สามเดือนต่อมา รีแฟกเตอร์โมดูลนั้น? Octomind ดึงการตัดสินใจเดิม — พร้อมความทรงจำที่เกี่ยวข้อง แนวทางที่ขัดแย้งกันที่ถูกปฏิเสธ เหตุผลเบื้องหลังการแลกเปลี่ยน

หน่วยความจำถูกจำกัดขอบเขตให้กับโปรเจกต์ของคุณผ่านแฮช URL git remote คำค้นข้ามโปรเจกต์ใช้งานได้เมื่อคุณต้องการบริบทที่ใช้ร่วมกัน การกรองตามบทบาท (developer, reviewer เป็นต้น) ทำให้มุมมองเป็นระเบียบ

Octomind จัดการเอเจนต์ Octobrain จัดการหน่วยความจำ ด้วยกัน พวกมันแก้ปัญหาทั้งหมด: AI ที่รู้จักโดเมนของคุณจริง ๆ ข้ามเซสชัน โดยไม่ต้องปวดหัวกับการตั้งค่า

ทำไมเราไม่ใช้ Mem0 หรือ Zep

เราประเมินพื้นที่หน่วยความจำก่อนสร้าง นี่คือสิ่งที่เราพบ:

• Mem0: เส้นทางที่เร็วที่สุดสู่โปรดักชัน บริการที่จัดการอย่างยอดเยี่ยม สถาปัตยกรรมเวกเตอร์แบนราบ (ไม่มีความสัมพันธ์แบบกราฟ) เราต้องการกราฟ
• Zep: ใช้กราฟเป็นฐาน แข็งแกร่งในคำค้นเชิงเวลา นำหน้าในเบนช์มาร์ก LoCoMo — สถาปัตยกรรมซับซ้อน หนักกว่าที่เราต้องการสำหรับการใช้งานแบบ local-first
• Letta: ระดับหน่วยความจำที่ได้รับแรงบันดาลใจจาก OS, LLM จัดการการดึงข้อมูล — ต้องใช้ LLM สำหรับทุกการดำเนินงานหน่วยความจำ เราต้องการบางสิ่งที่เบากว่า เร็วกว่า คาดเดาได้มากกว่า

Octobrain ต่างออกไป เราไม่ได้กำลังปรับให้เหมาะกับแนวทางเดียว — เรากำลังทำให้กลยุทธ์ SOTA หลายอย่างพร้อมใช้และกำหนดค่าได้ Hybrid search หรือเวกเตอร์ล้วน ๆ? ตัวเลือกของคุณ Temporal decay หรือความสำคัญแบบสถิต? กำหนดค่าได้ Auto-linking หรือความสัมพันธ์แบบทำมือ? ทำงานได้ทั้งคู่ Embedding ในเครื่องหรือผ่าน API? อย่างใดอย่างหนึ่งก็ได้

เป้าหมายไม่ใช่ระบบหน่วยความจำที่ง่ายที่สุด แต่เป็นระบบที่แม่นยำที่สุดสำหรับกรณีการใช้งานเฉพาะของคุณ

โอเพนซอร์ส Local-First

Octobrain มีลิขสิทธิ์ Apache-2.0 และทำงานบนเครื่องของคุณทั้งหมด โค้ดของคุณ ความทรงจำของคุณ ข้อมูลของคุณ — ไม่เคยออกจากระบบของคุณ เว้นแต่คุณจะกำหนดค่า API embedding ภายนอกอย่างชัดเจน เราสร้างมันแบบนี้เพราะเราเบื่อที่จะเลือกระหว่างบริการที่จัดการให้ที่ "สะดวก" ซึ่งต้องการส่งโค้ดเบสของเราไปยังเซิร์ฟเวอร์ของคนอื่น หรือโซลูชัน DIY ที่เปราะบางและพังเมื่อมีโหลด

การโฮสต์เองไม่ควรหมายถึงการประนีประนอมกับความสามารถ Octobrain ให้คุณ hybrid search ระดับโปรดักชัน, temporal decay และกราฟความสัมพันธ์ — ทั้งหมดทำงานในเครื่อง โดยไม่เปิดเผยข้อมูลใด ๆ

เริ่มต้นใช้งาน

# macOS ผ่าน Homebrew (แนะนำ)
brew install muvon/tap/octobrain

# แพลตฟอร์มใดก็ได้ผ่าน crates.io
cargo install octobrain

# เริ่ม MCP server
octobrain mcp

เพิ่มในการตั้งค่า Claude Desktop ของคุณ:

{
	"mcpServers": {
		"octobrain": {
			"command": "/path/to/octobrain",
			"args": ["mcp"]
		}
	}
}

รีสตาร์ท Claude AI ของคุณตอนนี้มีหน่วยความจำระยะยาวแล้ว

คำถามที่พบบ่อย

Octobrain ทำงานกับผู้ช่วย AI อื่นนอกจาก Claude หรือไม่?

ใช่ ไคลเอนต์ที่เข้ากันได้กับ MCP ใด ๆ ก็ทำงานได้ — Claude Desktop, Zed, Cursor, Windsurf และการใช้งานที่กำหนดเองใด ๆ ที่พูดโปรโตคอลได้

ข้อมูลของฉันถูกเก็บที่ไหน?

ในเครื่องของคุณ Octobrain ใช้ SQLite สำหรับกราฟและ LanceDB สำหรับเวกเตอร์ ไม่มีบริการคลาวด์ ไม่มีที่จัดเก็บภายนอกเว้นแต่คุณจะกำหนดค่าผู้ให้บริการ embedding แบบ API

สิ่งนี้เปรียบเทียบกับการใช้หน่วยความจำในตัวของ Claude อย่างไร?

หน่วยความจำของ Claude เหมาะสำหรับความต้องการส่วนตัวและบริบทที่เกิดซ้ำ Octobrain มีไว้สำหรับความรู้ของโปรเจกต์ — การตัดสินใจเชิงสถาปัตยกรรม รูปแบบโค้ดเบส การแก้บั๊ก การแลกเปลี่ยนทางการออกแบบ มันคงอยู่ข้ามโปรเจกต์และอยู่รอดจากการเปลี่ยนบัญชี

ฉันสามารถนำเข้าโน้ตหรือเอกสารที่มีอยู่ได้หรือไม่?

ใช่ ระบบความรู้ใน 0.5.0 ทำดัชนีไฟล์ในเครื่อง — Markdown, PDF, ไฟล์ข้อความ ชี้ไปที่เอกสารของคุณและมันจะแบ่งเป็นชิ้น embed และทำให้ค้นหาได้

จะเกิดอะไรขึ้นถ้าฉันเปลี่ยนชื่อหรือลบไฟล์ที่กล่าวถึงในความทรงจำ?

Octobrain ตรวจจับสิ่งนี้เมื่อเริ่มต้น ถ้าไฟล์ที่เกี่ยวข้องทั้งหมดหายไป ความทรงจำจะถูกลบ ถ้าบางอันยังอยู่ ความสำคัญจะถูกลงโทษ การเปลี่ยนชื่อถูกตรวจจับผ่านประวัติ git และการอ้างอิงจะอัปเดตโดยอัตโนมัติ

มีเวอร์ชันโฮสต์หรือไม่?

ตอนนี้ยังไม่มี Octobrain ถูกออกแบบเป็น local-first เวอร์ชันโฮสต์จะต้องการการเปลี่ยนแปลงทางสถาปัตยกรรมที่สำคัญและการพิจารณาด้านความปลอดภัย ถ้าคุณต้องการสิ่งนี้ แจ้งให้เราทราบ

อะไรต่อไป

เรากำลังทดลองกับกลยุทธ์การดึงข้อมูล การแทนแบบหลายเวกเตอร์ Learned sparse retrieval การขยายคำค้น พื้นที่หน่วยความจำพัฒนาอย่างรวดเร็ว — เรามุ่งมั่นที่จะส่งมอบสิ่งที่ใช้งานได้ ไม่ใช่สิ่งที่ฟังดูดีในเปเปอร์

ถ้าคุณกำลังสร้างเอเจนต์ AI ที่ต้องจำสิ่งต่าง ๆ ข้ามเซสชัน ลอง Octobrain เราสร้างมันเพราะเราต้องการ ถ้าคุณกำลังชนกำแพงเดียวกับเรา มันอาจจะเป็นสิ่งที่คุณต้องการเช่นกัน

---

Octobrain พัฒนาโดย Muvon Un Limited โอเพนซอร์สภายใต้ Apache-2.0 รับได้บน GitHub