MnemoverseDocs

Appearance

Cursor ​

For AI Agents

Machine-readable docs: mnemoverse/llms.txt (works in all sandboxes)

Give Cursor persistent memory. One config entry — the agent remembers across sessions, projects, and even other tools.

Choose your connection. The local MCP setup below uses an API key from console.mnemoverse.com (free, no credit card) and runs through npx, which needs Node.js 18 or later. For no API key to paste, use one of the keyless options: the Mnemoverse Memory extension or remote MCP with browser sign-in. Every tool connected as the same Mnemoverse account shares one memory.

Add to Cursor ​

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.

Keyless options ​

The keyless Mnemoverse Memory extension is also on Open VSX and works in Cursor — install, click Sign In, done.

Remote OAuth ​

Prefer no key at all? Cursor's native OAuth (cursor://) is permitted by the hosted connector's sign-in allowlist: add a remote MCP server pointing at https://mcp.mnemoverse.com/mcp and sign in via the browser — no API key to paste. See which clients can sign in. If OAuth doesn't complete on your setup, the ~/.cursor/mcp.json config above always works.

Try It ​

Make Cursor's AI actually use Mnemoverse

Connecting adds the memory tools; it doesn't make the assistant use them. By default it answers from its own context, not Mnemoverse. Set a one-line standing instruction first: Make Your Agent Use Memory.

With that in place, the win is one memory across tools. In Cursor:

"Remember: this repo's migrations run with make db-migrate, never prisma migrate directly."

Later, in Claude Code or ChatGPT — a different tool:

"How do I run migrations here?"

It recalls the rule, because the memory lives in Mnemoverse, not in Cursor. (A same-tool "it remembers" demo wouldn't prove much — cross-tool recall is what needs Mnemoverse.)

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

Tools ​

The MCP server gives Cursor 5 core memory tools:

ToolWhat it does
memory_writeStore a preference, decision, or lesson
memory_readSearch memories by natural language query — optionally newest-first (order_by) or time-bounded (since / until)
memory_list_recentList newest memories first, no query — catch up after a break or on a shared room
memory_feedbackReport if a memory was helpful (+1) or wrong (-1)
memory_statsCheck how many memories are stored

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 tool, whether a tool connects with OAuth or an API key.

                    ┌── Claude Code / Desktop
   Mnemoverse API ──├── Cursor ← you are here
   (one memory)     ├── VS Code / Windsurf
                    ├── ChatGPT (MCP / Actions)
                    └── 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 configured by hand in mcp.json, not the remote OAuth connection.

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? ​

Add the Mnemoverse MCP server to ~/.cursor/mcp.json with a free API key from console.mnemoverse.com, then restart Cursor. The Add to Cursor button writes the same entry with a placeholder key, which you then replace in the file it wrote. To skip the key, install the Mnemoverse Memory extension from Open VSX and sign in, or add the remote server https://mcp.mnemoverse.com/mcp and sign in through the browser; if browser sign-in does not complete on your setup, the mcp.json config always works. Either way the agent gets memory tools that persist across sessions, shared with every tool connected as the same Mnemoverse account.

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. The memory belongs to the account, not to a tool or a key, so a rule you store in Cursor can be recalled in Claude Code or ChatGPT without re-explaining. Whether ChatGPT can connect, and whether it can save or only recall, depends on your ChatGPT plan.

Source & Distribution ​

npm versionMCP Registry

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