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 another editor, use the same one.

Check the key before you add it. Check your API key asks the API whether it accepts the key, from bash or PowerShell, and names the cause if it does not.

VS Code — the VS Code extension signs in through the browser and needs no key; that's the default path. In VS Code's non-interactive Agent Host mode, servers that prompt for inputs like this one are not started; for unattended use there, put the key in the environment of the process that launches VS Code instead. To wire the MCP server directly instead, add this to .vscode/mcp.json (note: VS Code uses servers, not mcpServers). Never put a literal mk_live_ key in that file — it's committed with the repo. The inputs entry below prompts for the key instead: VS Code masks what you type and stores it in its own secret storage, not in the file:

json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "mnemoverse-api-key",
      "description": "Mnemoverse API key (starts with mk_live_). Optional to install and inspect — the server starts and lists its tools without a key; every actual tool call requires one. Get one free in ~30s at https://console.mnemoverse.com",
      "password": true
    }
  ],
  "servers": {
    "mnemoverse": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@mnemoverse/mcp-memory-server@latest"
      ],
      "env": {
        "MNEMOVERSE_API_KEY": "${input:mnemoverse-api-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.)

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

Tools ​

The MCP server gives VS Code 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. The remote OAuth connector also carries the Beta shared-room tools — see Remote MCP Server and Join a shared room.

Universal Memory ​

Same Mnemoverse account, same memories, in every tool. Claude and the editors connect with an API key or OAuth. ChatGPT's MCP connector signs in with OAuth instead of a key, while a Custom GPT uses an API key, so sign in with the Mnemoverse account your other tools use.

                    ┌── Claude Code / Desktop
   Mnemoverse API ──├── VS Code ← you are here
   (one memory)     ├── Cursor / Windsurf
                    ├── ChatGPT (MCP / 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.