MoltBrain MCP: Long-Term Memory Plugin for OpenClaw, Supports Smart Search & Storage

Moltbrain

MoltBrain is a long-term memory layer plugin designed for OpenClaw, MoltBook, and Claude Code, capable of automatically learning and recalling project context, providing intelligent search, observation recording, analysis statistics, and persistent storage functions.

Knowledge management and memory Developer tools #Memory enhancement #Intelligent search #Persistent storage #Project context .TypeScript

rating : 4.5 points

downloads : 10.1K

update time : 2026-03-13

Open Site

What is MoltBrain?

MoltBrain is an intelligent memory system specifically designed for AI assistants (such as OpenClaw, MoltBook, and Claude Code). It's like a digital brain that can automatically record your conversations with the AI, learn the details of your projects, remember technical decisions, and intelligently provide relevant context in subsequent conversations. Imagine this: You set up an OAuth authentication system in your first conversation. Weeks later, when you need to add a password reset function, MoltBrain will automatically remind you of your previous technical choices, code structure, and security settings, enabling the AI assistant to assist you based on the complete historical context.

How to use MoltBrain?

Using MoltBrain is very simple and only requires a few steps: 1. Install MoltBrain through the plugin marketplace. 2. It will run automatically in the background without additional configuration. 3. When you work with the AI assistant, it will automatically record important information. 4. In subsequent conversations, relevant memories will be automatically injected into the dialogue. You can also view and manage your memories through the web interface (localhost:37777), search past conversations, or export data.

Use cases

MoltBrain is particularly suitable for the following scenarios: • Long-term project development - Remember the technology stack, architectural decisions, and code patterns. • Team collaboration - Maintain consistency in technical decisions among team members. • Learning new frameworks - Record key concepts and examples during the learning process. • Code maintenance - Remember why specific implementation methods were chosen. • Cross-session work - Continue previous development work at different time points.

Main features

Automatic observation and learning

Automatically capture important findings, technical decisions, and code snippets in conversations without manual marking. The system will intelligently identify which information is worth remembering.

Intelligent recall and injection

Automatically inject historical memories into relevant conversations, allowing the AI assistant to provide suggestions based on the complete context. Supports semantic search to find the most relevant historical information.

Web memory viewer

Access the beautiful web interface through localhost:37777 to browse the memory timeline, search historical conversations, and view analytics statistics.

Decentralized storage DApp

Provide a persistent storage service (app.moltbrain.dev/storage), supporting content-addressable JSON data storage and named key-value slots. Data is isolated by wallet scope.

Virtuals Protocol integration

Provide a persistent memory plugin for the AI game agents of the Virtuals Protocol, allowing game AIs to remember states and strategies across sessions.

Deep integration with OpenClaw

As an extension and skill of OpenClaw (a project with over 116,000 stars), it provides complete lifecycle hooks and tool integration.

Analysis and tracking

Track token usage, session statistics, and concept trends to help you understand your work patterns and optimize the use of AI assistants.

Multiple export formats

Support export in JSON, CSV, and Markdown formats with custom templates for easy data backup and sharing.

Advantages

Seamless integration - Natively integrated with OpenClaw, MoltBook, and Claude Code, ready to use after installation.

Intelligent context - Automatically identify and recall relevant history to improve the efficiency of AI assistants.

Persistent memory - Data is stored locally and supports decentralized backup to ensure memories are not lost.

Multi-platform support - Compatible with multiple AI assistant platforms through the MCP protocol.

User-friendly - Provide a web interface and CLI tools for simple and intuitive memory management.

Privacy protection - Data is stored locally by default, with optional encryption and decentralized storage.

Limitations

Learning curve - You need to understand the basic concepts of the MCP protocol for the best experience.

Resource consumption - Long-term operation may occupy a certain amount of disk space to store memory data.

Platform dependency - Optimized mainly for specific AI assistant platforms, with limited universality.

Configuration complexity - Advanced functions require certain technical knowledge for configuration.

Paid service - The decentralized storage service requires a small payment in USDC ($0.01 per operation).

How to use

Install the plugin

Install MoltBrain through the plugin marketplace on supported AI assistant platforms. For Claude Code, use the plugin command to install directly.

Start the service

After installation, MoltBrain will automatically start the background service, listening on port localhost:37777. You can access the web interface through a browser.

Start using

Use the AI assistant normally, and MoltBrain will automatically record important conversations in the background. When historical context is needed, it will automatically inject relevant memories.

Manage memories

Use the web interface or CLI commands to view, search, tag, and export your memory data.

Usage examples

Cross-session project development

You are developing a web application and discussing authentication, database design, and API structure with the AI assistant at different time points. MoltBrain will remember all technical decisions. When you come back to add new features weeks later, the AI assistant can provide consistent suggestions based on the complete history.

Technical learning and reference

You are learning a new JavaScript framework and discussing core concepts, best practices, and common pitfalls with the AI assistant. MoltBrain records these learning points, allowing you to quickly find previous explanations and examples when you encounter similar problems.

Team knowledge sharing

The development team uses a shared MoltBrain instance to record the team's technical decisions, code review comments, and architectural discussions. New members can quickly understand the project history and design reasons when joining.

Code refactoring guidance

When refactoring old code, MoltBrain can provide the code's evolution history, previous refactoring decisions, and relevant business context to help make more informed refactoring choices.

Frequently Asked Questions

Will MoltBrain store all my conversations?

Where is the data stored? Is it secure?

Which AI assistant platforms does MoltBrain support?

Is the decentralized storage service paid?

How can I export my memory data?

Will MoltBrain affect the response speed of the AI assistant?

Can I manually edit or delete specific memories?

How can a team use shared memories?

Related resources

Official website

The official web application of MoltBrain, including the storage DApp and documentation.

GitHub repository

Complete source code, issue tracking, and contribution guidelines.

Storage DApp

Decentralized storage service interface for managing your memory data.

Virtuals Protocol plugin

A plugin that provides memory functions for the Virtuals Protocol game AI.

x402 payment protocol

Documentation for the micropayment protocol used by MoltBrain.

OpenClaw integration guide

Detailed guide for installing and configuring MoltBrain in OpenClaw.

MoltBook integration

Configuration instructions for integrating with the MoltBook social network.

Model Context Protocol

Official specification of the MCP protocol to understand the underlying technical principles.

🚀 MoltBrain

A long-term memory layer for OpenClaw, MoltBook & Claude Code that automatically learns and recalls your project context. $BRAIN CA 0x35e7942E91876Eb0c24A891128E559a744fe8B07

🚀 Quick Start

Installation

╔══════════════════════════════════════════════════════════════════════╗
║                                                                      ║
║   Step 1    /plugin marketplace add nhevers/moltbrain                ║
║   Step 2    /plugin install moltbrain                                ║
║                                                                      ║
╚══════════════════════════════════════════════════════════════════════╝

That's it. MoltBrain starts working automatically.

✨ Features

+-------------------------+-------------------------+-------------------------+
|                         |                         |                         |
|   OBSERVATIONS          |   SMART SEARCH          |   WEB VIEWER            |
|   ----------------      |   ----------------      |   ----------------      |
|   Auto-captures         |   Semantic search       |   Browse history        |
|   discoveries,          |   via MCP tools         |   at localhost          |
|   decisions & code      |   finds context         |   :37777                |
|                         |                         |                         |
+-------------------------+-------------------------+-------------------------+
|                         |                         |                         |
|   ANALYTICS             |   TAGS & FILTERS        |   FAVORITES             |
|   ----------------      |   ----------------      |   ----------------      |
|   Track tokens,         |   Organize with         |   Bookmark your         |
|   sessions, and         |   custom tags &         |   most important        |
|   concept trends        |   smart filters         |   observations          |
|                         |                         |                         |
+-------------------------+-------------------------+-------------------------+
|                         |                         |                         |
|   EXPORT                |   THEMES                |   SHORTCUTS             |
|   ----------------      |   ----------------      |   ----------------      |
|   JSON, CSV, or         |   Dark & light          |   Full keyboard         |
|   Markdown with         |   mode with             |   navigation in         |
|   custom templates      |   custom themes         |   the web viewer        |
|                         |                         |                         |
+-------------------------+-------------------------+-------------------------+

🔧 How It Works

                         ╔═══════════════════════════════════╗
                         ║      CLAUDE CODE SESSION          ║
                         ╚═══════════════╤═══════════════════╝
                                         │
                    ┌────────────────────┼────────────────────┐
                    │                    │                    │
                    ▼                    ▼                    ▼
           ╔════════════════╗   ╔════════════════╗   ╔════════════════╗
           ║  SessionStart  ║   ║  PostToolUse   ║   ║     Stop       ║
           ║────────────────║   ║────────────────║   ║────────────────║
           ║ Inject context ║   ║ Capture output ║   ║ Generate       ║
           ║ from memory    ║   ║ extract facts  ║   ║ summary        ║
           ╚═══════╤════════╝   ╚═══════╤════════╝   ╚═══════╤════════╝
                   │                    │                    │
                   └────────────────────┼────────────────────┘
                                        │
                         ╔══════════════╧══════════════╗
                         ║      WORKER SERVICE         ║
                         ║    http://localhost:37777   ║
                         ╚══════════════╤══════════════╝
                                        │
              ┌─────────────────────────┼─────────────────────────┐
              │                         │                         │
              ▼                         ▼                         ▼
     ╔════════════════╗       ╔════════════════╗       ╔════════════════╗
     ║    SQLite      ║       ║   ChromaDB     ║       ║  Web Viewer    ║
     ║   Database     ║       ║ Vector Search  ║       ║     UI         ║
     ║────────────────║       ║────────────────║       ║────────────────║
     ║ Observations   ║       ║ Semantic       ║       ║ Timeline       ║
     ║ Summaries      ║       ║ similarity     ║       ║ Search         ║
     ║ Sessions       ║       ║ matching       ║       ║ Analytics      ║
     ╚════════════════╝       ╚════════════════╝       ╚════════════════╝

⚙️ Configuration

Settings stored in ~/.moltbrain/settings.json:

┌──────────────────────────────────────┬─────────┬────────────────────────────┐
│             SETTING                  │ DEFAULT │        DESCRIPTION         │
├──────────────────────────────────────┼─────────┼────────────────────────────┤
│ MOLTBRAIN_WORKER_PORT                │  37777  │ Worker service port        │
├──────────────────────────────────────┼─────────┼────────────────────────────┤
│ MOLTBRAIN_CONTEXT_OBSERVATIONS       │   50    │ Max observations to inject │
├──────────────────────────────────────┼─────────┼────────────────────────────┤
│ MOLTBRAIN_PROVIDER                   │ claude  │ AI provider for summaries  │
├──────────────────────────────────────┼─────────┼────────────────────────────┤
│ MOLTBRAIN_PRUNE_DAYS                 │    0    │ Auto-prune (0 = disabled)  │
├──────────────────────────────────────┼─────────┼────────────────────────────┤
│ MOLTBRAIN_THEME                      │ system  │ UI theme (dark/light/sys)  │
├──────────────────────────────────────┼─────────┼────────────────────────────┤
│ MOLTBRAIN_LOG_LEVEL                  │  info   │ Logging verbosity level    │
└──────────────────────────────────────┴─────────┴────────────────────────────┘

💻 CLI Commands

moltbrain stats          # Show memory statistics
moltbrain export         # Export to markdown  
moltbrain tag <id> <t>   # Tag an observation
moltbrain prune          # Manual cleanup
moltbrain search <q>     # Search observations

📁 Project Structure

moltbrain/
│
├── 📊 benchmarks/         Performance tests
├── 🎨 contrib/            Community modes & themes
├── 📚 docs/               Documentation
├── 📖 examples/           Usage examples & guides
│
├── 🔌 extension/
│   ├── profiles/          Observation modes
│   ├── runtime/           Worker scripts
│   ├── themes/            UI themes (dark/light)
│   ├── snippets/          Code snippets
│   └── templates/         Summary templates
│
├── 🌍 locales/            i18n (en, es, fr)
├── 🗄️ migrations/         Database migrations
├── 📋 schemas/            JSON validation schemas
├── 🛠️ scripts/            Build & utility scripts
│
├── 💻 src/
│   ├── analytics/         Token & session tracking
│   ├── cache/             Query & context caching
│   ├── core/              Core engine
│   ├── export/            JSON/CSV/MD exporters
│   ├── favorites/         Bookmark system
│   ├── filters/           Date/type/project filters
│   ├── formatters/        Output formatters
│   ├── mcp/               MCP server for OpenClaw & MoltBook
│   ├── shortcuts/         Keyboard shortcuts
│   ├── themes/            Theme system
│   └── validators/        Input validation
│
├── 🦞 integrations/
│   └── clawd/             Clawd extension & skill
│
├── 📝 templates/          Export templates
├── 🧪 tests/              Test suites
└── 🔧 tools/              CLI utilities

🔌 API

The worker exposes a REST API at http://localhost:37777:

# Health check
curl http://localhost:37777/health

# Search observations
curl "http://localhost:37777/api/search?q=authentication"

# Get timeline
curl "http://localhost:37777/api/timeline?project=my-app&days=7"

# Export data
curl "http://localhost:37777/api/export?format=json" > backup.json

# Get statistics
curl "http://localhost:37777/api/stats"

🗄️ Storage Dapp

Persistent, Postgres-backed storage for agents and apps. Live at app.moltbrain.dev/storage.

+-----------------------------------------------------------------------------+
|                                                                             |
|   BLOB STORAGE      Content-addressed JSON blobs via SHA-256                |
|   ----------         Store and retrieve data by hash. $0.01 per request.   |
|                                                                             |
|   MEMORY SLOTS      Named key-value slots for agent state                  |
|   ----------         Allocate, write, read. Persistent across sessions.    |
|                                                                             |
|   AGENT VAULT       Per-wallet scoping with label badges                   |
|   ----------         Connect the same wallet your agents use.              |
|                      Browse, view, and delete what they stored.            |
|                                                                             |
+-----------------------------------------------------------------------------+

All endpoints are paid via x402 micropayments ($0.01 USDC on Base). Data is scoped per wallet, backed by Postgres, and survives redeploys. Agents can tag stored data with a label (e.g. "openclaw_session", "virtuals_agent") so the vault shows what stored each item.

# Store a blob
curl -X POST https://app.moltbrain.dev/api/x402/store \
  -H "X-PAYMENT: <x402_header>" \
  -d '{"data": {"key": "value"}, "label": "my_agent"}'

# List your blobs
curl https://app.moltbrain.dev/api/x402/list/blobs \
  -H "X-PAYMENT: <x402_header>"

# Full catalog
curl https://app.moltbrain.dev/api/x402/catalog

🎮 Virtuals Protocol Integration

GAME SDK plugin that gives any Virtuals Protocol AI agent persistent memory and storage via MoltBrain.

npm install @moltbrain/game-plugin

import { GameAgent } from "@virtuals-protocol/game";
import { MoltBrainPlugin } from "@moltbrain/game-plugin";

const moltbrain = new MoltBrainPlugin({
  privateKey: process.env.AGENT_PRIVATE_KEY!, // wallet with USDC on Base
});

const agent = new GameAgent(process.env.GAME_API_KEY!, {
  name: "My Agent",
  goal: "Remember everything across sessions",
  description: "An agent with persistent memory via MoltBrain",
  workers: [moltbrain.getWorker()],
});

await agent.init();
await agent.step({ verbose: true });

9 functions available: moltbrain_chat, moltbrain_search, moltbrain_store, moltbrain_retrieve, moltbrain_allocate_slot, moltbrain_write_slot, moltbrain_read_slot, moltbrain_stats, moltbrain_capacity. Everything the agent stores shows up in the vault dapp at app.moltbrain.dev/storage. Connect the same wallet to browse it. See the full plugin repo: github.com/nhevers/Moltbrain-virtuals

🦞 OpenClaw Integration

Works with OpenClaw (116k+ stars) - the popular personal AI assistant!

+-----------------------------------------------------------------------------+
|                                                                             |
|   EXTENSION        Add to OpenClaw's extensions/ folder                     |
|   ----------       Full lifecycle hooks integration                         |
|                                                                             |
|   SKILL            Install as an OpenClaw skill                              |
|   ----------       recall_context, search_memories, save_memory tools       |
|                                                                             |
|   MCP SERVER       Protocol-based integration                               |
|   ----------       Works with any MCP-compatible client                     |
|                                                                             |
+-----------------------------------------------------------------------------+

Quick setup:

# As OpenClaw extension
cd ~/.openclaw/extensions
git clone https://github.com/nhevers/moltbrain.git moltbrain
cd moltbrain/integrations/openclaw
npm install && npm run build

# Enable the plugin (required for bundled installations)
pnpm openclaw plugins enable moltbrain

# Or via MCP
npm run mcp:start

Note: If installing as a bundled extension (in OpenClaw's extensions/ directory), you must explicitly enable it: pnpm openclaw plugins enable moltbrain See integrations/openclaw/README.md for full setup guide.

📚 MoltBook Integration

Works with MoltBook - the social network for AI agents! Share memories, learn from other agents, and build collective knowledge. Quick setup:

# Install MoltBook MCP integration
npm install --save @moltbrain/moltbook-mcp

# Configure in your MoltBrain settings
{
  "MOLTBRAIN_MOLTBOOK_ENABLED": true,
  "MOLTBRAIN_MOLTBOOK_API_URL": "https://moltbook.com"
}

See integrations/moltbook/README.md for full setup guide.

💻 Claude Code Integration

Works with Claude Code via the plugin marketplace:

/plugin marketplace add nhevers/moltbrain
/plugin install moltbrain

📋 Requirements

╔══════════════════════════════════════╗
║                                      ║
║   •  Node.js 18+  or  Bun 1.0+      ║
║   •  OpenClaw, MoltBook, or Claude Code ║
║                                      ║
╚══════════════════════════════════════╝