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.

LICENSE

Shown as plain text.

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "{}"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright 2026 Muvon Un Limited

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
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