MnemoverseDocs

Appearance

Devin Desktop (formerly Windsurf) ​

For AI Agents

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

Give Devin Desktop persistent memory. Windsurf was renamed Devin Desktop on 2 June 2026, and since version 3.9.19 of 8 September 2026 its agent is Devin Local: Cascade has been removed. This guide keeps its old address, so links to the Windsurf page still land here.

Devin Local has no memory feature. Devin's documentation says Devin Local "replaces memories and workflows with rules and skills", and its customizations page lists rules, skills, plugins, MCP servers and hooks. These carry what you write into them. An MCP memory server is one way to keep what the agent learns from one session to the next, and Mnemoverse carries it into your other tools as well.

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, Cursor, or VS Code, use the same one. That's the point.

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.

Add to Devin Desktop ​

Devin Local reads MCP servers from the same config files as Devin CLI. Pick the file by scope:

ScopeFile
You, in every project~/.config/devin/mcp_config.json (macOS and Linux), %APPDATA%\devin\mcp_config.json (Windows)
One project, shared through the repository.devin/mcp_config.json
One project, only you (gitignored).devin/mcp_config.local.json

Put an entry that holds your key in the user file or the local one. Devin's documentation says project-level servers "are shared with your team via version control", so a key in .devin/mcp_config.json is committed with the code.

The entry is the same JSON Windsurf used, so an entry already in the old Windsurf file keeps loading (below). For a new setup, paste it into the Devin user file:

Devin Desktop (formerly Windsurf) — add to ~/.config/devin/mcp_config.json:

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

If you have Devin CLI installed (a separate install from Devin Desktop), it writes the same entry to the user file from a terminal:

bash
devin mcp add -s user -e MNEMOVERSE_API_KEY=mk_live_YOUR_KEY mnemoverse -- npx -y @mnemoverse/mcp-memory-server@latest

Without -s user, the CLI saves the entry to .devin/mcp_config.local.json in the current project.

⚠️ Restart Devin Desktop after editing the config file, then start a new Devin Local session.

Check that it loaded. Choose Open customizations from the new-tab menu in an agent space, or right-click a Devin Local session in the agent sidebar: the list shows the MCP servers the session loaded. By default Devin Local asks before it calls any MCP tool, and you can allow one tool or every tool on the mnemoverse server, for the session or permanently.

Why @latest? It forces a registry metadata lookup on every session start so you always get the newest release, whereas bare npx @mnemoverse/mcp-memory-server caches the first installed version indefinitely.

Set up in Windsurf before the rename? ​

The old file still counts. Devin's configuration import reads MCP servers from ~/.codeium/windsurf/mcp_config.json by default: its windsurf option defaults to true. The import is documented for Devin CLI, whose agent harness Devin Local shares. An existing mnemoverse entry there keeps loading, so you do not need a second copy.

The same import also reads MCP servers from Claude Code (.mcp.json, ~/.claude.json and its settings files), Cursor (.cursor/mcp.json), OpenCode and Zed, so a mnemoverse entry you added for one of those tools may already be loaded. Before you add one, look for an existing mnemoverse server in Open customizations, or run devin mcp list in Devin CLI. Devin's documentation does not say which entry wins when two share a name.

To turn the Windsurf import off, set "read_config_from": { "windsurf": false } in ~/.config/devin/config.json. Devin's import page lists Windsurf rules and skills under the same option, so .windsurf/rules/ may stop loading too. Move the memory rules to .devin/rules/ first (Make Your Agent Use Memory).

Devin builds before v3000.3 kept MCP servers under mcpServers in ~/.config/devin/config.json itself, and the Devin Local page still shows that file. Current builds use the dedicated mcp_config.json and move old entries into it on startup.

With the Mnemoverse Agent Memory extension ​

The Mnemoverse Agent Memory extension installs in Devin Desktop from Open VSX, but it cannot connect memory by itself there: the editor gives extensions no way to add MCP servers. Its Mnemoverse: Copy MCP Config command copies an entry for the hosted server https://mcp.mnemoverse.com/mcp, with no key, and names the file to paste it into. That entry is the keyless route described next. If the copied entry says serverUrl, the Windsurf field name, rename it to url, the field Devin's MCP documentation uses for a remote server.

Keyless: the hosted connector (not verified) ​

Devin Desktop can also point at the hosted connector, with no key in the file:

json
{
  "mcpServers": {
    "mnemoverse": {
      "url": "https://mcp.mnemoverse.com/mcp"
    }
  }
}

OAuth sign-in to the hosted connector from Devin Local is not verified yet. Devin documents a browser sign-in for MCP servers that use OAuth: Devin CLI runs it with devin mcp login mnemoverse or prompts when the server is first used, and Devin Desktop shows Needs auth with an Authenticate button when stored credentials expire. We have not run that flow against Mnemoverse, and whether it completes depends on the registration allowlist. Until it is verified, use the API-key entry above.

Sources, read 2026-10-04 (the Devin Local memory line re-read 2026-11-04, and the Devin Desktop FAQ and customizations pages added then): the Devin Desktop changelog (v3.0.12, 2 June 2026: "Windsurf is now Devin Desktop."; v3.9.19, 8 September 2026: "Cascade has been removed. Devin Local is now the only agent available in Devin Desktop."), the Devin Local agent page, and Devin CLI's MCP configuration and configuration import pages. From host documentation, not verified live.

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 this check using the connection you configured; it does not establish that Devin's unverified OAuth route works. 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 MCP server gives Devin Desktop 11 tools: 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) are covered in 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 ──├── Devin Desktop ← you are here
   (one memory)     ├── Cursor / VS Code
                    ├── ChatGPT (published plugin)
                    └── Python SDK / REST

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

Configuration ​

VariableRequiredDefault
MNEMOVERSE_API_KEYYesnone
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 Devin Desktop (Windsurf)? ​

Add the Mnemoverse MCP server to ~/.config/devin/mcp_config.json (%APPDATA%\devin\mcp_config.json on Windows) with your API key and restart Devin Desktop. Devin Local, the agent in Devin Desktop, reads MCP servers from the same config files as Devin CLI. One free key from console.mnemoverse.com covers every tool.

Does my Windsurf MCP config still work in Devin Desktop? ​

By default, yes. Devin imports MCP servers from ~/.codeium/windsurf/mcp_config.json unless the windsurf option of read_config_from is set to false, so an entry added before the rename keeps loading. New entries belong in ~/.config/devin/mcp_config.json.

Does Devin Desktop remember earlier sessions? ​

Not as a memory feature. Devin's documentation says Devin Local "replaces memories and workflows with rules and skills", and its customizations page lists rules, skills, plugins, MCP servers and hooks. Rules, AGENTS.md files and skills carry only what you write into them. An MCP memory server is one way to keep what the agent learns across sessions, and Mnemoverse also carries it into your other tools.

Can Devin Desktop share memory with Claude Code, Cursor, 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.