Persistent memory API for AI agents
Persistent memory for AI agents
One memory. Every AI tool. Write once, recall anywhere: across Claude Code, Cursor, VS Code, ChatGPT, and Python, with one API key or OAuth.
Connect the AI you already use
Using another tool? Explore 70+ integration guides →
claude mcp add --scope user --transport http mnemoverse https://mcp.mnemoverse.com/mcpPaste into your terminal. In a fresh Claude Code session, run /mcp, select Mnemoverse → Authenticate, and sign in in the browser.
Free to start · no credit card · no API key to copy · Setup help
Community launch
We're live on TinyLaunch
If you like what we're building, we'd love your support.
The technology behind the memory
Mnemoverse is a persistent memory API for AI agents: write a preference, decision, or lesson once and recall it from any tool. It is not a vector database: memories learn from outcomes via Hebbian associations and Rescorla-Wagner, get re-ranked so stale memory ranks down, and improve with use. Connect compatible AI tools through their supported setup, or use Python and REST in your own app. The MCP server exposes the memory tools. Mnemoverse publishes that server on npm and the official MCP Registry, a Python SDK on PyPI, and a one-click VS Code extension that runs the same server, so one memory is reachable from Python code, from any MCP client, and from VS Code. Agents built on A2A frameworks reach the same memory through the A2A endpoint. The free tier is $0 with 1,000 queries/day. Mnemoverse is benchmarked on public memory benchmarks (LoCoMo and LongMemEval), with every published number tracing to a committed run artifact. Our research on reading memory at several levels of detail is described in the SLoD paper (arXiv:2603.08965), peer-reviewed and accepted at the GRAAI workshop (IEEE WCCI 2026); the hosted engine does not run that method yet (how SLoD relates to the product).
New to the category? What an AI agent memory layer is — the definitions, how the approaches differ, and where Mnemoverse fits.
Not a vector database
Memory that learns from outcomes and improves
Vector databases store and retrieve. In Mnemoverse, telling it a recalled memory helped or misled re-ranks what comes back next, and shared rooms let several agents work from one memory.
| Mnemoverse | Vector DB (Pinecone / Weaviate / Chroma) | |
|---|---|---|
| Core model | Hebbian associations + prediction-error feedback (Rescorla-Wagner-style) | Vector embeddings (cosine similarity) |
| Learns from outcomes | Yes: feedback updates valence | No outcome-feedback loop (reranking is similarity-based) |
| Concept associations | Three-factor Hebbian graph | None |
| Memory compression | Consolidation built (HDBSCAN + Von Restorff protection); switched off on the hosted service today | Accumulate forever |
| Query expansion | Automatic via learned associations | No learned-association expansion (hybrid/keyword only) |
| Starting price | Free (1,000 queries/day) | Free tier, then ~$20–50/mo |
How it works
Write → Learn → Recall
The same loop on every tool. Memories that lead to good outcomes rank higher next time. The system improves with use.
Write
Store a preference, decision, or lesson with a single call. A write too similar to a memory you already have can be refused, and the response tells you whether it was stored.
Learn
Report outcomes and the system updates valence. Memories that lead to good answers rank higher; ones that consistently fail rank lower. Nothing is erased.
Recall
Query in natural language. Hebbian expansion pulls in associated concepts and valence-boosted ranking surfaces what actually mattered last time, across every tool with one API key or OAuth.
After you connect
Give it one useful thing to remember
Choose something true and useful to you. Adapt these example requests to your own preference or project, then try them with Mnemoverse connected.
01 · A preference you should only have to explain once
Your preferred project-update format
Save it in one conversation
Save this in Mnemoverse, in my general domain: I prefer project updates in three short bullets — progress, next step, blockers. Tell me whether it was actually stored.Look for confirmation that the write stored a memory. A similar record can make a new write unnecessary; if the write is refused, check the reason and recall the existing record.
Recall it in a fresh conversation
Look in my Mnemoverse general domain for my preferred project-update format. Tell me what the saved memory says before drafting an update.Check that the retrieved memory contains progress, next step, blockers. Then ask for an update in that format. Ask your assistant to show the retrieved note so you can check what it actually recalled.
02 · Across your tools
Carry a decision into the next tool
Plan a demo in ChatGPT, then recall the decision in Claude Code. Both tools need the same account and memory domain.
Try the two-tool example
Save this project decision in Mnemoverse, in my general domain: For the Atlas demo, use a local sample dataset so the demo works without network access. Confirm the write result.Find the Atlas demo decision in my Mnemoverse general domain. What dataset did we choose, and why? Use the saved record rather than guessing.Check for the local sample dataset and the reason: the demo must work offline. This shares the saved decision; it does not synchronize entire conversations.
03 · In your application
Keep a lesson, then report whether it helped
Save how you resolved a timeout. Retrieve the lesson when the issue returns, then use feedback to report the outcome you observed.
Follow the Python write → read → feedback example →Feedback adjusts ranking. A single walkthrough is not a benchmark or a guarantee that every future answer improves.
These examples use the general domain — a named memory space. Use the exact same name for saving and reading. In ChatGPT, select Mnemoverse Memory in the new conversation. If a step fails, follow the connection and recall checks.
Mnemoverse keeps the notes you or your connected tools save. Connecting does not import past chats or your AI app's built-in memories. Read how memory is stored and controlled →
See it work
Watch an agent's memory take shape
This is a real memory graph, not an illustration: atoms, associations, and recall as the engine stores and re-ranks. Drag to explore.
Atoms are memories
Each node is one stored memory, sized by importance and colored by type. The graph is what the agent actually knows.
Links are associations
When two concepts are recalled together, a Hebbian link forms and thickens, so related memories surface as a group, not one at a time.
Consolidation is built, not enabled
Look-alike memories merge (HDBSCAN), while distinctive ones are protected. That is built and not enabled on the hosted service today. Recall stays sharp by re-ranking on outcomes.
Retrieval lights the path
A query activates associated concepts and walks the links to the right atom, the same recall path measured in our public LoCoMo runs. The graph below is a real run artifact, not an illustration.
For agents
MCP, A2A or REST: one memory
Use the protocol your agent already speaks. All three take the same API key.
Local MCP server with an API key
This alternative runs @mnemoverse/mcp-memory-server locally through Node.js and connects to Mnemoverse with your API key. Hosted connections use browser sign-in; available tools depend on the host and configured connection. The package is listed on the official MCP Registry.
claude mcp add mnemoverse -s user \
-e MNEMOVERSE_API_KEY=mk_live_YOUR_KEY \
-e MNEMOVERSE_API_URL=https://core.mnemoverse.com/api/v1 \
-- npx -y @mnemoverse/mcp-memory-server@latestA2A 1.0 agent
Agents built on A2A frameworks call Mnemoverse as an agent with two skills: search memory and store a memory. Give your client the address below and your API key; it reads the rest from the Agent Card. Each request gets one message back.
- Address:
https://mcp.mnemoverse.com
curl -sS -X POST https://mcp.mnemoverse.com/a2a \
-H 'Content-Type: application/json' \
-H 'A2A-Version: 1.0' \
-H "Authorization: Bearer $MNEMOVERSE_API_KEY" \
--data '{"jsonrpc":"2.0","id":"1","method":"SendMessage","params":{"message":{"messageId":"m-1","role":"ROLE_USER","parts":[{"text":"What did we decide about billing?"}]}}}'REST API and Python SDK
Call the REST API from your own code in any language, or install the Python SDK. Both use the same API key and the same memory.
pip install mnemoverseBenchmarks
Benchmarked, honestly
Mnemoverse is evaluated on public memory benchmarks (LoCoMo and LongMemEval) rather than internal scores you can't reproduce. Every published number traces back to a committed run artifact: configuration, prompts, and code version frozen.
Live, verified numbers: see the benchmarks page.
Pricing
Start free. Scale when you need to.
Free tier ships with full API access and the MCP server, no credit card required. Reads, writes and feedback all count as queries, only successful requests count, and daily limits reset every 24 hours.
Enterprise
Custom limits · SSO/SAML · audit logs · SLA · data residency · BAA/SOC 2 on request.
Contact salesBuilding a startup?
Early-stage teams start on Team free: your first month on signup, six months if we approve you.
FAQ
Frequently asked
It learns from outcomes (Hebbian associations + Rescorla-Wagner), re-ranks recall from that feedback so stale memory ranks down, and improves over time. A vector database only does similarity search.
Yes. Install the published Mnemoverse Memory plugin in ChatGPT and sign in to Mnemoverse in the browser. Connect Claude and your other tools to the same Mnemoverse account to share its memories. Install in ChatGPT →
Yes. Free is $0: 1,000 queries/day, 10,000 atoms, 60 req/min. No credit card.
Per-tenant org isolation. API keys are SHA-256 hashed and compared in constant time, and we don't train on your data.
RAG answers “what do the docs say?” Mnemoverse remembers “what did we discuss, decide, or learn last time?” They're complementary.
Yes. @mnemoverse/mcp-memory-server exposes memory tools through a local stdio server, and hosted MCP connections are also available. Tool availability depends on the host and configured connection. Deletion isn't an agent-facing tool at all: it's an administrative REST operation, so no MCP client can wipe a memory. To fix something wrong, an agent writes a corrected memory and can name the one it replaces with memory_write's supersedes field, in the npm package from 0.18.0 and on the hosted connector; shared rooms do not support replacing.
Yes. Mnemoverse answers as an A2A 1.0 agent with two skills: search memory and store a memory. Give an A2A client the address https://mcp.mnemoverse.com and your API key. It reads the Agent Card and works with the same memory as your other tools. Each request gets one message back. There are no tasks, no streaming and no push notifications. A2A endpoint docs →
Get started
Connect your AI
Choose your tool, connect your account, and save your first useful memory.
Agents you build can connect over MCP, A2A or REST.