Source: https://mnemoverse.com/docs/api/windsurf
Content revision: e51afd56337ba03158075fc16a1c499c90428efd0dc9ec263ac9117238b34bd0
Updated: 2026-11-05T09:32:01Z

# Devin Desktop (formerly Windsurf)

**For AI Agents**
Machine-readable docs: [mnemoverse.com/docs/llms.txt](https://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](https://docs.devin.ai/desktop/devin-local/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](https://console.mnemoverse.com/sign-up?utm_source=docs&utm_medium=cta&utm_campaign=api-windsurf) (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](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.

## Add to Devin Desktop

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

| Scope | File |
| --- | --- |
| 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](https://mnemoverse.com/docs/api/windsurf#set-up-in-windsurf-before-the-rename)). 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](https://cli.devin.ai) 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](https://mnemoverse.com/docs/api/agent-memory#editor-rule-files-need-frontmatter)).

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](https://mnemoverse.com/docs/api/vs-code#where-the-extension-works)** installs in Devin Desktop from [Open VSX](https://open-vsx.org/extension/mnemoverse/mnemoverse-vscode), 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) {#keyless}

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](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-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](https://docs.devin.ai/desktop/devin-desktop-faq) and [customizations](https://docs.devin.ai/desktop/devin-local/customizations) pages added then): the [Devin Desktop changelog](https://docs.devin.ai/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](https://docs.devin.ai/desktop/devin-local) page, and Devin CLI's [MCP configuration](https://docs.devin.ai/cli/extensibility/mcp/configuration) and [configuration import](https://docs.devin.ai/cli/reference/configuration/read-config-from) 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](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 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](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) are covered in [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 ──├── 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

| Variable | Required | Default |
|----------|----------|---------|
| `MNEMOVERSE_API_KEY` | Yes | none |
| `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 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](https://console.mnemoverse.com/sign-up?utm_source=docs&utm_medium=cta&utm_campaign=api-windsurf) 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 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): one-click install or `~/.cursor/mcp.json`
- [VS Code](https://mnemoverse.com/docs/api/vs-code): keyless extension with browser sign-in
- [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