MnemoverseDocs

Appearance

Cursor ​

For AI Agents

Machine-readable docs: mnemoverse.com/docs/llms.txt

Give Cursor persistent memory. One config entry gives the agent the Mnemoverse memory tools. Memories it saves through them are available in later sessions and in other tools connected as the same Mnemoverse account, when the agent calls memory_read.

Choose your connection. The recommended path is keyless: Add to Cursor adds the hosted server and you sign in through the browser, with nothing to install or paste. The API-key path runs the server locally through npx, which needs Node.js 18 or later and a key from console.mnemoverse.com (free, no credit card). Every tool connected as the same Mnemoverse account shares one memory. Pick one path, not several, so the tools are not listed twice.

Add to Cursor (no API key) ​

Add to Cursor

  1. Click Add to Cursor. Cursor opens its own MCP install and asks you to confirm. It adds the hosted server to ~/.cursor/mcp.json under the name mnemoverse; the link carries only the server address, no key:

    json
    {
  "mcpServers": {
    "mnemoverse": {
      "url": "https://mcp.mnemoverse.com/mcp"
    }
  }
}

  2. Open Customize in the sidebar (Cursor Settings → Tools & MCPs in Cursor 3.21.16) and click Connect next to mnemoverse.

  3. Approve in the browser. Cursor runs the OAuth sign-in and keeps the token itself.

Because the entry lives in your Cursor MCP settings, it works in every Cursor window, including the Agents Window. No Node.js is needed. To add it by hand instead, merge the JSON above into ~/.cursor/mcp.json and click Connect the same way. This path was checked end to end in Cursor 3.21.16 on 2026-09-23: sign-in, token, the full tool list, connected.

The sign-in works because the hosted server's sign-in allowlist accepts both callbacks Cursor documents: the desktop loopback http://localhost:8787/callback, and https://www.cursor.com/agents/mcp/oauth/callback for Cursor on the web and Cursor Agents. MCP needs a paid Cursor plan: Cursor's pricing lists "MCPs, skills, and hooks" from the Individual plan up, and not on Hobby. On the web, add the server at cursor.com/agents: Cursor on the web and Cloud Agents. See which clients can sign in.

With the Mnemoverse Agent Memory extension ​

The Mnemoverse Agent Memory extension also installs in Cursor, from Open VSX (Extensions view, search Mnemoverse). In Cursor it uses the same hosted server and needs no key and no Node.js:

  • Editor windows. The extension adds the hosted server right away, listed as extension-mnemoverse.
  • Agents Window. Cursor runs no extensions there, so the extension offers Mnemoverse: Add to Cursor (all windows). It opens the same Cursor install as the link above and puts mnemoverse in ~/.cursor/mcp.json; the extension then drops its in-window copy so the tools are not listed twice.
  • Sign-in. Either way, click Connect in Customize and approve in the browser. Cursor runs the sign-in and holds it.

If ~/.cursor/mcp.json or the project's .cursor/mcp.json already has Mnemoverse, the extension adds nothing.

Add to Cursor with an API key ​

This path runs the local server through npx and needs an API key from console.mnemoverse.com. Use it when you want the local stdio server rather than the hosted one.

The install button in this section is not the one at the top of the page. It installs the local npx server with the placeholder key mk_live_YOUR_KEY, under the same name, mnemoverse, as the keyless entry. Use it instead of the keyless button, not as well, and replace the placeholder with your key before the first tool call.

Cursor — click to install, or add the JSON below to ~/.cursor/mcp.json, the global config that covers every project. Do not put it in a project-level .cursor/mcp.json: that file lives inside the repository and is committed with it unless you exclude it, and this config holds your key.

Add to Cursor

The install button carries the placeholder key mk_live_YOUR_KEY, not yours, so the shortest path is to skip the button: add the JSON below to ~/.cursor/mcp.json, merging it with any servers already there, and put your own key in place. Get one at console.mnemoverse.com. If you did click the button, edit the same key in the mcp.json it wrote; Cursor keeps MCP environment values in that file, not in a settings form. Until the key is real the server starts and lists its tools, but every tool call is refused.

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"
      }
    }
  }
}

⚠️ Restart Cursor after editing the config file. MCP servers are only picked up on client startup.

Why @latest? It forces a registry metadata lookup on every session start so you always get the newest release — bare npx @mnemoverse/mcp-memory-server caches the first installed version indefinitely.

Check the key before it goes into ~/.cursor/mcp.json. Check your API key asks the API whether it accepts the key, from bash or PowerShell, and names the cause if it does not.

Try It ​

Ask the assistant to call memory_stats with {} on the Mnemoverse server you connected. A successful stats result confirms read access, including an empty account with zero memories. Listed tools, an empty response, or an error do not confirm the connection. Report the actual authentication, permission or transport error instead of claiming success. If the user only wanted to connect, stop here; do not write a test memory.

To verify saving when the user requests it:

  1. Use a harmless fact that is true and that the user actually wants saved. Ask the assistant to save that fact with memory_write; do not invent a deployment rule, preference or contact for a test.
  2. Check the actual memory_write result. Report a new save only if it says the memory was stored. If it refuses the write or returns an error, report that outcome; do not claim that a new memory was saved.
  3. Start a new conversation, or use another connected tool on the same Mnemoverse account. Ask the assistant to call memory_read for the topic without repeating the fact. Confirm recall only when the actual tool result contains the saved fact. An ordinary answer from chat context or a local rules file is not proof.

The stats check alone does not verify writes. If the user already requested a memory task, continue that task after the check and verify its own results.

For ongoing use, you can add a standing instruction to guide later recall: Make Your Agent Use Memory. It is not required for the explicit check above.

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

Tools ​

The server gives Cursor 11 tools: the core memory tools (memory_write stores, memory_read recalls), the Beta shared-room tools, and vault_list, which lists stored secrets by alias and never returns a value. The MCP Server page lists every tool and what it does.

For detailed parameter docs, see Claude Code or API Reference. Shared rooms (Beta) — a memory pool shared across accounts — are covered in Join a shared room.

Universal Memory ​

Same Mnemoverse account, same memories, in every connected tool. For ChatGPT, install the published Mnemoverse Memory plugin and sign in to that account in the browser. The alternative custom setups have separate requirements.

                    ┌── Claude Code / Desktop
   Mnemoverse API ──├── Cursor ← you are here
   (one memory)     ├── VS Code / Devin Desktop
                    ├── ChatGPT (published plugin)
                    └── Python SDK / REST

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

A read without a domain covers all of your account's domains. A tool scoped to one domain, such as a GPT told to use project:acme, recalls only that domain.

Configuration ​

These environment variables apply to the local stdio MCP server from the API-key path, not the hosted server added by the keyless link.

VariableRequiredDefault
MNEMOVERSE_API_KEYYes—
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 the "add MCP server by URL" field. A remote MCP connector uses https://mcp.mnemoverse.com/mcp (Remote MCP Server).

Common questions ​

How do I add persistent memory to Cursor? ​

Click the keyless Add to Cursor link above. Cursor adds the hosted server https://mcp.mnemoverse.com/mcp to ~/.cursor/mcp.json as mnemoverse; then open Customize, click Connect next to mnemoverse and approve in the browser. There is no API key to paste, and the entry works in every Cursor window, including the Agents Window. The alternative runs the local server through npx with a free API key from console.mnemoverse.com in ~/.cursor/mcp.json (API-key path). Either way the agent gets memory tools that persist across sessions, shared with every tool connected as the same Mnemoverse account.

Does the Mnemoverse extension work in Cursor? ​

Yes, in part. The Mnemoverse Agent Memory extension installs in Cursor from Open VSX and adds the hosted server to Cursor's editor windows. Cursor's Agents Window runs no extensions, so for it the extension offers Mnemoverse: Add to Cursor (all windows), which puts mnemoverse in ~/.cursor/mcp.json through Cursor's own install. Either way you sign in by clicking Connect in Customize.

Does Cursor memory survive between sessions and projects? ​

Yes. Memories are stored in the hosted Mnemoverse API, not in the editor, so they survive restarts, new chats, and different projects — and the same memory is readable from any other connected tool.

Can Cursor share memory with Claude Code and ChatGPT? ​

Yes, when every tool connects as the same Mnemoverse account. In ChatGPT, install the published Mnemoverse Memory plugin and complete browser sign-in. Check installation availability and memory operations in that account; do not apply custom-server creation restrictions to the published plugin. Custom MCP and Custom GPT Actions are separate alternatives described in the ChatGPT guide.

Source & Distribution ​

npm versionMCP Registry

The MCP server is listed on the Official MCP Registry. Source code is open on GitHub under MIT.