Mnemoverse Memory for VS Code

Persistent memory for GitHub Copilot Chat Agent Mode — one memory, every AI tool.

What this extension does

Adds Mnemoverse Memory as an MCP server inside GitHub Copilot Chat's Agent Mode, with no .vscode/mcp.json file to edit and no JSON config to commit. Once installed and connected, your Copilot agent gains six tools for long-term memory: it can store facts, preferences, and decisions during one chat and recall them from any future chat — across sessions, branches, and projects.

Scope (honest)

This specific extension wires Mnemoverse into GitHub Copilot Chat Agent Mode on VS Code 1.102 or newer. That's currently the only chat client in the VS Code ecosystem that consumes MCP servers registered via the native vscode.lm API.

If you use a different editor / client, install Mnemoverse there directly — the memory is the same account, the setup is different:

Client	Mode	How to install Mnemoverse
VS Code + Copilot Chat	Agent Mode	This extension (1-click from Marketplace)
VS Code + Copilot Chat	Ask / Edit Mode	Not supported — MCP servers only run in Agent Mode
Cursor	built-in chat	`.cursor/mcp.json` snippet
Windsurf	built-in chat	`~/.codeium/windsurf/mcp_config.json` snippet
Claude Code	CLI	`claude mcp add` one-liner
Claude Desktop	app	`claude_desktop_config.json` snippet
ChatGPT	Custom GPT	GPT Actions + OAuth
Any HTTP client	—	REST API

Write a memory in any of the tools above → read it from any other. Same Mnemoverse account, same memory layer, different integration plumbing per client.

Requirements

VS Code 1.102 or newer — required for the registerMcpServerDefinitionProvider API this extension uses
GitHub Copilot Chat extension installed and signed in
A free Mnemoverse account — sign up at console.mnemoverse.com, no credit card (you connect from VS Code in one click — no key to copy or paste)
Node.js on your PATH — the extension spawns npx to run the memory server

Install

Search for "Mnemoverse Memory" in the VS Code Marketplace and click Install.
Run Mnemoverse: Sign In from the Command Palette (or click Sign In on the welcome notification). Your browser opens console.mnemoverse.com; approve the connection and you're connected. No API key to copy or paste: the key is minted for you and stored in the OS keychain, never on disk.
Open Copilot Chat (Cmd/Ctrl+Shift+I), switch the mode picker to Agent (MCP servers only show there), and ask the agent to remember something.

If your browser can't return you to VS Code automatically (some remote/SSH setups, or a browser that blocks custom URL schemes), copy the code the page shows and run Mnemoverse: Complete sign-in to paste it. Or skip the browser entirely and paste a key by hand with Mnemoverse: Set API Key (paste manually) — keyless Sign In is just the default.

Try it

In a Copilot Chat Agent Mode session:

Remember that I prefer Railway for deployments.

Open a new chat and ask:

Where should I deploy this?

If Copilot recalls Railway, everything is wired up. The memory persists across sessions, machines with the same account, and every other Mnemoverse-connected tool.

Tools exposed to the agent

Tool	What it does
`memory_write`	Store a preference, decision, or lesson
`memory_read`	Search memories by natural-language query
`memory_feedback`	Rate a memory as helpful or harmful (affects future retrieval)
`memory_stats`	Show total memories, domains, and average importance
`memory_delete`	Permanently delete one memory by id
`memory_delete_domain`	Wipe an entire domain (safety interlocked)

Commands

Command	What it does
`Mnemoverse: Sign In`	Connect your memory via the browser — no key to paste. The default.
`Mnemoverse: Complete sign-in`	Finish a Sign In when the browser couldn't return automatically — paste the code from the page.
`Mnemoverse: Sign Out`	Disconnect and clear the stored key.
`Mnemoverse: Set API Key (paste manually)`	Fallback: paste a key directly. Clears any existing one first.
`Mnemoverse: Clear API Key`	Remove the stored key. The server won't start until you reconnect.
`Mnemoverse: Open Documentation`	Open the docs in your default browser.

How it works (internals)

This extension uses vscode.lm.registerMcpServerDefinitionProvider — the canonical 2026 path for third-party MCP server integration in VS Code. It contributes an entry to VS Code's Language Model namespace rather than writing a .vscode/mcp.json file in your workspace. No config files are created.

When Copilot Chat Agent Mode calls into our provider's resolveMcpServerDefinition, we pull your API key from vscode.SecretStorage (OS keychain) and spawn npx -y @mnemoverse/mcp-memory-server@latest with the key in the child process environment. The @latest tag ensures you automatically get new releases of the underlying mcp-memory-server npm package — same binary our docs point Claude Desktop and Cursor users at, same open-source implementation.

The server itself is a thin stdio wrapper that forwards tool calls to core.mnemoverse.com/api/v1 over HTTPS. The API key never leaves your machine for any purpose except authenticating API calls to Mnemoverse.

Privacy and security

Your API key is stored only in vscode.SecretStorage (OS keychain — macOS Keychain, Windows Credential Vault, Linux libsecret). Never on disk, never in settings.json, never in git.
The extension contains zero telemetry of its own.
Memory content is sent to core.mnemoverse.com over HTTPS. See the Mnemoverse privacy policy for what is stored and for how long.
Capabilities declared in package.json: untrustedWorkspaces: false (we spawn npx, which runs arbitrary third-party code), virtualWorkspaces: false (we need a local Node.js runtime).

Security disclosures

Found a vulnerability? Contact security@mnemoverse.com or file a private advisory at github.com/mnemoverse/mnemoverse-vscode/security/advisories/new. Coordinated disclosure policy: mnemoverse.com/.well-known/security.txt.

Source

MIT licensed: github.com/mnemoverse/mnemoverse-vscode. Contributions welcome.