Open Memory Protocol (OMP)

An open standard for portable, interoperable AI memory across tools, sessions, and devices.

Try it now — no install needed:

https://omp-server-production.up.railway.app/app

The Problem

Every AI tool remembers you differently — and only within its own walls.

• Claude knows what you told it yesterday. Cursor doesn't.
• ChatGPT learned your preferences. Your custom agent hasn't.
• Copilot saw your code style. Your terminal AI is starting from zero.

Every time you switch tools, your AI forgets you. You repeat yourself. Context is lost. The AI that was finally starting to know you resets to a stranger.

This is the AI memory silo problem. And it has the same solution as every silo problem before it: an open protocol.

What is OMP?

Open Memory Protocol is a vendor-neutral specification for how AI tools store, retrieve, and share memory about users and their context.

It is:

• A specification — a precise definition of memory objects, storage format, and HTTP API
• A reference server — self-hostable, open-source, runs in Docker in one command
• A set of SDKs — TypeScript and Python libraries for building OMP-compatible tools
• A set of adapters — plug-ins for Claude (MCP), OpenAI, Cursor, and more

Any AI tool that implements OMP can instantly share memory with any other OMP-compatible tool.

Quick Start

Option A — Hosted server (zero setup)

The OMP reference server is publicly hosted. Just point your tools at it:

https://omp-server-production.up.railway.app

curl https://omp-server-production.up.railway.app/v1/health
# {"status":"ok","version":"0.1","compliance":"OMP-Core","memories_count":0}

Mobile PWA — open on any phone, no install needed:

https://omp-server-production.up.railway.app/app

Option B — Self-hosted (your own server)

Requirements: Node.js 22 or newer

npx omp-server

Or with Docker:

docker run -p 3456:3456 -v omp-data:/data ghcr.io/smjai/omp-server

Your server is now running at http://localhost:3456. Test it:

curl http://localhost:3456/v1/health
# {"status":"ok","version":"0.1","compliance":"OMP-Core","memories_count":0}

2. Connect Claude (via MCP)

Replace http://localhost:3456 with https://omp-server-production.up.railway.app if using the hosted server.

Find your Claude Desktop config file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json
• Windows (Store app): %LOCALAPPDATA%\Packages\Claude_pzs8sxrjxfjjc\LocalCache\Roaming\Claude\claude_desktop_config.json

Add to it:

{
  "mcpServers": {
    "omp": {
      "command": "npx",
      "args": ["omp-mcp"],
      "env": {
        "OMP_SERVER": "http://localhost:3456",
        "OMP_API_KEY": "your-omp-key"
      }
    }
  }
}

To enable AI-powered memory extraction and compression, also set these on the server:

OMP_AI_PROVIDER=anthropic   # or "openai"
OMP_AI_API_KEY=sk-ant-...   # your Anthropic or OpenAI key

3. Make Claude use OMP automatically

Without a system prompt, you have to ask Claude to use OMP tools manually. To make it automatic, create a Project in Claude Desktop and add this system prompt:

You have access to OMP memory tools (omp_remember, omp_recall, omp_list).

At the start of every conversation, use omp_recall to search for memories 
relevant to what the user is asking about.

Whenever the user shares anything worth remembering — preferences, decisions, 
projects, facts about themselves — automatically use omp_remember to save it 
without being asked.

Never tell the user you are saving a memory. Just do it silently.

This makes OMP invisible — Claude just remembers, automatically, across every session.

4. Continue a conversation in a different AI tool — automatically

The OMP Bridge browser extension makes this seamless. No copying JSON, no manual steps.

How it works:

1. Chat with ChatGPT about anything
2. The extension silently saves your conversation to your OMP server every 2 minutes
3. Open Claude.ai (or any other AI) to start a new chat
4. A toast notification appears: "Continue from ChatGPT? [topic]"
5. Click "Continue in Claude" — OMP generates a natural handoff brief and injects it
6. Claude responds as if it was in the conversation the whole time

You can also save manually at any point: click the OMP Bridge extension icon → "Save this conversation to OMP".

The handoff brief (AI-generated) looks like:

We were exploring MCP (Model Context Protocol) with ChatGPT — specifically what it
is, how it compares to function calling, and why it's more portable across providers.
I'm ready to go deeper on real-world implementations. Can you show me how to build
an MCP server from scratch?

API — save and replay conversations programmatically:

# Save a conversation
curl -X POST http://localhost:3456/v1/conversations \
  -H "Content-Type: application/json" \
  -d '{
    "model": "chatgpt",
    "topic": "MCP deep dive",
    "messages": [
      {"role": "user", "content": "Tell me about MCP"},
      {"role": "assistant", "content": "MCP stands for..."}
    ]
  }'

# Generate a handoff brief for another model
curl -X POST http://localhost:3456/v1/handoff \
  -H "Content-Type: application/json" \
  -d '{
    "conversation_id": "conv_abc123",
    "target_model": "claude"
  }'
# → { "brief": "We were exploring MCP with ChatGPT...", "topic": "...", "source_model": "chatgpt" }

Write a memory from any tool

curl -X POST http://localhost:3456/v1/memories \
  -H "Content-Type: application/json" \
  -d '{
    "content": "User prefers TypeScript over JavaScript and dislikes verbose comments",
    "type": "semantic",
    "source": { "tool": "claude" },
    "tags": ["preferences", "coding"]
  }'

Query from any other tool

curl "http://localhost:3456/v1/memories/search?q=coding+preferences"

How It Works

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Claude    │     │   Cursor    │     │  Your Agent │
│  (MCP)      │     │  (SDK)      │     │  (REST API) │
└──────┬──────┘     └──────┬──────┘     └──────┬──────┘
       │                   │                   │
       └───────────────────┼───────────────────┘
                           │
                  ┌────────▼────────┐
                  │   OMP Server    │
                  │  (self-hosted)  │
                  │                 │
                  │  ┌───────────┐  │
                  │  │  SQLite   │  │
                  │  │  / Pgvec  │  │
                  │  └───────────┘  │
                  └─────────────────┘

Every tool reads and writes to a single OMP server you control. One memory store. All tools. Zero silos.

The Spec

OMP defines:

• Memory Object — the canonical schema for a memory (content, type, source, tags, timestamps, optional embedding)
• Memory Types — episodic (events), semantic (facts/preferences), procedural (how-to knowledge)
• REST API — standard CRUD + semantic search endpoints
• Authentication — bearer token, per-tool API keys
• Export/Import — portable JSON format for moving memories between servers

Read the full specification: SPEC.md

Memory Object

{
  "id": "mem_01j9xk2p3q4r5s6t",
  "content": "User is building a fintech startup, prefers clean architecture, dislikes over-engineering",
  "type": "semantic",
  "source": {
    "tool": "claude",
    "session_id": "sess_abc123",
    "timestamp": "2026-06-29T12:00:00Z"
  },
  "tags": ["profile", "preferences", "engineering"],
  "created_at": "2026-06-29T12:00:00Z",
  "updated_at": "2026-06-29T12:00:00Z",
  "expires_at": null
}

Adapters

AI Coding Tools (Claude Code, Cursor, Copilot, Codex CLI)

Install the omp CLI:

npm install -g omp-cli

Claude Code (VS Code or terminal) — full MCP integration:

omp setup claude-code   # prints the exact command to run
# then run:
claude mcp add omp -- npx omp-mcp

Claude Code gets omp_remember, omp_recall, omp_compress as tools — same as Claude Desktop.

Cursor — injects memories into .cursorrules:

omp injec