AtomicMemory: long-term memory MCP server for agents
AtomicMemory
A long-term memory MCP server for agents: search, store and correct facts across sessions in the cloud or a local core
- 440 ★ on the repository
- Last commit
Extended access
Why this level
- Everything the agent sends to `memory_ingest` is stored by the memory provider and returned into the context of other sessions
- The installer runs as `curl | sh` and saves the project key in an owner-only file
- The `am integrate` command changes the user-level MCP configuration of the chosen agent
Install
- Works in
Manual install
curl --proto '=https' --tlsv1.2 -fsSL https://get.atomicstrata.ai/install.sh | sh -s -- --initInstalls the `am` command line client and starts cloud initialization. Downloads are checked against checksums.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Everything the agent sends to `memory_ingest` is stored by the memory provider and returned into the context of other sessions
- The installer runs as `curl | sh` and saves the project key in an owner-only file
- The `am integrate` command changes the user-level MCP configuration of the chosen agent
This is third-party code. Review the repository files before installing.
What it does
AtomicMemory keeps an agent's long-term memory: preferences, facts and decisions that outlive individual sessions. The memory can be corrected: when facts change, an entry is replaced, clarified, deleted or left as it is. The MCP server `@atomicmemory/mcp-server` gives the agent six tools. `memory_search` searches by meaning, `memory_ingest` stores text or messages, `memory_package` assembles context within a token budget, and `memory_list` shows recent entries. `entity_profile` builds a summary for a user or an agent, and `entity_attributes` returns structured entity, attribute, value triples. Storage comes in two flavors: the managed AtomicMemory Cloud or an open source core that runs locally in Docker. The `am` command line client helps connect the server to Cursor, Claude Code, Codex or OpenCode: the `am integrate` command writes the MCP configuration of the chosen agent.
Who it is for. For developers who work with several coding agents and want them to remember preferences, decisions and project facts across sessions.
Good fit when
- The agent forgets preferences and decisions between sessions, and you need a shared memory layer for Claude Code, Cursor, Codex and OpenCode
- What was remembered needs correcting: replacing a stale fact, clarifying it or deleting it
- You need context for a task within a token budget: `memory_package` assembles it
- The memory should live on your server: the open source core runs in Docker and the MCP server supports an HTTP mode
- You need a profile of a user or an agent built from accumulated entries
Not a fit when
- A project rules file such as AGENTS.md is enough for you: a separate memory service is excessive
- Conversations and facts must not leave for an external service and you cannot deploy the local core: in cloud mode the memory provider stores the entries
- You need an audit of entries: MCP answers arrive as text with JSON inside, so for verification you read the REST API or the SDK
Example request
Remember that I prefer aisle seats when flying, then search memory for what I said about seat choiceMCP
- Transport
- stdio, http
- Authentication
- key is optional
Environment variables
ATOMICMEMORY_API_KEYsecret- Project API key. Required for the cloud; for the local core local-dev-key is used by default.
ATOMICMEMORY_API_URL- Memory provider URL. Required in HTTP mode.
ATOMICMEMORY_SCOPE_USER- Default user scope. In stdio mode the local user name is used.
ATOMICMEMORY_MCP_TRANSPORT- Transport: stdio by default or http for a hosted server.
Limitations
Cloud mode needs a project API key and an AtomicMemory Cloud account. The Connected Local mode requires a running Docker and an OpenAI API key, and the OpenAI API is unavailable from Russia. macOS and Linux with glibc on x86_64 and arm64 processors are supported.
Tool answers arrive as text with JSON inside for client compatibility. To verify entries the authors advise reading the REST API or the SDK. Plugin packages for Codex and Cursor are marked as coming soon, so those agents connect through direct MCP configuration with `am integrate`.
HTTP mode works only with a project key in every request, and there is no OAuth. The server stores what the agent sends into it, so secrets, tokens and private keys must not go into memory.
How to disable. Remove the server from your agent's user-level MCP configuration and restart the client. The entries remain in storage: the cloud project or the local core.
FAQ
How do I connect AtomicMemory to Claude Code?
Install the `am` client with the script from get.atomicstrata.ai, go through `am init`, then run `am integrate --yes --host claude-code`. The command writes the user-level MCP configuration, and `am integrate doctor` shows setup problems.
Which tools does the AtomicMemory MCP server have?
Six: `memory_search`, `memory_ingest`, `memory_package`, `memory_list`, `entity_profile` and `entity_attributes`. The first four work with entries, the last two return a profile and structured attributes.
Do I need Docker and an OpenAI key?
For the cloud you need neither. The Connected Local mode runs the core in Docker and asks for an OpenAI API key, which the client reads with hidden input and stores with owner-only permissions.
Can I run the server without the cloud?
Yes. The command `npx -y @atomicmemory/mcp-server` with no key and no URL talks to the local core at `http://127.0.0.1:17350` and substitutes the key `local-dev-key`.
How do I run the server over HTTP on my own host?
Set `ATOMICMEMORY_MCP_TRANSPORT=http` and `ATOMICMEMORY_API_URL`, then start the package with the `--http` flag. Every request must carry an Authorization header with the project key, otherwise the server answers 401. By default it listens on port 3100.
Discussion
No questions or reviews yet.
Related
MCP serversAn MCP server for long-term agent memory: compresses dialogues into atomic facts, resolves pronouns and anchors relative time to absolute dates
A self-hosted MCP server for long-term agent memory: structured records, versioned rollback and a visual dashboard
Self-hosted long-term memory for agents: semantic search, a knowledge graph and autonomous consolidation over MCP and a REST API
iai-memory
iai-memory (Personal Memory Engine)
A local long-term memory MCP server for agents: keeps conversations verbatim and returns the right context at the start of a session
Long-term memory for agents: a remote MCP server, plugins for Claude Code, Cursor and Codex, and an API for your own apps
A local-first MCP memory server for agents: session history, codebase index and a concept graph in one SQLite database
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| AtomicMemory: long-term memory MCP server for agents (this entry) | yes | key is optional | 440 | |
| Mem0 | no | 68,059 | a memory layer for agents with plugins for Claude Code, Codex, Cursor and OpenCode, a CLI and an SDK | |
| MCP Memory Service | no | not required | 2,056 | self-hosted memory with semantic search, a knowledge graph and auto-consolidation |
| Basic Memory | no | not required | 4,403 | agent memory in local Markdown files with a link graph |
README in short
The description has tables of package statuses (published, publish pending, coming soon, deprecated) and a section on trust boundaries: what lives in this repository and what stays in closed infrastructure. The author presents the benchmark results as his own measurements and promises the materials to reproduce them later.