Source: https://mnemoverse.com/docs/api/vs-code
Content revision: 9e549a48e7746352a2ceb6fea779a86a071335fb91a0db19e0ceceed44e8ee6e
Updated: 2026-11-04T21:21:12Z

# VS Code & Copilot Chat

**For AI Agents**
Machine-readable docs: [mnemoverse.com/docs/llms.txt](https://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.

## Keyless extension (recommended)

[![Install the extension in VS Code](https://img.shields.io/badge/VS_Code-Install_extension-0098FF)](https://vscode.dev/redirect?url=vscode%3Aextension%2FMnemoverse.mnemoverse-vscode)

The **[Mnemoverse Agent Memory](https://marketplace.visualstudio.com/items?itemName=Mnemoverse.mnemoverse-vscode)** extension is on the VS Code Marketplace and on [Open VSX](https://open-vsx.org/extension/mnemoverse/mnemoverse-vscode). 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:

| Setting | What runs | What it needs |
| --- | --- | --- |
| `local` (default) | `npx -y @mnemoverse/mcp-memory-server@latest` on your machine, with the key from **Sign In** | Node.js 18 or later |
| `hosted` | The hosted server `https://mcp.mnemoverse.com/mcp`. VS Code runs the OAuth sign-in the first time the agent uses memory | No 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.

| Editor | What the extension does |
| --- | --- |
| **VS Code 1.102+**, Insiders | Registers the server through VS Code's MCP API. The agent in Copilot Chat (Agent Mode) gets the memory tools. |
| **VSCodium, Positron, Eclipse Theia** | The 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](https://console.mnemoverse.com) instead. |
| **Cursor** | Adds 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](https://mnemoverse.com/docs/api/cursor). |
| **Kiro, Windsurf / Devin Desktop, Trae** | These 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](https://mnemoverse.com/docs/api/windsurf#keyless)). |
| **Antigravity** | Antigravity 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](https://mnemoverse.com/docs/api/install-by-host#google-antigravity). |

Source & issues: [github.com/mnemoverse/mnemoverse-vscode](https://github.com/mnemoverse/mnemoverse-vscode).

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

[![Install the MCP server in VS Code](https://img.shields.io/badge/VS_Code-Install_MCP_server-0098FF)](https://vscode.dev/redirect/mcp/install?name=mnemoverse&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.mnemoverse.com%2Fmcp%22%7D)

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](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist). 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](https://console.mnemoverse.com/sign-up?utm_source=docs&utm_medium=cta&utm_campaign=api-vs-code) (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](https://mnemoverse.com/docs/api/getting-started#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](https://github.com/mnemoverse/mnemoverse-vscode) 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](https://mnemoverse.com/docs/api/agent-memory). It is not required for the explicit check above.

If this setup saved you time, a [GitHub star](https://github.com/mnemoverse/mcp-memory-server) 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](https://mnemoverse.com/docs/api/mcp-server#tools) page lists every tool and what it does.

For detailed parameter docs, see [Claude Code](https://mnemoverse.com/docs/api/claude#tools) or [API Reference](https://mnemoverse.com/docs/api/reference). Shared rooms (Beta), a memory pool shared across accounts, are covered in [Remote MCP Server](https://mnemoverse.com/docs/api/remote-mcp-server) and [Join a shared room](https://mnemoverse.com/docs/api/agent-setup#join-a-shared-room-beta).

## Universal Memory

Same Mnemoverse account, same memories, in every connected tool. In ChatGPT, [install the published Mnemoverse Memory plugin](https://mnemoverse.com/docs/api/chatgpt#install-the-published-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](https://mnemoverse.com/docs/api/chatgpt#alternative-setups) 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

| Variable | Required | Default |
|----------|----------|---------|
| `MNEMOVERSE_API_KEY` | Yes (manual config only) | — |
| `MNEMOVERSE_API_URL` | No | `https://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](https://mnemoverse.com/docs/api/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](https://mnemoverse.com/docs/api/vs-code#remote-url-oauth-vs-code-1-102-no-api-key) 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](https://mnemoverse.com/docs/api/vs-code#where-the-extension-works) 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 version](https://img.shields.io/npm/v/@mnemoverse/mcp-memory-server.svg?color=cb3837&label=npm)](https://www.npmjs.com/package/@mnemoverse/mcp-memory-server)
[![MCP Registry](https://img.shields.io/badge/MCP_Registry-listed-0ea5e9)](https://registry.modelcontextprotocol.io/v0/servers?search=mnemoverse)

The MCP server is listed on the [Official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=mnemoverse). Source code is open on [GitHub](https://github.com/mnemoverse/mcp-memory-server) under MIT.

## Related

- [Make Your Agent Use Memory](https://mnemoverse.com/docs/api/agent-memory) — connecting is step one; get the agent to actually call the memory tools
- [Cursor](https://mnemoverse.com/docs/api/cursor) — keyless Add to Cursor link, or `~/.cursor/mcp.json` with an API key
- [Windsurf](https://mnemoverse.com/docs/api/windsurf) — Windsurf / Devin Desktop setup
- [Editors overview](https://mnemoverse.com/docs/api/editors) — all editor paths side by side
- [Claude Code](https://mnemoverse.com/docs/api/claude) — the Claude CLI
- [ChatGPT](https://mnemoverse.com/docs/api/chatgpt) — the published Mnemoverse Memory plugin and alternative custom setups
- [Remote MCP Server](https://mnemoverse.com/docs/api/remote-mcp-server) — connect over one-click OAuth, no API key
- [API Reference](https://mnemoverse.com/docs/api/reference) — full endpoint documentation