How do I use Cerebro?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Cerebro remember that the database connection is in prod.yaml" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Cerebro

by Professor-Low

Overview Schema Related Servers Score Discussions

Python

Local

Why Cerebro?

:brain: Remember Everything

Your AI gets total recall. Conversations, facts, and context carry across sessions — nothing is ever forgotten.

Episodic memory for events, semantic for facts, working for active reasoning
Hybrid semantic + keyword search across all memories
Session continuity — pick up exactly where you left off

:gear: Learn and Adapt

Your AI gets smarter with every interaction. Solutions, failures, and patterns are tracked automatically.

Auto-detects solutions, failures, and antipatterns
Patterns auto-promote to trusted knowledge after 3+ confirmations
Tracks past mistakes and avoids repeating them

:crystal_ball: Reason and Predict

Go beyond retrieval into genuine reasoning. Cerebro builds causal models and catches problems before they happen.

Causal models with "what-if" simulation
Predictive failure anticipation from historical patterns
Hallucination detection and confidence scoring

Related MCP server: MemPalace

See It In Action

Note: In the demo, Claude Code calls tools prefixed with ai-memory — that's just the MCP server name in the config. The server is Cerebro. Name it anything you like in your mcp.json (we recommend "cerebro").

Quick Start

Prerequisites

Python 3.10+
Claude Code or any MCP-compatible client

1. Install

pip install cerebro-ai

For semantic search (recommended — uses FAISS + sentence-transformers):

pip install cerebro-ai[embeddings]

Without [embeddings], Cerebro falls back to keyword-only search. Still functional, but semantic search is significantly more powerful.

2. Initialize

cerebro init

This creates your local memory store at ~/.cerebro/data.

3. Add to Claude Code

Add this to your MCP config (~/.claude/mcp.json):

{
  "mcpServers": {
    "cerebro": {
      "command": "cerebro",
      "args": ["serve"]
    }
  }
}

4. Verify

Restart Claude Code and run /mcp — you should see 49 Cerebro tools. Start a conversation and Cerebro will automatically begin building your memory.

5. Tell Claude How to Use Memory (Recommended)

Add this to your ~/.claude/CLAUDE.md:

## AI Memory (Cerebro)
- At session start, call `check_session_continuation` to resume previous work
- Before answering questions, call `search` to check if relevant memory exists
- When you solve a problem, call `record_learning` to save the solution
- Call `get_corrections` to avoid repeating known mistakes
- Use `update_active_work` before ending a session with pending work

This tells Claude how to use the 49 memory tools proactively, instead of waiting for you to ask.

6. Install Hooks (Optional)

cerebro hooks install

Hooks automate memory at lifecycle events — saving conversations on exit, injecting context on each message, restoring continuity on start. Run cerebro hooks status to see what's installed.

Health Check

cerebro doctor

Note: If you installed with [embeddings], the first run downloads a ~438 MB sentence-transformer model. Subsequent starts are instant.

The Full Experience

The MCP tools give your AI persistent memory. Cerebro Pro wraps it in a complete cognitive desktop — where your AI thinks, acts, and evolves autonomously.

What You Get

These are the tools you'll use daily. Cerebro has 49 total — here are the highlights:

Tool	What it does
`search`	Find anything in memory — hybrid semantic + keyword search across all conversations, facts, and learnings
`record_learning`	Save a solution, failure, or antipattern. Next time you hit the same problem, Cerebro surfaces it
`get_corrections`	Check what your AI got wrong before — so it doesn't repeat the same mistakes
`check_session_continuation`	Pick up where you left off. Detects in-progress work and restores full context
`working_memory`	Active reasoning state: hypotheses, evidence chains, scratch notes that persist across compactions
`causal`	Build cause-effect models. Ask "what causes X?" or simulate "what if I do Y?"
`predict`	Anticipate failures before they happen based on patterns from your history
`get_user_profile`	Your AI knows your preferences, projects, environment, and goals — no re-explaining

See all 49 tools below or browse the full MCP Tools Reference.

Your First Conversation

Once Cerebro is connected, try this:

You: "Search my memory for anything about Docker networking"
Claude: calls search("Docker networking") → finds nothing yet

You: "I just learned that Docker containers on the same network
       can reach each other by container name, not IP."
Claude: calls record_learning(solution, ...)
        → Saved! Next time you ask about Docker networking, this surfaces automatically.

You: "What mistakes have I made before?"
Claude: calls get_corrections() → shows past corrections so it doesn't repeat them

Every session builds on the last. After a few conversations, Claude knows your projects, preferences, and environment without re-explaining.

All 49 MCP Tools

Cerebro exposes 49 tools through the Model Context Protocol, organized into 10 categories. Every tool works with any MCP-compatible AI client.

Tool	Description
`save_conversation_ultimate`	Save conversations with comprehensive extraction of facts, entities, actions, and code snippets
`search`	Hybrid semantic + keyword search across all memories (recommended default)
`search_knowledge_base`	Search the central knowledge base for facts, learnings, and discoveries
`search_by_device`	Filter memory searches by device origin (e.g., only laptop conversations)
`get_chunk`	Retrieve specific memory chunks by ID for context injection

Tool	Description
`get_entity_info`	Get information about any entity (tool, person, server, etc.) with conversation history
`get_timeline`	Chronological timeline of actions and decisions for a given month
`find_file_paths`	Find all file paths mentioned in conversations with purpose and context
`get_user_context`	Comprehensive user context: goals, preferences, technical environment
`get_user_profile`	Full personal profile: identity, relationships, projects, preferences

Tool	Description
`memory_type: query_episodic`	Query event memories by date, actor, or emotional state
`memory_type: query_semantic`	Query general facts by domain or keyword
`memory_type: save_episodic`	Save event memories with emotional state and outcome
`memory_type: save_semantic`	Save factual knowledge with domain classification
`working_memory`	Active reasoning state: hypotheses, evidence chains, scratch notes
`consolidate`	Cluster episodes, create abstractions, strengthen connections, prune redundancies

Tool	Description
`reason`	Active reasoning over memories: analyze, find insights, validate hypotheses
`causal`	Causal models: add cause-effect links, find causes/effects, simulate "what-if" interventions
`predict`	Predictive simulation: anticipate failures, check patterns, suggest preventive actions
`self_model`	Continuous self-modeling: confidence tracking, uncertainty, hallucination checks
`analyze`	Pattern analysis, knowledge gap detection, skill development tracking

Tool	Description
`record_learning`	Record solutions, failures, or antipatterns with tags and context
`find_learning`	Search for proven solutions or known antipatterns by problem description
`analyze_conversation_learnings`	Extract learnings from a past conversation automatically
`get_corrections`	Retrieve corrections Claude learned from the user to avoid repeating mistakes

Tool	Description
`check_session_continuation`	Check for recent work-in-progress to continue
`get_continuation_context`	Get full context for resuming a previous session
`update_active_work`	Track current project state for session handoff
`session_handoff`	Save and restore working memory across sessions
`working_memory: export/import`	Export active reasoning state for handoff, import to restore
`session`	Session info: thread history, active sessions, summaries, continuation detection

Tool	Description
`preferences`	Track and evolve user preferences with confidence weighting and contradiction detection
`personality`	Personality evolution: traits, consistency checks, feedback-driven adaptation
`goals`	Detect, track, and reason about user goals with blocker identification
`suggest_questions`	Generate questions to fill knowledge gaps in the user profile
`get_suggestions`	Proactive context-aware suggestions based on current situation and history

Tool	Description
`projects`	Project lifecycle: state, active list, stale detection, auto-update, activity summaries
`project_evolution`	Version tracking: record releases, view timeline, manage superseded versions

Tool	Description
`rebuild_vector_index`	Rebuild the FAISS vector search index after bulk updates
`decay`	Storage decay management: run decay cycles, preview, manage golden (protected) items
`self_report`	Self-improvement reports: performance metrics, before/after tracking
`system_health_check`	Health check across all components: storage, embeddings, indexes, database
`quality`	Memory quality: deduplication, merge, fact linking, quality scoring

Tool	Description
`meta_learn`	Retrieval strategy optimization: A/B testing, parameter tuning, performance tracking
`memory_type`	Query and manage episodic vs semantic memory types with stats and migration
`privacy`	Secret detection, redaction statistics, sensitive conversation identification
`device`	Device registration and identification for multi-device memory isolation
`branch`	Exploration branches: create divergent reasoning paths, mark chosen/abandoned
`conversation`	Conversation management: tagging, notes, relevance scoring

How It Works

graph LR
  A[Your AI Client] <-->|MCP Protocol| B[Cerebro Server]
  B --> C[FAISS Vector Search]
  B --> D[Knowledge Base]
  B --> E[File Storage]

All data stays on your machine. No cloud, no API keys, no telemetry.

Free vs Pro

Capability	Free (This Repo)	Pro (cerebro.life)
Memory	49-tool MCP server. Full cognitive architecture.	Everything in Free + dashboard visualization of your memory graph and health stats.
Interface	Claude Code CLI or any MCP client.	Native desktop app with Mind Chat, 3D neural constellation, real-time activity.
Agents	Single Claude session with persistent memory.	Agent swarms — multiple Claudes collaborating on complex tasks autonomously.
Browser	Not included.	Autonomous browser agents: research, navigate, extract — with live video preview.
Automations	Not included.	Calendar-driven recurring tasks, scheduled research, automated workflows.
Cognitive Loop	Not included.	OODA cycle: Observe-Orient-Decide-Act. Your AI thinks and acts continuously.

Configuration

Cerebro works out of the box with zero configuration. All settings are optional and controlled via environment variables:

Variable	Default	Description
`CEREBRO_DATA_DIR`	`~/.cerebro/data`	Base directory for all Cerebro data
`CEREBRO_EMBEDDING_MODEL`	`all-mpnet-base-v2`	Sentence transformer model for semantic search
`CEREBRO_EMBEDDING_DIM`	`768`	Embedding vector dimensions
`CEREBRO_LOG_LEVEL`	`INFO`	Logging level
`CEREBRO_LLM_URL`	(none)	Optional local LLM endpoint for deeper reasoning
`CEREBRO_LLM_MODEL`	(none)	Optional local LLM model name

Set them in your MCP config:

{
  "mcpServers": {
    "cerebro": {
      "command": "cerebro",
      "args": ["serve"],
      "env": {
        "CEREBRO_DATA_DIR": "/path/to/your/data"
      }
    }
  }
}

Troubleshooting

Problem	Solution
First start is slow	If you installed `[embeddings]`, the sentence-transformer model (~438 MB) downloads on first run. This is a one-time download.
"No module named 'src'"	Install via `pip install cerebro-ai`, not by running the source directly.
MCP tools not showing up	Check `~/.claude/mcp.json` is valid JSON, restart Claude Code, and run `/mcp` to verify.
Hook errors blocking Claude	Hooks should never block — they always output `{"continue": true}`. Check stderr output with `cerebro hooks status`. If a hook is broken, run `cerebro hooks uninstall` to remove all hooks.
"cerebro: command not found"	Ensure the pip scripts directory is in your PATH. Try `python -m src.cli serve` as a fallback.

Contributing

Contributions are welcome — bug fixes, new MCP tools, documentation improvements, or feature ideas.

Please read the Contributing Guide before submitting a pull request. All contributions must be compatible with the AGPL-3.0 license.

License & Attribution

Copyright (C) 2026 Michael Lopez (Professor-Low)

Cerebro is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0).
See LICENSE for details.

What AGPL-3.0 means: If you use Cerebro's code in your own product — including as a network service — you must release your modified source code under the same license and give proper attribution. This protects the project from being taken proprietary.

Created and maintained by Michael Lopez (Professor-Low)

If Cerebro helps you, consider giving it a star — it helps others find the project. cerebro.life

This server cannot be installed

license - permissive license

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

<1hResponse time

2dRelease cycle

6Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly
Lightport: Open-Sourcing Glama's AI Gateway
By punkpeye on April 27, 2026.
OpenAI
open source

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Professor-Low/Cerebro'

If you have feedback or need assistance with the MCP directory API, please join our Discord server