SaveState as an MCP Memory Provider

Run SaveState as a Model Context Protocol server. Claude Code, Cursor, Codex, and any MCP-compatible client can read your encrypted memory archive in real time — no manual export, no platform silo.

⚡ SaveState is the only MCP memory provider with end-to-end encryption, cross-platform portability, and an open archive format. Your keys, your data, every client.

Why MCP changes the framing

Most "AI memory" tools today are either platform silos (ChatGPT Memory, Claude Projects) or unencrypted runtime stores (community MCP memory servers). SaveState ships both halves: an encrypted, portable archive and the runtime tools to query it from any client. Snapshot once, recall everywhere.

Quick install (Claude Code)

Add SaveState to ~/.claude/settings.json:

{
  "mcpServers": {
    "savestate": {
      "command": "npx",
      "args": ["-y", "@savestate/cli", "mcp"],
      "env": {
        "SAVESTATE_MCP_PASSPHRASE": "your-passphrase-here"
      }
    }
  }
}

Then restart Claude Code. The new tools (savestate_search_snapshots, savestate_stats, plus the memory + snapshot toolset) are now available to the model.

Cursor

Add to .cursor/mcp.json or ~/.cursor/mcp.json:

{
  "mcpServers": {
    "savestate": {
      "command": "npx",
      "args": ["-y", "@savestate/cli", "mcp"]
    }
  }
}

Codex CLI / OpenAI Codex

codex mcp add savestate -- npx -y @savestate/cli mcp

Tools exposed

Tool	What it does
`savestate_snapshot`	Create a new encrypted snapshot of the current AI state. `limit` is a positive integer up to 1000. `offset` is a non-negative integer up to 1000.
`savestate_restore`	Restore a specific snapshot. `limit` is a positive integer up to 1000. `offset` is a non-negative integer up to 1000.
`savestate_list`	List available snapshots. `limit` is a positive integer up to 1000 (default 10). `offset` is a non-negative integer up to 1000. The optional `platform` filter is case-insensitive.
`savestate_status`	Check SaveState initialization + adapter status. `limit` is a positive integer up to 1000. `offset` is a non-negative integer up to 1000.
`savestate_search_snapshots`	Full-text search across every snapshot — even on a different platform. Search with a word or phrase: exact phrase matches rank highest, while individual terms can still surface partial matches. The killer feature. Optional inclusive `since` and `until` ISO-8601 date or timestamp filters narrow which snapshots are searched; date-only bounds include the full UTC day. `limit` is a positive integer up to 1000 (default 20). `offset` is a non-negative integer up to 1000. Paginated responses report next and previous offsets, identify the final page, and suggest a nearby offset when an empty page is requested.
`savestate_stats`	Aggregate stats: total snapshots, cadence, adapter mix, top tags. `limit` is a positive integer up to 1000 (most recent snapshots first). `offset` is a non-negative integer up to 1000.
`savestate_memory_store` / `_search` / `_delete`	Live memory CRUD against the SQLite-backed memory store. `savestate_memory_store` `offset` is a non-negative integer up to 1000. `savestate_memory_search` accepts an optional case-insensitive `source` metadata filter plus inclusive `minImportance`, `maxImportance`, `since`, and `until` filters; date-only bounds use the full UTC day. `limit` is a positive integer up to 1000 (default 10), and `offset` is a non-negative integer up to 1000; search responses report the filtered total, remaining rows, and next offset when another page exists, or the total and a recovery offset when a page is empty. `savestate_memory_delete` `offset` is a non-negative integer up to 1000.
`add_memories` / `search_memory` / `list_memories` / `delete_memory` / `delete_all_memories`	OpenMemory-compatible API surface, drop-in for any client expecting the OpenMemory protocol. `add_memories` `limit` is a positive integer up to 1000. `add_memories` `offset` is a non-negative integer up to 1000. `search_memory` accepts an optional case-insensitive `source` metadata filter, plus inclusive `minImportance` and `maxImportance` filters from 0 through 1. `search_memory` also accepts inclusive `since` and `until` ISO-8601 creation bounds; date-only bounds use the full UTC day. `search_memory` `limit` is a positive integer up to 1000 (default 10). `search_memory` `offset` is a non-negative integer up to 1000; search responses report the filtered total, remaining rows, and next offset when another page exists, or the total and a recovery offset when a page is empty. `list_memories` accepts a non-empty `search` substring matched against content and tags, plus inclusive `since` and `until` ISO-8601 creation bounds; date-only bounds use the full UTC day. `list_memories` `limit` is a positive integer up to 1000 (default 50), matching the MCP tool description. `list_memories` `offset` is a non-negative integer up to 1000. Its response summary reports the starting offset, a previous offset on later pages, and the next offset when another page exists; an exhausted page reports active filters and a suggested offset for the nearest page to retry. `delete_memory` `limit` is a positive integer up to 1000. `delete_memory` `offset` is a non-negative integer up to 1000. `delete_all_memories` `limit` is a positive integer up to 1000. `delete_all_memories` `offset` is a non-negative integer up to 1000.

Resources

savestate://snapshots — JSON list of snapshots in the local index. Default 50; ?limit= is a positive integer up to 1000. ?offset= is a non-negative integer up to 1000. ?platform=, ?adapter=, ?label=, and ?tag= accept non-empty values; all four match case-insensitively. Inclusive ?since= and ?until= accept ISO-8601 dates or timestamps (date-only values include the full UTC day). Filters apply before pagination and are preserved in continuation URIs. Each snapshot includes its adapter alongside its platform, normalized tags, and a label that is always a string or null. The response includes the active platform, adapter, label, tag, since, and until plus matching filters.* fields, plus total, count, and remaining entries after the visible page, plus page/totalPages, offset, pageSize, nextOffset, and a ready-to-read nextUri when another page exists, previousOffset and a ready-to-read previousUri for returning to the prior page, and suggestedOffset with a ready-to-read suggestedUri when an offset is past the available snapshots.
savestate://memories — Live memory entries from the SQLite store (default 50; ?limit= is a positive integer up to 1000). ?offset= is a non-negative integer up to 1000. ?search= accepts a non-empty text query matched against content or tag values. ?type= accepts fact, event, preference, or conversation. ?tag= accepts a non-empty tag. ?since= and ?until= accept ISO-8601 creation bounds (date-only values include the full UTC day). Inclusive ?minImportance= and ?maxImportance= filters accept scores from 0 through 1; all active filters carry forward in pagination links. The response echoes active filters as filters.type, filters.tag, filters.search, filters.since, filters.until, filters.minImportance, and filters.maxImportance (or null when unset), and includes total, count, and remaining entries after the visible page, plus page/totalPages, offset, pageSize, nextOffset, and a ready-to-read nextUri when another page exists, previousOffset and a ready-to-read previousUri for returning to the prior page, and suggestedOffset with a ready-to-read suggestedUri when an offset is past the available entries.

Clients can detect failures reliably: unknown tool calls include isError: true, and resource-read failures are returned as MCP protocol errors instead of successful JSON payloads that merely contain an error field.

Passphrase handling

The MCP server can run with or without encryption. If SAVESTATE_MCP_PASSPHRASE is set, the SQLite-backed memory store encrypts content; cross-snapshot search tools always require a passphrase per-call so the user keeps control. Pass the passphrase via the passphrase argument when invoking savestate_search_snapshots or savestate_snapshot.

🔒 Passphrases never leave the local process. SaveState derives keys with scrypt, encrypts with AES-256-GCM, and never sends plaintext to the cloud or to any MCP client.

Why SaveState specifically?

Encrypted by default — AES-256-GCM with user-controlled keys. Other MCP memory servers store plaintext on disk.
Cross-platform — One memory archive, six adapters (ChatGPT, Claude, Claude Code, Gemini, OpenAI Assistants, Clawdbot), with more coming. No re-onboarding when you switch tools.
Open format — The SaveState Archive Format (SAF) is an open spec. Your archive is yours forever, even if SaveState disappears.
Memory governance — Signal Fitness League scoring + Trust Kernel staged promotion (in progress) means low-quality memory drops out automatically.
Backup as a side effect — Every MCP interaction is captured into the same encrypted, portable archive. No second tool needed.

Pro is $9/month. Encrypted portable memory, including MCP search from every client. Card today. No waitlist.

Subscribe to Pro — $9/mo Team is $29/month

After you pay, your API key is emailed. Then savestate login. Card today — no waitlist.

Next steps

CLI Reference — every command, every flag.
Encryption — how passphrases, scrypt, and GCM fit together.
SAF Archive Format — the open format spec.