MyMemory

MyMemory is a user-owned, portable memory vault — one memory for every AI. Import your context once (CLAUDE.md, custom instructions, bios, chat exports) and it is distilled into atomic entries. Every AI tool you use reads the same vault over HTTP or MCP, and agents propose new memories after conversations — proposals wait in a review queue until you promote or reject them. The memory belongs to you, not a lab.

Try it in 5 seconds

A read-only public demo vault is live — this curl returns its compiled context block, no account or key of your own needed:

curl https://www.myclawn.com/api/mymemory/context \
  -H "Authorization: Bearer mm_28dbde38035867722fed80de7a99a48f"

The key is scoped read on a shared demo vault, so writes are rejected. Everything below is about your own vault.

Quick start

  1. Open myclawn.com/mymemory and sign in with a passkey — that creates your vault. No password, no email.
  2. Import what you already have: paste your CLAUDE.md, ChatGPT custom instructions, a bio, or a chat export into the Import view. The distiller splits it into atomic entries.
  3. Imported entries land pending — skim the Review queue, approve what is true, reject the rest. Only active entries are ever served to your tools.

Connect your agents

In the Keys view, create a key with the read scope. Keys look like mm_… and are shown once — copy it immediately. Any tool that can make an HTTP request can then pull your compiled context:

curl https://www.myclawn.com/api/mymemory/context \
  -H "Authorization: Bearer mm_your_key"

The response is { context_block, entries }: context_block is the paste-ready text (directives first, then facts, preferences, and notes — one per line) for a system prompt, and entries is the raw list for structured use.

The MCP server

For MCP-capable agents there is a stdio server, mymemory-mcp, with the key in MYMEMORY_API_KEY:

claude mcp add mymemory -e MYMEMORY_API_KEY=mm_your_key -- npx -y mymemory-mcp
// claude_desktop_config.json
{
  "mcpServers": {
    "mymemory": {
      "command": "npx",
      "args": ["-y", "mymemory-mcp"],
      "env": { "MYMEMORY_API_KEY": "mm_your_key" }
    }
  }
}

It exposes three tools:

  • mymemory_get_context — the compiled context block plus raw entries; call once at conversation start.
  • mymemory_search — { query }, case-insensitive search over active entries.
  • mymemory_propose — { entries: [{ kind, text }] }, up to 20 per call. These are the only writes an agent can make, and they land pending in your review queue — nothing becomes memory until you approve it.

Key scopes gate the verbs: read covers context and search, propose covers proposing. A read-only key that tries to propose gets a 403. Approving, rejecting, editing, and key management stay with you in the app.

iOS & Android pairing

The mobile apps pair without you ever typing an API key into a phone:

  1. In the web app, Keys view → create a pair code. You get a 6-character code, single-use, valid for 10 minutes.
  2. In the iOS or Android app, enter the code. The app redeems it for its own mm_… key and stores it on-device.

Each paired device holds its own key, so revoking a lost phone in the Keys view does not touch your other devices.

Good to know

  • Pending vs active — only active entries go into the context block. Imports and agent proposals start pending; entries you add by hand start active. Rejected entries are archived, not deleted.
  • Kinds — directive (rules: "never …", "always …"), fact, preference, note. Directives compile first in the context block, so your rules lead every prompt.
  • Dedupe — proposals are deduped case-insensitively against existing non-archived entries, so repeat suggestions do not pile up in the queue.
  • Neutral by design — the same vault serves Claude, ChatGPT, and any MCP or HTTP tool. Switching models does not mean starting your memory over.

Open your vault → / MCP tools for local agents →