MnemoverseDocs

Appearance

VS Code & Copilot Chat ​

For AI Agents

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

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

The Mnemoverse Memory extension is on the VS Code Marketplace (and on Open VSX for VSCodium, Cursor, and 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 VS Code forks on the same base. (Ask / Edit Mode is not supported — MCP servers only run in Agent Mode.)

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. Add a server of type http pointing at the connect endpoint:

json
{
  "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). VS Code in the browser / Codespaces (via vscode.dev/redirect) is also 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 always works.

Manual config (API key) ​

For the manual path 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.

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

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

⚠️ Restart VS Code 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 Copilot 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 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 the editor. (A same-tool "it remembers" demo wouldn't prove much — cross-tool recall is what needs Mnemoverse.)

Tools ​

The MCP server gives VS Code 7 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
memory_deletePermanently delete a single memory by its id
memory_delete_domainWipe all memories in a domain (requires explicit confirm)

For detailed parameter docs, see Claude Code or API Reference. The remote OAuth connector exposes a slightly different tool set (no delete tools, plus the Beta shared-room set) — see Remote MCP Server and Join a shared room.

Universal Memory ​

Same API key, same memories — across all tools.

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

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

Configuration ​

VariableRequiredDefault
MNEMOVERSE_API_KEYYes (manual config only)—
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 VS Code and Copilot Chat? ​

Install the Mnemoverse Memory extension from the VS Code Marketplace, click Sign In, and approve in your browser — no API key to paste. It works in Copilot Chat Agent Mode (VS Code 1.102+). Manual .vscode/mcp.json with an API key also works.

Does VS Code memory work without an API key? ​

Yes, two keyless paths: the Mnemoverse Memory extension (browser sign-in) or a remote MCP server entry of type http pointing at https://mcp.mnemoverse.com/mcp — VS Code 1.102+ runs OAuth for you.

Can VS Code share memory with Cursor, Claude Code, and ChatGPT? ​

Yes. Every tool connects to the same hosted memory behind one API key or OAuth, so a fact stored from VS Code is recalled in Cursor, Claude Code, or ChatGPT without re-explaining.

Source & Distribution ​

npm versionMCP Registry

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