A shared persistent memory for every AI tool you use

Claude Code

Cursor

Windsurf

VS Code Copilot

ChatGPT

MCP Server • pgvector • Local LLMs • 100% Local • ~$0/month

The Problem

1 Every AI tool has amnesia. Close the chat, lose the context.

2 Switch from Cursor to Claude Code? Start from scratch.

3 That architecture decision you made last Tuesday? Gone.

4 Bugs you already fixed? Your AI will suggest the same broken approach again.

You're the only one remembering anything. Your AI tools should be doing that for you.

The Solution

One shared brain that every agent reads and writes to, automatically, silently, without you lifting a finger.

🧠 Capture in Claude Code at 2am

🔍 Recall in Cursor the next morning

✨ Your AI already knows the context

How It Works

Your thought / conversation
         |
         v
  [remember / capture_context]
         |
         +---> Ollama        -->  vector embedding (768 dims)
         +---> LLM / heuristic -->  metadata (type, people, topics)
         +---> project scope   -->  filter by project
                  |
                  v
       PostgreSQL + pgvector
       (annotations, ratings, access tracking)
                  |
                  v
       MCP Server (stdio / HTTP)  --  11 tools
                  |
         +-------+--------+--------+--------+
         v       v        v        v        v
      Claude  Cursor  Windsurf  Copilot  ChatGPT

Silent Auto-Capture

Agents capture without being asked. You never say "remember this."

1 You fix a bug in Claude Code. The agent silently calls capture_context

2 The brain decomposes it into atomic memories: root cause, fix applied, decision made

3 Each gets a vector embedding + metadata (type, people, topics, action items)

4 Dedup check: near-identical memories are skipped automatically

5 Stored in PostgreSQL. Searchable by meaning across every future session.

Proactive Auto-Recall

Agents search the brain before starting tasks. Prior context surfaces automatically.

1 Next morning, open Cursor and start working on the same feature

2 Cursor silently calls search("authentication token validation")

3 Finds the bug fix from last night's Claude Code session, by meaning, not keywords

4 Cursor already knows: the root cause, the fix, and the decision to use integration tests

"Why does my AI suddenly remember my project?" Because the brain captured it automatically.

One-Command Setup

$ python server.py wire --check

Scanning for AI tools...
Claude Desktop up-to-date
Claude Code CLI up-to-date
Cursor            needs-config
Windsurf          up-to-date
VS Code Copilot needs-config
ChatGPT Desktop not-installed

$ python server.py wire

Cursor           wired ✓
VS Code Copilot wired ✓

Done. All agents connected to Open Brain.

11 MCP Tools

capture_context

Auto-ingest session text, decompose into atomic memories

Semantic search by meaning. Returns 200-char previews.

recall

Get full memory content by ID, tracks access

remember

Store a single explicit thought or decision

rate

Upvote / downvote to surface the best memories

annotate

Attach corrections or warnings to existing memories

prune

Remove stale, never-accessed memories (dry-run first)

+ 4 more

list_recent, stats, forget, forget_many

Smart Batching

GPU-aware processing that avoids model thrashing on local hardware

Scenario	Naive Approach	Open Brain
5 memories, dual model	~200s (constant GPU swaps)	~15s (batched)
Model loads per capture	2 × N memories	2 total
Embedding + metadata	Interleaved (thrashing)	Phased (embed all, then extract all)

Phase 1: LLM decomposes text into atomic memories → Phase 2: Batch all embeddings → Phase 3: Batch all metadata → Phase 4: Store with dedup

By The Numbers

MCP Tools

~100ms

Search Latency

Supported Clients

Monthly Cost (local)

Command to Wire All Agents

Cloud Dependencies

100%

Your Data Stays Local

Open Brain

Your AI tools should never forget.

Docs: shep-engineering.github.io/open-brain
GitHub: github.com/shep-engineering/open-brain
Stack: Python • MCP • pgvector • Ollama • Docker

The user's only job is to work.
The brain's job is to remember everything.