MnemoverseDocs

Appearance

MCP Server ​

npm versionnpm downloads per monthMCP RegistryLicense: MITGlama quality score

Mnemoverse gives any MCP-compatible AI tool a long-term memory kept in your account. One config adds the memory tools, and the memory rules tell the agent when to use them.

Current release: v0.15.1 (2026-10-12), 11 tools. The version here comes from the same registry file every Mnemoverse surface reads, refreshed automatically when a release ships.

The @mnemoverse/mcp-memory-server npm package works with any tool that supports the Model Context Protocol. Listed on the Official MCP Registry: any MCP-aware client that browses the registry will find it there.

Prefer not to manage an API key?

The hosted Remote MCP Server connects the same memory over one-click OAuth sign-in: add https://mcp.mnemoverse.com/mcp as a custom connector, no key to paste. This page covers the local npx package. Since 0.9.0 the two surfaces expose the same tool set, with one per-host exception: in ChatGPT the connector does not offer vault_list (where each tool works). Deletion is an administrative REST operation, not an agent tool.

Pick Your Tool ​

  • Claude Code & Claude Desktop: one command for Claude Code, JSON config for Desktop
  • Cursor: keyless one-click Add to Cursor with browser sign-in, or ~/.cursor/mcp.json with an API key
  • VS Code: keyless extension, remote OAuth, or .vscode/mcp.json
  • Devin Desktop (formerly Windsurf): ~/.config/devin/mcp_config.json with an API key
  • ChatGPT: the remote MCP connector added as a custom MCP server, or GPT Actions with a key
  • Python SDK: pip install mnemoverse for scripts and backends

Try It ​

Your assistant may never recall what it saved unless you tell it to

Connecting adds the memory tools; it doesn't make the assistant use them. By default it answers from its own context instead of checking Mnemoverse, so recall quietly goes unused. The server's instructions and tool descriptions say what each tool does, not when the assistant should use it unasked. Add the memory rules to your agent's instructions: the setup_memory prompt produces them, or copy them from Make Your Agent Use Memory. They cover writing as well as recall.

With that in place, the point is one memory across tools, provided both tools are connected with the same MNEMOVERSE_API_KEY. Memory is scoped to the account behind the key, so keys from two different accounts mean two separate memories and the demo below comes back empty; two keys from the same console account share one memory.

In whichever tool you just connected:

"Remember: staging deploys go through make deploy-staging, never Railway directly."

Later, in a different tool (even days later):

"How do I deploy staging here?"

It recalls the rule, because the memory lives in Mnemoverse, not in any single tool. (A same-tool "it remembers" demo wouldn't prove much: the tool's own memory could do that; cross-tool recall is what needs Mnemoverse.)

If nothing comes back, check four things in this order. A key the server never accepted (from 0.8.4 a wrong key prints one line naming MNEMOVERSE_API_KEY on stderr at startup, so look there first). Two different keys across the two tools, which gives you two memories rather than one. Missing memory rules (above), which leave recall unused rather than broken. And the read itself: an unscoped read does not search shared rooms, and memory_read ranks by meaning, so ask for memory_list_recent when you want a complete recent list rather than the closest match.

The key alone can be checked before it goes into a config. Check your API key asks the API whether it accepts the key, from bash or PowerShell, and names the cause if it does not.

If this setup saved you time, a GitHub star helps the next builder find it.

How It Works ​

Your AI tool ←stdio→ @mnemoverse/mcp-memory-server ←HTTPS→ core.mnemoverse.com

The MCP server runs locally via npx, communicates with your AI tool over stdio, and calls the Mnemoverse API over HTTPS. Your memories are stored server-side, accessible from any tool with the same API key.

Tools ​

The server exposes 11 tools, grouped below: tools that work on your own memory, tools that share a memory pool across accounts, and one that discovers stored secret aliases. Two delete tools were removed in 0.9.0; deletion is an administrative REST operation now, and the honest way to fix a wrong memory from an agent is to write a corrected one.

Reading and writing your own memory ​

ToolWhat it does
memory_writeStore a preference, decision, or lesson
memory_readSearch memories by natural language query, optionally newest-first (order_by), time-bounded (since / until) or with near-copies spread out (diversity, 0.15.0+)
memory_list_recentList the newest memories first, no query, to catch up after a break or on a shared room
memory_feedbackReport if a memory was helpful (+1) or wrong (-1); pass a room's address as domain to rate memories read from that room
memory_statsCheck how many memories are stored
memory_graphRead the association links around given concepts: which concepts your memory has linked, with each link's weight, valence and count; read-only

Shared rooms (Beta) ​

ToolWhat it does
memory_create_roomCreate a room, a memory pool shared across accounts
memory_invite_to_roomMint a shareable invite code for a room
memory_join_roomRedeem an invite code and join a room
memory_list_roomsRe-find the rooms you belong to in a fresh session

Secrets ​

ToolWhat it does
vault_listList stored secret aliases; values are never returned

Every host gets every tool on this page except where Where each tool works says otherwise: the remote connector does not offer vault_list in ChatGPT.

Prompts and a resource ​

Clients that support MCP prompts get four prompts. Three are named shortcuts to the tools above: recall (search memory for a topic), save_insight (store an insight, optionally under a domain) and what_do_you_know (a briefing on a subject that says where nothing is stored). The fourth, setup_memory, returns the memory rules for your agent's instructions and where they go for your tool (Make Your Agent Use Memory). None of them calls the API itself. Clients that attach MCP resources can open one saved memory by its id through memory://item/{memory_id}, which returns its memory_id, content and domain.

Every tool answers with text for the model and, since 0.12.0, with structuredContent for a client that reads structured tool results: the same values as data, under the field names the hosted connector uses, with any field the engine did not send left absent rather than defaulted.

See the Claude Code page for detailed parameter docs and examples for each tool.

Search versus the recent feed ​

memory_read and memory_list_recent answer different questions, and using the wrong one is the most common way to conclude the memory is empty when it is not.

memory_read is a semantic search: it answers "what do I know about X" and returns what is relevant to a query. Entries that exist but do not match the query are not returned (correctly, but invisibly).

memory_list_recent is a walk backwards through time: it answers "what happened lately" and is complete by construction. Nothing is skipped. Use it to resume after a break, to catch up on a shared room, or whenever you want to be sure you are seeing everything rather than the best matches.

Both accept the same time and authorship filters:

ParameterMeaning
sinceOnly entries created at or after this instant (your last-seen watermark)
untilOnly entries created at or before this instant; pair with since for a closed window
exclude_authorDrop entries written by one author principal; it matches the principal, not the agent name shown in results, so an agent name will silently match nothing

memory_list_recent additionally takes limit (1–100, default 20) and cursor. The feed is paged rather than truncated: when more entries exist, the response carries a cursor that continues the listing with no skips and no duplicates, so reading a thousand entries is a series of calls (ten at the largest page of 100, more when long entries make pages shorter) rather than one impossible one.

Shared rooms in detail ​

A room is a memory pool shared across accounts, addressed as a domain of the form xroom:<room_id>. Every memory tool that takes a domain works against a room you belong to: membership is enforced in the database, not only in the application, so a non-member cannot read a room's entries even if a bug let the request through.

The owner creates a room and mints invite codes; each code expires, and is single-use unless minted with max_uses. memory_list_rooms is how a fresh session re-finds the rooms you are already in.

Universal Memory ​

Same Mnemoverse account, same memories, in every tool. Claude and the editors connect with an API key or OAuth. ChatGPT's MCP connector signs in with OAuth instead of a key, while a Custom GPT uses an API key, so sign in with the Mnemoverse account your other tools use.

                    ┌── Claude Code / Desktop
   Mnemoverse API ──├── Cursor / VS Code / Devin Desktop
   (one memory)     ├── ChatGPT (MCP / Actions)
                    └── Python SDK / REST

Write a memory in Claude Code → Cursor reads it. Learn something in VS Code → ChatGPT knows it.

It also survives your account changing ​

The key lives in your config file, not in the host app's session. That has a practical consequence worth knowing about: signing out, switching accounts or being re-authenticated by the app does not disconnect this server.

OAuth-based connectors — including our own remote connector, and the calendar, chat and drive connectors you may have attached to the same app — are held by the host application's identity. When that identity changes, they are usually dropped, typically without saying so — the exact behaviour is the host app's. The tools quietly stop appearing and the assistant carries on as though it never had memory.

The local package, configured with MNEMOVERSE_API_KEY, has nothing to drop: it reads the key, calls the API, and keeps working across sign-outs, account switches and restarts. (The keyless editor-extension path is a different surface with its own sign-in.) That is the reason we recommend it for unattended agents, scheduled jobs and CI, where nobody is watching to notice a silent disconnect and sign in again.

Configuration ​

VariableRequiredDefault
MNEMOVERSE_API_KEYYesNone
MNEMOVERSE_API_URLNohttps://core.mnemoverse.com/api/v1

MNEMOVERSE_API_URL is the REST backend the local server talks to. It is not an MCP endpoint; never paste it into a connector-URL field. A remote MCP connector uses https://mcp.mnemoverse.com/mcp (Remote MCP Server).

Get your API key at console.mnemoverse.com (free tier, no credit card).

No key needed in VS Code or Cursor. In VS Code, install the Mnemoverse Agent Memory extension and click Sign In; it connects in your browser with nothing to paste. In Cursor, use the keyless Add to Cursor link and click Connect in Customize. Other editors are listed on Cursor, VS Code & Devin Desktop (Windsurf).

What's New ​

The latest release is v0.15.1, published 2026-10-12. What changed in every release, newest first and dated, is on one page: the changelog.

Source Code ​

MIT licensed: github.com/mnemoverse/mcp-memory-server