MnemoverseDocs

Appearance

VS Code & Copilot Chat ​

For AI Agents

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

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

Install the extension in VS Code

The Mnemoverse Agent Memory extension is on the VS Code Marketplace and on Open VSX. Install it with the button above, which opens the extension in VS Code, or search Mnemoverse in the Extensions panel, 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. The key is created for you and kept in the OS keychain, so there is 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+). (Ask and Edit Mode are not supported: MCP servers only run in Agent Mode.)

Local or hosted connection ​

The extension registers the server through VS Code's MCP API, so it writes no .vscode/mcp.json. The mnemoverse.connection setting decides how it connects:

SettingWhat runsWhat it needs
local (default)npx -y @mnemoverse/mcp-memory-server@latest on your machine, with the key from Sign InNode.js 18 or later
hostedThe hosted server https://mcp.mnemoverse.com/mcp. VS Code runs the OAuth sign-in the first time the agent uses memoryNo Node.js, no key

Switch with Mnemoverse: Use Hosted Connection (no Node.js) or Mnemoverse: Use Local Connection (npx). If npx is missing, the extension says so before Sign In opens the browser, and offers to switch to the hosted connection.

Where the extension works ​

What the extension can do depends on the editor it is installed in. Editors other than VS Code install it from Open VSX.

EditorWhat the extension does
VS Code 1.102+, InsidersRegisters the server through VS Code's MCP API. The agent in Copilot Chat (Agent Mode) gets the memory tools.
VSCodium, Positron, Eclipse TheiaThe same, through the same API. The tools appear only where the editor's agent uses MCP servers from extensions. Browser Sign In is not yet accepted from Positron, Theia or VSCodium Insiders; there the extension offers Set API Key with a key from the console instead.
CursorAdds the hosted server to editor windows as extension-mnemoverse. The Agents Window runs no extensions, so the extension offers Mnemoverse: Add to Cursor (all windows), which puts mnemoverse in ~/.cursor/mcp.json through Cursor's own install. You sign in with Connect in Customize. Details: Cursor.
Kiro, Windsurf / Devin Desktop, TraeThese editors give extensions no way to add MCP servers. The extension offers Mnemoverse: Copy MCP Config: an entry for the hosted server in the editor's format, with no key, and the name of the file to paste it into. Devin Desktop: sign-in to the hosted server is not verified yet (status).
AntigravityAntigravity reads MCP servers only from its own config file. Its OAuth callback is on the Mnemoverse sign-in allowlist, so add the hosted server there by hand (not verified live): Google Antigravity.

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

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

Install the MCP server in VS Code

Prefer not to install the extension? VS Code 1.102+ can connect to the hosted Mnemoverse server directly over a remote URL, and VS Code runs OAuth and dynamic client registration for you. The button above opens VS Code's own MCP install link (vscode:mcp/install) for a server named mnemoverse of type http at https://mcp.mnemoverse.com/mcp; confirm it in VS Code. To add it by hand, 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_), for this local package only: the hosted server https://mcp.mnemoverse.com/mcp signs in with OAuth and takes no key. 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 ​

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.

Run the check in Copilot Chat Agent mode. 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 VS Code 11 tools, on every path above: 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 Remote MCP Server and Join a shared room.

Universal Memory ​

Same Mnemoverse account, same memories, in every connected tool. In ChatGPT, install the published Mnemoverse Memory plugin and complete browser sign-in with that account; no API key is needed. Claude and the editors use their own setup guides. Custom MCP and Custom GPT Actions remain separate alternatives with their own authentication and creation requirements.

                    ┌── Claude Code / Desktop
   Mnemoverse API ──├── VS Code ← you are here
   (one memory)     ├── Cursor / Devin Desktop
                    ├── ChatGPT (published plugin)
                    └── 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 Agent Memory extension from the VS Code Marketplace, run Mnemoverse: Sign In and approve in your browser. There is no API key to paste. It works in Copilot Chat Agent Mode on VS Code 1.102 or later. Without the extension, the one-click install link adds the hosted server https://mcp.mnemoverse.com/mcp and VS Code signs you in; a manual .vscode/mcp.json with an API key also works.

Does VS Code memory work without an API key? ​

Yes. The extension signs in through the browser: on the default local connection it creates the key for you and keeps it in the OS keychain, and with the setting mnemoverse.connection set to hosted it uses https://mcp.mnemoverse.com/mcp, where VS Code runs the OAuth sign-in and no key or Node.js is needed. Without the extension, a remote server entry of type http pointing at the same URL does the same on VS Code 1.102 or later.

Does the extension work in Cursor, Devin Desktop (formerly Windsurf) and other VS Code-based editors? ​

It depends on the editor; the table above has the details. VSCodium, Positron and Eclipse Theia use the same VS Code MCP API. In Cursor the extension adds the hosted server to editor windows and offers Add to Cursor (all windows) for the Agents Window. Kiro, Windsurf / Devin Desktop and Trae give extensions no way to add MCP servers, so the extension offers Copy MCP Config, a hosted-server entry with no key; from Devin Desktop that sign-in is not verified yet. Antigravity reads MCP servers only from its own config file; its OAuth callback is on the Mnemoverse sign-in allowlist, so the hosted server is added there by hand (not verified live).

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

Yes, when each tool connects to the same Mnemoverse account. In ChatGPT, install the published Mnemoverse Memory plugin and sign in in the browser. The ChatGPT guide explains how to check availability and verify saving and recalling in your account and client.

Source & Distribution ​

npm versionMCP Registry

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