Skip to main content
Glama
mymemory-mcp

mymemory-mcp

mymemory-mcp

One memory for every AI. MyMemory is a user-owned, portable memory vault: import your context once (CLAUDE.md, custom instructions, bios), and every AI tool you use reads the same distilled entries. Agents propose new memories after conversations; proposals land in a pending queue you promote or reject. The memory belongs to you, not a lab. This package is the vault as an MCP server: 3 tools, zero install beyond npm.

Your context, portable. — myclawn.com/mymemory

Quick start

Get an API key first: open https://www.myclawn.com/mymemory, sign in with a passkey, and create a key in the Keys view. Keys look like mm_… and are shown once — the read + propose scopes cover everything below.

Claude Code

claude mcp add mymemory -e MYMEMORY_API_KEY=mm_your_key -- npx -y mymemory-mcp

Claude Desktop (claude_desktop_config.json)

{
  "mcpServers": {
    "mymemory": {
      "command": "npx",
      "args": ["-y", "mymemory-mcp"],
      "env": {
        "MYMEMORY_API_KEY": "mm_your_key"
      }
    }
  }
}

Any other MCP client: serve over stdio with command npx and args ["-y", "mymemory-mcp"]; the key goes in the MYMEMORY_API_KEY env var. Self-hosted or testing against a local app? Point MYMEMORY_BASE_URL at the origin (default https://www.myclawn.com).

Related MCP server: SOMA MCP

What your agent can do

Tool

What

mymemory_get_context

Fetch the vault's compiled context block (directives first, then facts/preferences/notes) plus the raw entries — call once at conversation start

mymemory_search

Case-insensitive substring search over active entries ({query} → {count, matches})

mymemory_propose

Propose up to 20 {kind, text} entries (directive / fact / preference / note) — they land pending until you approve them in the app

The API key's scopes gate the verbs: read covers context + search, propose covers proposing. A read-only key proposing gets a clear 403.

What it deliberately does NOT do

No approving/rejecting entries, no editing the vault, no minting or revoking keys — curation stays with the human at myclawn.com/mymemory, where every proposed entry waits in a review queue. This package is the read/propose surface: agents remember, you decide.

  • The vault app: https://www.myclawn.com/mymemory

  • API + pairing surface: https://www.myclawn.com/api/mymemory/*

  • iOS app source (pairs via 6-char code): ios/ in the monorepo

Decisions

  • Search is client-side. The API contract defines no search route, so mymemory_search fetches /api/mymemory/context once and filters entries by case-insensitive substring over text (and kind, so "directive" lists all rules). Simple and fine at vault sizes.

  • mymemory_get_context returns text-first. The compiled context_block leads the tool result (paste-ready), followed by the raw entries as JSON for structured use.

  • MYMEMORY_BASE_URL is the origin, not the full API prefix; routes are appended as /api/mymemory/…. Trailing slashes are tolerated.

  • Engines node >=22 per the build contract (sibling myclawn-mcp says >=20; the contract wins).

  • Registry metadata (server.json / smithery.yaml) ships in this package; submission steps live in docs/registry-submissions.md. The package is publish-ready (publishConfig.access: public).

MIT © MyClawn

Available Tools

3 tools
mymemory_get_contextA

Fetch the user's MyMemory vault context: a compiled context_block (directives first, then facts/preferences/notes, one per line) plus the raw active entries. Call once at conversation start and apply it — these are the user's standing rules, facts, and preferences across every AI tool they use.

Inputs: no named parameters.

mymemory_proposeA

Propose new entries to the user's MyMemory vault when you learn something durable about them. Entries land in a PENDING queue the human reviews in the app — nothing becomes active without their approval. Only propose lasting cross-session knowledge (a rule, fact, preference, or note about the user), never one-off task details or things already in the vault. kinds: directive = a rule ("never …", "always …"), fact, preference, note. Max 20 per call; the server dedupes against existing entries.

Inputs: entries (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 3 tools

    Disambiguation4/5

    The three tools have distinct purposes: get_context (retrieve full vault), search (find specific entries), and propose (add new entries). While get_context and search both read data, their purposes are clearly separated (bulk fetch vs. targeted lookup), and propos e is clearly a write operation. No meaningful ambiguity between them.

    Naming Consistency5/5

    All tool names follow a consistent mymemory_<verb> pattern: get_context, search, propose. The verbs are uniform and descriptive, and each name clearly signals its operation (retrieval, lookup, and write). The mymemory_ prefix consistently scopes the namespace.

    Tool Count3/5

    Three tools is on the thin side but understandable for a personal memory vault: fetch, search, and write. The scope is narrow enough that three tools could work, though one might expect an explicit update/delete mechanism. It's at the lower boundary of reasonable.

    Completeness3/5

    The vault supports retrieval (get_context), search, and creation (propose, gated by PENDING approval). However, there's no tool to update or delete existing active entries, nor to approve the pending queue, meaning maintenance of the vault is delegated entirely to the human in the app. This leaves some lifecycle gaps beyond the core read/write flow.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      A private, self-hosted MCP server that wraps a retrieval pipeline over your own data, enabling trusted AI agents to access and manage your personal memory through standard MCP tools.
      Apache 2.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      A portable self-hosted memory layer for AI tools, storing context, memories, and handoffs for access from any MCP-compatible client.
      48 npm
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A personal memory MCP server that stores and retrieves conversation memories, enabling AI agents to recall past discussions, promises, and preferences using natural language.
      MIT