Generated banner for Octobrain
Generated logo for Octobrain

Octobrain

Memory serverOfficial Muvon project

Created by Muvon

Published in Muvon/octobrain. Publisher page

20 GitHub stars

What it is

Persistent memory for AI assistants — semantic search, knowledge graph, and MCP server integration. Built in Rust.
— the description by Muvon

AutoGineer overview, from the brain’s own files

Octobrain provides long-term memory for AI assistants by storing insights, architecture decisions, and project knowledge. It functions as a CLI tool or an MCP server, allowing AI agents to persist context across sessions. The system uses vector embeddings for semantic search and supports hybrid search by combining vector similarity with BM25 full-text search. It includes features for auto-linking memories, managing knowledge bases via indexed files and URLs, and consolidating goal-related memories into summaries. The system is built in Rust and uses LanceDB for storage.

How it works

Memory model: Vector store

AutoGineer overview, from the brain’s own files

Octobrain stores memories and knowledge in a vector database. It uses embedding models to convert text into vectors for semantic retrieval. When a user or agent interacts with it, the system performs searches across stored memories and indexed knowledge sources. It supports project scoping based on Git remotes and allows for the creation of relationships between memories. The MCP server implementation enables integration with tools like Claude Desktop, allowing agents to call functions to memorize, remember, or search through indexed knowledge.

Folders
FolderRoleFiles
.githubagent-config2
scriptsscripts2
srcsource-code47
.cargofolder1
benchesfolder18
config-templatesfolder1

The agent reads

The agent writes

Requirements

Apps: Docker

Runtimes: Rust

Databases: Qdrant

API keys (by name): GOOGLE_API_KEY, JINA_API_KEY, OPENAI_API_KEY, VOYAGE_API_KEY

Works with: Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Kiro, OpenCode, Amp, Cline, JetBrains Junie, Devin (ex-Windsurf)

Set it up

  1. This brain runs code automatically: 1 script. Review Makefile before opening the folder in Claude Code. No step below turns a hook on for you.

    • Makefile: echo "$(YELLOW)Installing $(BINARY_NAME)...$(NC)"; cargo install --path .; echo "$(GREEN)$(BINARY_NAME) installed successfully$(NC)"
  2. Not scanned by AutoGineerThe author’s MCP configuration (README.md) also starts it in a way AutoGineer does not offer. Read that file: AutoGineer did not scan that path; what it runs is listed under “This brain runs”. https://github.com/Muvon/octobrain/blob/bfb15d6772028f00207b757e883e2d1ddd3fb562/README.md
  3. Not scanned by AutoGineerThe author’s README also describes installing it from a clone of its repository. Read its install section: AutoGineer did not scan that path. https://github.com/Muvon/octobrain/blob/bfb15d6772028f00207b757e883e2d1ddd3fb562/README.md#development-setup
  4. Not scanned by AutoGineerThe author’s README also describes installing it with Homebrew (the author’s own tap). Read its install section: AutoGineer did not scan that path. https://github.com/Muvon/octobrain/blob/bfb15d6772028f00207b757e883e2d1ddd3fb562/README.md#installation
  5. Not scanned by AutoGineerThe author’s README also describes installing it with cargo. Read its install section: AutoGineer did not scan that path. https://github.com/Muvon/octobrain/blob/bfb15d6772028f00207b757e883e2d1ddd3fb562/README.md#installation
  6. Not scanned by AutoGineerThe author’s README also describes installing it from a clone of its repository. Read its install section: AutoGineer did not scan that path. https://github.com/Muvon/octobrain/blob/bfb15d6772028f00207b757e883e2d1ddd3fb562/README.md#installation
  7. Not scanned by AutoGineerThe author’s README also describes installing it with cargo. Read its install section: AutoGineer did not scan that path. https://github.com/Muvon/octobrain/blob/bfb15d6772028f00207b757e883e2d1ddd3fb562/README.md#quick-start
  8. Created by Muvon. Published in Muvon/octobrain. Licence: Apache License 2.0.

Usage

AutoGineer overview, from the brain’s own files

  • Store project insights and decisions for future retrieval
  • Search for relevant context across past conversations
  • Index documentation and web content for agent access
  • Connect related memories to form a knowledge graph
  • Integrate with AI assistants via the MCP protocol
“octobrain memory memorize --title "API Design" --content "Use REST for CRUD" --memory-type architecture”
Stores a new memory entry regarding API design patterns in the persistent store.
“octobrain memory remember "api design patterns"”
Performs a semantic search and returns relevant memories matching the query.
“octobrain knowledge index https://docs.rs/tokio/latest/tokio/”
Indexes the content of the provided URL into the knowledge base for future retrieval.

Documentation by Muvon

Octobrain

Persistent memory for AI assistants — store insights, decisions, and knowledge that survives across conversations.

Image: Crates.io Image: License Image: Rust Image: CI Image: Coverage

MCP Registry: mcp-name: io.github.Muvon/octobrain

Table of Contents

  • Why Octobrain?

  • Quick Start

  • Installation

  • Usage

  • Features

  • Benchmarks

  • Configuration

  • Memory Types

  • MCP Integration

  • Storage Locations

  • Contributing

  • License

Octobrain gives your AI assistant a long-term memory. Store code insights, architecture decisions, bug fixes, and knowledge — then retrieve them with semantic search in future sessions. Works as a CLI tool or as an MCP server for integration with Claude Desktop and other AI tools.

Why Octobrain?

AI assistants start every conversation with zero context. You explain your project, your preferences, your decisions — every single time. Octobrain breaks that cycle:

  • Persistent memory — Insights survive across sessions, not just within them

  • Semantic search — Find memories by meaning, not exact keywords

  • Auto-linking — Related memories connect automatically (Zettelkasten-style)

  • Knowledge indexing — Ingest docs, articles, and files for retrieval

  • MCP integration — Works with Claude Desktop and other MCP-compatible tools

Quick Start

# Install from crates.io
cargo install octobrain

# Store your first memory
octobrain memory memorize --title "API Design Pattern" \
  --content "Use REST for CRUD, GraphQL for complex queries" \
  --memory-type architecture --tags "api,design"

# Search memories
octobrain memory remember "how should I design APIs"

# Start MCP server for Claude Desktop integration
octobrain mcp

Installation

cargo install octobrain
From Source
# Clone and build
git clone https://github.com/muvon/octobrain.git
cd octobrain
cargo build --release

# Binary location
./target/release/octobrain --help
Docker
docker pull ghcr.io/muvon/octobrain:latest
Homebrew (macOS/Linux)
brew install muvon/tap/octobrain
Feature Flags

Octobrain supports multiple embedding providers:

FlagDescriptionAPI Key Required
fastembedLocal embeddings via FastEmbedNo
huggingfaceLocal embeddings via HuggingFaceNo
(default)Both fastembed + huggingfaceNo
(no features)API-based: Voyage, OpenAI, Google, JinaYes
# Build with local embeddings (default, no API keys needed)
cargo build --release

# Build with API-based embeddings only
cargo build --no-default-features --release

For API-based embeddings, set the appropriate environment variable:

  • VOYAGE_API_KEY for Voyage AI

  • OPENAI_API_KEY for OpenAI

  • GOOGLE_API_KEY for Google

  • JINA_API_KEY for Jina

Usage

Memory Management

Store and retrieve insights, decisions, and context:

All memory subcommands accept global flags:

  • --scope <string> — Override project scope (default: auto-detected from Git remote)

  • --role <string> — Filter by role (e.g. "developer", "reviewer")

# Store a memory
octobrain memory memorize --title "API Design" \
  --content "Use REST for CRUD, GraphQL for complex queries" \
  --memory-type architecture --tags "api,design"

# Search memories (semantic search)
octobrain memory remember "api design patterns"

# Multi-query search for broader coverage
octobrain memory remember "authentication" "security" "jwt"

# Get a memory by ID
octobrain memory get <id>

# Get recent memories
octobrain memory recent --limit 20

# Filter by type
octobrain memory by-type architecture --limit 10

# Filter by tags
octobrain memory by-tags "api,security"

# Find memories related to files
octobrain memory for-files "src/main.rs,src/lib.rs"

# Update a memory
octobrain memory update <id> --title "New Title" --add-tags "new-tag"

# Delete a memory
octobrain memory forget --memory-id <id>

# Get memories relevant to the current Git commit
octobrain memory current-commit

# Show memory statistics
octobrain memory stats

# Clean up old/low-importance memories
octobrain memory cleanup

# Compact tables and refresh indices (run when searches slow down)
octobrain memory maintenance

# ⚠️ Delete ALL memory data
octobrain memory clear-all --yes
Memory Consolidation

Close a goal and fold all its contributing memories into a consolidated summary:

# Consolidate a goal (Achieves-link sources → Consolidated state, importance dampened)
octobrain memory consolidate <goal-id> --summary "Final summary"

# Sleep consolidation: auto-cluster recent similar memories
octobrain memory sleep-consolidate --threshold 0.85 --min-size 3
Memory Relationships

Connect related memories for context-rich retrieval:

# Create a relationship between memories
octobrain memory relate <source-id> <target-id> \
  --relationship-type "depends_on" \
  --description "Source requires target to function"

# View relationships for a memory
octobrain memory relationships <memory-id>

# Find related memories through relationships
octobrain memory related <memory-id>

# Auto-link similar memories (Zettelkasten-style)
octobrain memory auto-link <memory-id>

# Explore memory graph
octobrain memory graph <memory-id> --depth 2
Knowledge Base

Index and search web content, docs, and files:

# Index a URL
octobrain knowledge index https://docs.rs/tokio/latest/tokio/

# Index a local file (.txt, .md, .pdf, .docx, .html)
octobrain knowledge index ./docs/architecture.md

# Search knowledge base
octobrain knowledge search "how to handle async tasks"

# Search within a specific source (auto-indexes if outdated)
octobrain knowledge search "spawn blocking" --source https://docs.rs/tokio/

# Read full content of a URL or local file
octobrain knowledge read https://docs.rs/tokio/latest/tokio/

# Search indexed content by regex pattern
octobrain knowledge match "spawn_blocking|block_in_place"

# Store raw text content
octobrain knowledge store "meeting-notes" --content "Discussion points..."

# List indexed sources
octobrain knowledge list --limit 20

# Show statistics
octobrain knowledge stats

# Delete a source
octobrain knowledge delete https://example.com/docs

# Delete stored content by key
octobrain knowledge delete-stored "meeting-notes"
Knowledge Boxes

Import and sync git-backed knowledge bundles scoped to your projects:

# Import a remote git repo as a knowledge box
octobrain box import https://github.com/org/docs-repo.git

# Import at global scope (visible in every project)
octobrain box import https://github.com/org/docs-repo.git --global

# Pull and re-index all subscribed boxes + local .box/ directories
# (the MCP server syncs each session's repos on first contact; agents run `knowledge` `sync` after editing .box/)
octobrain box sync

# List subscribed boxes
octobrain box list

# Remove a box
octobrain box remove github.com/org/docs-repo
MCP Server

Run as an MCP server for integration with Claude Desktop and other AI tools:

# Start with stdio transport (for Claude Desktop)
octobrain mcp

# Start with HTTP transport (for web-based tools)
octobrain mcp --bind 0.0.0.0:12345

Available MCP Tools:

ToolDescription
memorizeStore memories with metadata; optional related_to for inline relationships
rememberSemantic search with filters; returns 1-hop graph neighbors
forgetDelete memories (requires confirmation)
knowledgeUnified tool: search, store, delete, read, match, sync via command field; sync re-indexes knowledge boxes after .box/ edits
See MCP Integration for Claude Desktop setup.

Features

  • Semantic Search — Find memories by meaning using vector embeddings, not exact keyword matches

  • Hybrid Search — Combines BM25 full-text search with vector similarity for better results

  • Reranking Support — Pluggable cross-encoder reranking stage (provider-dependent)

  • Auto-Linking — Automatically connects semantically similar memories (Zettelkasten-style)

  • Temporal Decay — Ebbinghaus forgetting curve for importance management

  • Knowledge Indexing — Ingest URLs, PDFs, docs for retrieval

  • Project Scoping — Isolate memories per Git project or share across projects

  • Role Filtering — Tag memories by role (developer, reviewer, etc.)

  • Query Expansion (HyDE-lite) — Pseudo-relevance feedback for +10-30% recall on long-tail queries

  • MCP Protocol — Full MCP 2026-07-28 compliance for AI tool integration

Benchmarks

Retrieval quality of octobrain's knowledge system on standard BEIR datasets — nDCG@10, fully local, no LLM judge, using the harness's default embedder bge-small-en-v1.5 (384-dim, 33M params). Each corpus passage is indexed through octobrain's real retrieval path and scored against the official qrels (metrics reproduce pytrec_eval).

Datasetoctobrain vectoroctobrain hybridBM25¹bge-small-en-v1.5²
SciFact (5.2K docs, 300 q)0.7220.7420.6650.713
NFCorpus (3.6K docs, 323 q)0.3410.3630.3250.343
  • vector = dense-only retrieval; reproduces the embedder's published BEIR numbers (validates the harness).

  • hybrid = BM25 + vector fused with Reciprocal Rank Fusion (k=60) — octobrain's default. Adds +2 nDCG@10 over the bare embedding and beats classic BM25 on both datasets.

¹ Canonical BM25 from the BEIR paper (Anserini/Lucene, k1=0.9 b=0.4). ² From the bge-small-en-v1.5 model card (MTEB).

Scope: this measures the ranking layer (embedding + BM25 fusion + reranking). BEIR passages are pre-chunked, so octobrain's chunking strategy is not exercised here.

⚠️ Reranker status: The cross-encoder reranker is currently a no-op with fastembed models (byte-identical results to hybrid-only). Rerank is excluded from the numbers above pending investigation. See benches/README.md for details.

Reproduce (downloads the datasets, builds a release binary, runs fully offline):

cd benches && bash scripts/run_retrieval.sh

Configuration

Configuration is stored in ~/.local/share/octobrain/config.toml. The template written on first run defines every option with sensible defaults, but loading is strict — a field you delete by hand causes startup to fail rather than falling back to a default.

Override the config location with OCTOBRAIN_CONFIG_PATH=/path/to/config.toml.

Key Settings
SectionOptionDefaultDescription
[embedding]modelfastembed:Qdrant/all-MiniLM-L6-v2-onnxEmbedding model (provider:model format). Default is a local fastembed model — no API key, runs on CPU.
[search]similarity_threshold0.3Minimum relevance (0.0-1.0)
[search.hybrid]enabledtrueEnable BM25 + vector fusion
[search.reranker]enabledtrueEnable cross-encoder reranking
[search.hyde]enabledtruePseudo-relevance feedback query expansion
[memory]max_memories10000Maximum stored memories
[memory]auto_linking_enabledtrueAuto-connect similar memories
[knowledge]chunk_size1200Characters per chunk
[embedding]batch_size32Texts embedded per batch
[embedding]timeout_secs30Embedding call timeout (0 = no timeout)
[search]max_results50Hard ceiling on results from any search
[search.reranker]modelfastembed:jina-reranker-v2-base-multilingualCross-encoder model
[search.reranker]top_k_candidates50Candidates retrieved before reranking
[search.hyde]top_k3Neighbors averaged for the centroid
[search.hyde]alpha0.5Blend weight on the original query embedding
[memory]max_search_results50Default page size when no limit is given
[memory]sleep_consolidation_enabledtrueLazy sleep consolidation on manager init
[memory]sleep_consolidation_interval_hours24Hours between sleep-consolidation passes
[knowledge]outdating_days15Days before indexed content is reindexed on search
[knowledge]max_results5Results returned from knowledge search
Embedding Providers
[embedding]
# Local models (no API key, runs on CPU, model auto-downloaded on first use)
model = "fastembed:Qdrant/all-MiniLM-L6-v2-onnx"                       # Default: 384-dim quantized, ~125MB resident
model = "fastembed:nomic-ai/nomic-embed-text-v1.5"                      # 768-dim, 8192-ctx, ~550MB weights, highest quality
model = "fastembed:BAAI/bge-small-en-v1.5"                              # 384-dim, ~62 MTEB, fast + good quality
model = "fastembed:sentence-transformers/all-MiniLM-L6-v2-quantized"  # Smallest (~22MB), fastest
model = "fastembed:BAAI/bge-base-en-v1.5"                              # Larger (~440MB), higher quality
model = "fastembed:intfloat/multilingual-e5-small"                     # Multilingual

# Cloud providers (require API keys, generally higher quality)
model = "voyage:voyage-3.5-lite"          # VOYAGE_API_KEY
model = "openai:text-embedding-3-small"   # OPENAI_API_KEY
model = "google:text-embedding-004"       # GOOGLE_API_KEY
model = "jina:jina-embeddings-v3"         # JINA_API_KEY
Full Configuration

See config-templates/default.toml for all available options with documentation.

Memory Types

Organize memories by category for better filtering:

TypeUse For
codeCode patterns, solutions, implementations
architectureSystem design, decisions, patterns
bug_fixBug fixes, troubleshooting, solutions
featureFeature specs, implementations
documentationDocs, explanations, knowledge
user_preferenceSettings, preferences, workflows
decisionProject decisions, trade-offs
learningTutorials, notes, education
configurationSetup, config, deployment
testingTest strategies, QA insights
performanceOptimizations, benchmarks
securityVulnerabilities, fixes, considerations
validationIdea/product validation, hypothesis testing
researchTechnical/market research, analysis
workflowSOPs, playbooks, process descriptions
requirementBusiness requirements, specs, constraints
designUI/UX decisions, wireframes, system design
integrationAPI integrations, third-party services
communicationStakeholder updates, team decisions
processDeployment procedures, runbooks, operations
insightGeneral insights, tips
goalTask/intent anchors for consolidation workflow

MCP Integration

Claude Desktop Setup

Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

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

Restart Claude Desktop. Octobrain tools will be available in your conversations.

HTTP Transport

For web-based integrations:

octobrain mcp --bind 0.0.0.0:12345

The server exposes endpoints at /mcp for MCP protocol communication.

Storage Locations

Data is stored in platform-specific directories:

PlatformLocation
macOS~/.local/share/octobrain/
Linux~/.local/share/octobrain/ or $XDG_DATA_HOME/octobrain/
Windows%APPDATA%\octobrain\

Project-specific memories are isolated by normalized Git remote URL (e.g., github.com/org/repo).

Contributing

Contributions are welcome! Please:

  1. Fork the repository

  2. Create a feature branch (git checkout -b feature/amazing-feature)

  3. Run cargo fmt --all to format code

  4. Run cargo clippy and fix all warnings

  5. Run cargo test --no-default-features

  6. Submit a pull request

Development Setup
# Clone and build
git clone https://github.com/muvon/octobrain.git
cd octobrain
cargo build --no-default-features

# Run tests
cargo test --no-default-features

# Run clippy
cargo clippy --no-default-features

License

Apache-2.0 — see LICENSE for details.

Credits

Developed by Muvon Un Limited.

86 files · 79 not served here

Advantages

Limitations

  • Strict configuration loading causes startup failure if any field is missing from the TOML file evidence: AGENTS.md
  • The cross-encoder reranker is currently a no-op when using fastembed models evidence: README.md

Security

Risk level: Medium risk

This brain runs

Git hooks (5)

  • .pre-commit-config.yaml: pre-commit hooks from https://github.com/doublify/pre-commit-rust at v1.0 (contributor tooling: runs only after pre-commit install) · uses the network
  • .pre-commit-config.yaml: cargo fmt
  • .pre-commit-config.yaml: cargo clippy
  • .pre-commit-config.yaml: cargo check
  • .pre-commit-config.yaml: pre-commit hooks from https://github.com/pre-commit/pre-commit-hooks at v4.4.0 (contributor tooling: runs only after pre-commit install) · uses the network

Agent instructions that run or fetch something (13)

  • AGENTS.md: what Makefile targets use) and **full gate** `--all-features` (what CI + pre-commit run;
  • AGENTS.md: Check: `cargo check --no-default-features --all-targets` · All feature combos: `make check-features`
  • AGENTS.md: Format (write): `cargo fmt --all` · Format (verify): `cargo fmt --all -- --check` — `make fmt` is verify-only
  • AGENTS.md: Run CLI: `cargo run --no-default-features -- <subcommand>` · MCP server: `cargo run --no-default-features -- mcp` (stdio) or `-- mcp --bind=host:port` (streamable HTTP)
  • AGENTS.md: BEIR retrieval bench (local, free): `bash benches/scripts/run_retrieval.sh` or `cargo run --release --features bench --bin beir_bench -- <dataset_dir> [label]`
  • AGENTS.md: Completions: `make install-completions` / `make test-completions`
  • AGENTS.md: `make ci` references nonexistent targets (`format-check`, `lint`) — run the four commands above instead
  • AGENTS.md: boxes under `<storage>/boxes/`, shared-embedding endpoints under `<storage>/run/`.
  • AGENTS.md: `make check-features` passes when touching feature-gated code
  • AGENTS.md: Stale Makefile details: `make fmt` verifies only, `make ci` is broken, `make install-deps` has a `trustup` typo.
  • AGENTS.md: LongMemEval benches require `benches/.env` (LLM keys) and cost ~10M tokens per full run;
  • AGENTS.md: smoke-test with `make smoke` in `benches/`.
  • AGENTS.md: Force-run sleep consolidation or maintenance in production paths

Install scripts (1)

  • Makefile (make install): echo "$(YELLOW)Installing $(BINARY_NAME)...$(NC)"; cargo install --path .; echo "$(GREEN)$(BINARY_NAME) installed successfully$(NC)"

MCP servers (1)

  • README.md (octobrain): /path/to/octobrain mcp
  • Medium risk: runs-git-hook-remote-exec (.pre-commit-config.yaml:4)
  • Medium risk: runs-git-hook-remote-exec (.pre-commit-config.yaml:35)

Attribution and licence

Created by
Muvon
Publisher
Muvon (Official Muvon project)
Source
Muvon/octobrain · commit bfb15d6
Licence
Apache License 2.0 (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Muvon.

Install from source

79 of its files are not served here, so there is no ZIP. Muvon/octobrain at bfb15d6