Cursor, VS Code & Windsurf

For AI Agents

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

Give your code editor persistent memory. One config file — it remembers across sessions.

The VS Code extension is keyless — install it, click Sign In, approve in your browser, done. No API key to copy or paste.

For the manual mcp.json configs (Cursor, Windsurf, other editors) you'll need an API key — get one free at console.mnemoverse.com (no credit card). If you already have a key from Claude Code or ChatGPT — use the same one. That's the point.

VS Code + GitHub Copilot Chat Agent Mode

The Mnemoverse Memory extension is on the VS Code Marketplace (and on Open VSX for VSCodium / Cursor / Windsurf). Install it — Extensions panel → search Mnemoverse Memory → Install, or run code --install-extension Mnemoverse.mnemoverse-vscode. Then run Mnemoverse: Sign In from the Command Palette (or click Sign In on the welcome notification): your browser opens, you approve, and you're connected — no API key to paste. If your browser can't return automatically, copy the code it shows and run Mnemoverse: Complete sign-in. Works in Copilot Chat Agent Mode (VS Code 1.102+) and other VS Code forks on the same base. Prefer manual config instead? The .vscode/mcp.json below also works (that path needs an API key).

Chat client	Install path
VS Code + Copilot Chat — Agent Mode	Mnemoverse Memory extension or manual .vscode/mcp.json
VS Code + Copilot Chat — Ask / Edit Mode	Not supported — MCP servers only run in Agent Mode
VS Code — any other MCP-consuming extension	Manual .vscode/mcp.json (see below)
Cursor	.cursor/mcp.json (see Cursor section below)
Windsurf — now Devin Desktop (docs)	~/.codeium/windsurf/mcp_config.json (path still works; see Windsurf section below)

Source & issues: github.com/mnemoverse/mnemoverse-vscode.

Remote URL + OAuth (VS Code 1.102+, no API key)

Prefer not to install the extension? VS Code 1.102+ can connect to the hosted Mnemoverse Memory connector directly over a remote URL — VS Code runs OAuth and dynamic client registration for you, so there's no API key to paste. Add a server of type http pointing at the connect endpoint:

{
  "servers": {
    "mnemoverse": {
      "type": "http",
      "url": "https://mcp.mnemoverse.com/mcp"
    }
  }
}

On first use VS Code opens your browser to sign in, registers itself automatically (PKCE / DCR), and connects. This is verified working on VS Code Desktop (it uses a loopback redirect). The remote connector exposes seven tools — memory_read, memory_stats, memory_write, and memory_feedback, plus the three Beta shared-room tools (memory_create_room, memory_invite_to_room, memory_join_room).

Caveats

• The keyless Mnemoverse Memory extension is still the simplest path for most people — install, click Sign In, done.
• VS Code in the browser / Codespaces (via vscode.dev/redirect) and Cursor's native OAuth (cursor://) are permitted by the sign-in allowlist — see which clients can sign in. If OAuth doesn't complete on your setup, the extension or the manual mcp.json with an API key (below) always works.

Manual JSON config (Cursor, VS Code, Windsurf)

Cursor — click to install, or add to .cursor/mcp.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"
      }
    }
  }
}

VS Code — add to .vscode/mcp.json (note: VS Code uses servers, not mcpServers):

{
  "servers": {
    "mnemoverse": {
      "type": "stdio",
      "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"
      }
    }
  }
}

Windsurf — add to ~/.codeium/windsurf/mcp_config.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 your editor 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.

Try It

Make the editor 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 (or VS Code):

"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 any single editor. (A same-tool "it remembers" demo wouldn't prove much — cross-tool recall is what needs Mnemoverse.)

Tools

The MCP server gives your editor 6 core memory tools (the Beta shared-room tools are covered separately below):

Tool	What it does
memory_write	Store a preference, decision, or lesson
memory_read	Search memories by natural language query
memory_feedback	Report if a memory was helpful (+1) or wrong (-1)
memory_stats	Check how many memories are stored
memory_delete	Permanently delete a single memory by its id
memory_delete_domain	Wipe all memories in a domain (requires explicit confirm)

For detailed parameter docs, see Claude Code or API Reference.

Shared rooms (Beta)

Your editor's agent can also share a memory pool with other accounts through a room. Three Beta tools — memory_create_room, memory_invite_to_room (which mints a one-time share code, mnvr_...), and memory_join_room — create a room, invite someone, and join one. Members read and write the shared pool by passing domain: "xroom:<room_id>" on memory_write / memory_read. See Join a shared room for the full flow.

Universal Memory

Same API key, same memories — across all tools.

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

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

Configuration

Variable	Required	Default
MNEMOVERSE_API_KEY	Yes	—
MNEMOVERSE_API_URL	No	https://core.mnemoverse.com/api/v1

Source & Distribution

The MCP server is also listed on the Official MCP Registry — any MCP-aware client that browses the registry will find it there. Source code is open on GitHub under MIT.

Related

• Make Your Agent Use Memory — connecting is step one; get the agent to actually call the memory tools
• Remote MCP Server — connect over one-click OAuth, no API key
• Claude Code — the Claude CLI
• Claude Desktop, Web & Mobile — the Claude apps
• ChatGPT — give any Custom GPT persistent memory
• Python SDK — for scripts and backends
• API Reference — full endpoint documentation