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.18.1 (2026-11-13), 11 tools in the npm package. This version comes from the docs facts registry, updated from npm after each release. The hosted connector is deployed separately and may serve a different package version.

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?

For ChatGPT, install the published Mnemoverse Memory plugin and sign in in the browser. Other compatible MCP clients can add the hosted Remote MCP Server at https://mcp.mnemoverse.com/mcp and connect through OAuth, with 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 published plugin does not offer vault_list (where each tool works). Deletion is an administrative REST operation, not an agent tool.

Pick Your Tool ​

  • Claude Code: run the local npm server from the CLI with an API key
  • Claude Desktop: configure the local npm server with an API key, or connect the hosted server with OAuth
  • 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 published Mnemoverse Memory plugin with browser sign-in
  • 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 to the same Mnemoverse account. 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 in Mnemoverse that staging deploys go through make deploy-staging."

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). Keys from two different accounts 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 connected with a key from the same account.

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, naming the memory it replaces in memory_write's supersedes (0.18.0+; not in shared rooms).

Reading and writing your own memory ​

ToolWhat it does
memory_writeStore a preference, decision, or lesson; with supersedes (0.18.0+), mark the memories it corrects as replaced
memory_readSearch memories by natural language query, optionally newest-first (order_by), time-bounded (since / until), with near-copies spread out (diversity, 0.15.0+), or including replaced memories (include_history, 0.18.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 ​

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

The server advertises the tools on this page; each host's guide records its setup and verification status. The published ChatGPT plugin uses the hosted server's ChatGPT tool surface, which does not offer vault_list. Where each tool works describes these declared differences; verify the actual tool response in your account before relying on it.

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. One field has no hosted counterpart yet: since 0.16.0, memory_read and memory_list_recent called without a domain carry rooms_not_searched (Shared rooms in detail).

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 except Vault secrets and, in an organisation that has switched read-side filtering on, superseded revisions (API reference). 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.

A memory_read or memory_list_recent without a domain searches your own domains only and never a room. Since 0.16.0 its answer names the rooms it did not search, whether or not it found anything: the text ends with a note listing each live room's address, and structuredContent carries the same list as rooms_not_searched (state, rooms, note). Pass one of those addresses as domain to read the room. The field is absent when you have no rooms and on a call that names a domain. The hosted connector does not list skipped rooms yet.

Universal Memory ​

Same Mnemoverse account, same memories, in every connected tool. In ChatGPT, install the published Mnemoverse Memory plugin and complete browser sign-in with that account; no API key is needed. Claude and the editors use their own setup guides. Custom MCP and Custom GPT Actions remain separate alternatives with their own authentication and creation requirements.

                    ┌── Claude Code / Desktop
   Mnemoverse API ──├── Cursor / VS Code / Devin Desktop
   (one memory)     ├── ChatGPT (published plugin)
                    └── 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).

Any client that runs local (stdio) MCP servers takes this entry under the key it uses for them (for example mcpServers, or servers in a VS Code style mcp.json). The package needs Node.js 18 or later; npx downloads it on first start. Ready files for each app are under Pick Your Tool and on Install by host.

json
{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": ["-y", "@mnemoverse/mcp-memory-server@latest"],
      "env": {
        "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY",
        "MNEMOVERSE_API_URL": "https://core.mnemoverse.com/api/v1"
      }
    }
  }
}

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.18.1, published 2026-11-13. 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