Universal Memory Protocol | Universal Memory Protocol<br>Skip to content Universal Memory Protocol<br>A transport-neutral memory protocol for AI agents. What MCP did for tools, UMP does for memory - negotiated operations over a portable, signed, bi-temporal record that any harness can speak and any store can serve.
Read the spec Quickstart GitHub
The third interoperability layer<br>Section titled “The third interoperability layer”
Agents can already call tools (MCP ) and talk to each other (A2A ). What they<br>can’t do is carry memory across sessions, agents, and vendors . Every harness<br>reinvents memory privately and non-portably. UMP fixes that.
In simple terms: you already have useful memories scattered across agent files,<br>Claude/Codex project notes, Recall exports, Obsidian folders, Postgres, Redis,<br>SQLite, and vector databases. UMP turns those into one portable memory shape and<br>one small operation set, so new agents and new stores can extend the same memory<br>instead of starting over.
Tools - MCP<br>Model Context Protocol standardized how agents call functions and read resources.
Coordination - A2A<br>Agent2Agent standardized how agents discover and invoke one another.
Memory - UMP<br>Universal Memory Protocol standardizes how agents remember - portable knowledge across sessions, agents, and vendors.
Implement it<br>Section titled “Implement it”
Use the MCP server when you want agent memory immediately. Use the TypeScript SDK<br>when you are building a memory-aware app or agent runtime. Use HTTP when the<br>client is Python, Go, Swift, a browser, or anything else that can send JSON.
// MCP host config: Claude Code, Codex, Cursor, or any MCP client.
"mcpServers": {
"ump": {
"command": "npx",
"args": ["-y", "@universalmemoryprotocol/core", "ump-memory"]
import {
JsonFileStore,
UmpServer,
generateKeyPair,
} from "@universalmemoryprotocol/core";
const key = generateKeyPair();
const store = await JsonFileStore.open(".ump/memory.ump.json");
const ump = new UmpServer({
name: "my-agent",
version: "1.0.0",
conformance: "L2",
store,
key,
});
await ump.remember({
kind: "procedural",
body: { text: "Use pnpm for this repository." },
scope: { owner: key.did, project: "github.com/acme/app", visibility: "private" },
provenance: { actor: key.did, actor_kind: "user", method: "user_correction" },
});
const memories = await ump.recall({
query: "package manager",
scope: { owner: key.did, project: "github.com/acme/app" },
});
Terminal window# Any language: expose JSON over HTTP.
UMP_HTTP=4000 npx -y @universalmemoryprotocol/core ump-memory
import requests
base = "http://localhost:4000"
owner = requests.get(f"{base}/.well-known/ump.json").json()["owner"]
requests.post(f"{base}/ump/remember", json={
"kind": "semantic",
"body": {"text": "User prefers concise release notes."},
"scope": {"owner": owner, "project": "github.com/acme/app", "visibility": "private"},
"provenance": {"actor": owner, "actor_kind": "user", "method": "user_correction"},
}).raise_for_status()
hits = requests.post(f"{base}/ump/recall", json={
"query": "release note preference",
"scope": {"owner": owner, "project": "github.com/acme/app"},
}).json()["results"]
Why it’s shaped like this<br>Section titled “Why it’s shaped like this”
UMP is not a new transport protocol . It is an application-level memory<br>protocol that rides existing transports. The lesson of MCP is *minimal primitives
existing rails + great SDKs + neutral governance*.
Rides MCP<br>The primary binding is an MCP profile (ump.* tools). Any MCP host - Claude<br>Code, Codex - can use UMP today, with zero new transport.
Six operations<br>capabilities · recall · remember · revise · forget · get (+ optional<br>feedback/subscribe). A conforming client is ~100 lines.
One portable record<br>Typed, scoped, bi-temporal, signed JSON. Reuses W3C PROV + DID - no new vocabulary.
Adopt incrementally<br>Four conformance levels. Ship an *.ump.json export (L0) today; wire the full<br>runtime (L3) when ready.
Any store can serve it<br>Section titled “Any store can serve it”
UMP is a protocol surface, not a database bet. @universalmemoryprotocol/core ships practical<br>implementations for local files, SQL databases, Redis, Recall, and vector engines<br>so teams can adopt UMP where they already store memory.
Files first<br>JsonFileStore writes portable memory.ump.json; MarkdownDirectoryStore<br>writes human-editable *.ump.md records for repos and Obsidian-style vaults.
SQL + cache<br>PostgresStore, SqliteStore, and RedisStore accept your existing client.<br>No native database driver is bundled into the core package.
Vector databases<br>VectorStore plus QdrantStore, PineconeStore, and WeaviateStore wrappers<br>let embedding-backed engines keep their own retrieval quality.
Recall engine adapter<br>Recall is one implementation: a richer memory engine behind the same UMP<br>interface, not a dependency or lock-in.
Bring existing memory with you<br>Section titled “Bring existing memory with you”
People already have memory scattered through...