Open-source MCP memory server

Beautiful Brain

A living memory graph your agents consult before they act — and grow after. It remembers decisions, lessons, people, and the documents behind them, on infrastructure you own, in a graph you can open and read.

Connect a client Ask Claude Ask ChatGPT
v1.2.0 streamable http oauth enabled api keys enabled

The problem

Most AI sessions forget the work that made the last answer good.

Every session re-derives context from scratch. The decisions, the reasons, the lessons — gone when the window closes. Beautiful Brain keeps the useful residue.

The idea

Useful intelligence is cumulative. Memory should be inspectable, portable, and yours.

Recall

One vector space, plus a graph that thinks.

Notes, images, audio, video, and documents all land in the same searchable space, so “that diagram from the pricing discussion” is findable by meaning, not filename. When you ask for something, the brain weighs three things at once: the words you used, what you meant, and what’s connected to what. And it shows its work — every result says why it came back. Prefer fully offline? A local model handles text on your machine.

Linking

Typed synapses, and an algorithm that tends them.

Memories don’t just sit near each other — they’re connected with meaning: this supports that, this contradicts that, this was learned from that, use this next time. You can draw links yourself, and a caretaker algorithm quietly finds the ones you missed. It only ever proposes; you approve. It strengthens connections that keep proving useful, and it surfaces contradictions instead of hiding them.

Every applied repair leaves an audit trail — and a precise link is never replaced with a vague one.

Collaborate

Share memory, not access to it.

Send a memory to a colleague as a snapshot — nothing lands in their brain unless they choose to keep it. Hand off tasks the same way. For whole projects, a shared repo becomes the courier: every memory travels sealed end-to-end, so the host in the middle carries your context without ever being able to read it.

The same class of encryption secure messengers use, keyed per member — and tampering is detected, never silently accepted.

Multi-agent

A team of agents, one brain.

Run several agents on the same project and they coordinate through a shared board — started, done, blocked — see what the others are on, and write what they learned into the same brain. Status notes expire on their own after 45 minutes; there’s nothing to clean up.

Connectors

One brain, all your tools.

Your brain can hold the connections to your other tools — GitHub, Notion, mail, anything that speaks MCP — and hand an agent exactly the right one for the job. Finding a tool is instant because the catalog is kept warm, and whatever a third-party tool sends back is treated as information, never as instructions.

Skills

It absorbs what works.

When a piece of work goes unusually well, the brain notices. A background process — the Cognitive Pulse — distills what worked into a reusable pattern and proposes it; nothing changes without sign-off. The next time a similar task shows up, the pattern is already waiting, before planning even starts.

Artifacts & books

Memory becomes work product.

The things you actually make — documents, diagrams, pages, code — live in the brain as artifacts that render beautifully for humans, not just as text for machines. Gather related ones into a book: one shareable thing, laid out as a canvas or read page by page.

What it remembers

01

A graph, not a pile

Memories carry typed edges — caused_by, contradicts, learned_from, depends_on — so recall follows the shape of how decisions actually happened.

02

Multimodal recall

Text, images, audio, video, and PDFs share one vector space via gemini-embedding-2. A written cue finds the sketch; spreading activation surfaces the context around it, not just the match.

03

Lessons that change behavior

A lesson is structured, not sentimental: the trigger to watch for, the wrong default, the better next action, and the evidence. Agents replay them before repeating a mistake.

04

Cognitive Pulse

A background maintenance runner that notices stale tasks, orphans, and duplicates — then proposes. Review and application stay explicit; your history is never quietly rewritten.

Connect

Point a client at the graph

Works with Claude connectors, ChatGPT developer mode, Claude Code, Cursor, and any client that speaks Streamable HTTP MCP. OAuth and API keys can run side by side.

MCP endpoint
https://turbo-brain.com/mcp
Transport
Streamable HTTP
Authorization server
https://turbo-brain.com
Scopes
openid profile email offline_access
OAuth
enabled
API keys
enabled — Authorization: Bearer or X-API-Key
Version
1.2.0

Agent first

Install the skill, add the server, and start every relevant task by asking the graph what it already knows.

# 1. Install the agent skill
mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills/beautiful-brain"
curl -fsSL https://turbo-brain.com/skills/beautiful-brain/SKILL.md \
  -o "${CODEX_HOME:-$HOME/.codex}/skills/beautiful-brain/SKILL.md"

# 2. Connect the MCP server
claude mcp add --transport http beautiful-brain https://turbo-brain.com/mcp

# 3. First use
Call reflect({ topic: "<project>", goal: "<what you are doing>" })
For repeat work: process_patterns({ action: "find", task: "<task>" })

Self-host with your agent

Want your own instance? Hand the setup to your agent: it fetches the self-host skill and drives the whole install — prerequisites, Docker, config, verification — asking you at most three questions.

Ask Claude Ask ChatGPT

Tool surface

memory capture_memory · update_memory · search_memory · recall_memory · get_context · link_memory · reflect   artifacts & books get_artifact · show_artifact · book   skills & patterns skills · process_patterns   collaboration collab · space · board   connectors search · fetch · find_connector_tools · call_connector_tool   maintenance meta · repair_synapses · backfill_memory_embeddings