Install by host

Mnemoverse is a hosted memory service for AI agents. Every host that connects reaches the same memory: a fact saved from one tool is recalled in every other tool connected to the same account. The difference between hosts is only packaging and sign-in.

There are three ways a host gets the memory:

A plugin repository. mnemoverse/claude-plugin carries an Agent Plugins 1.0.0 manifest (plugin.json and mcp.json at the repository root), a Claude Code manifest (.claude-plugin/plugin.json and .claude-plugin/marketplace.json, with the server in .mcp.json), and a Kimi Code manifest (kimi.plugin.json). Most hosts that read one of these formats install it straight from GitHub; NanoClaw takes it from a local clone. The plugin points at the hosted server https://mcp.mnemoverse.com/mcp. On hosts that run a sign-in for a server that comes from a plugin, the sign-in is a browser flow (OAuth 2.1 with PKCE), started on first use or by the host's sign-in command, and there is no API key to paste. Hermes Agent, OpenClaw, NanoClaw and OpenHands load the plugin but run no sign-in for its server; their sections say what to do instead.
A host-native package. The Cursor plugin, the Gemini CLI extension, the VS Code extension and the Claude Desktop .mcpb bundle from the mcp-memory-server releases.
A plain MCP entry. The remote URL https://mcp.mnemoverse.com/mcp in any client that can complete a browser sign-in, or the local package npx -y @mnemoverse/mcp-memory-server@latest with an API key from console.mnemoverse.com (free tier, no credit card). The remote URL accepts only the browser sign-in and never an API key; a key works only with the local package. Both paths are on Quick Setup.

Every path that signs in exposes the same 11 tools: the memory tools (memory_write, memory_read and the rest), the shared-room tools and vault_list (aliases only, never values). The MCP Server page lists every one. ChatGPT is the one declared exception: it does not get vault_list (where each tool works).

The plugin also carries three commands (/mnemoverse:remember, /mnemoverse:recall, /mnemoverse:memory-status). Commands are a Claude Code feature: most other hosts load only the skills and the MCP server from the plugin, and each section below says what that host loads. The setup skill's instructions are written for Claude Code as well, so on any other host follow that host's section on this page instead.

How to read the Status column

Shipped means the package or manifest is published by Mnemoverse and the install path is on its own documentation page. Verified live means Mnemoverse ran the sign-in and one memory call (memory_stats) through that host's own runtime, on the date the section's Source line gives — not a full model conversation through the host. From host documentation, not verified live means the command or steps come from that host's own documentation, or from its source code where the section says so, as read on the date in the section's Source line, and Mnemoverse has not yet run them end to end on that host. Needs a live test means the host's documentation or source shows that the plugin route does not sign in, and this page gives no other route on that host until one has been run. Not supported by the host means the host's own documentation rules out the hosted server. If a step does not behave as written, write to support@mnemoverse.com with the host name and version.

Summary

Host	Form	Sign-in	Status
Claude Code	plugin from `mnemoverse/claude-plugin`	browser, no key	Shipped
Claude Desktop	`.mcpb` bundle, or a custom connector (Connect to Claude)	API key in the bundle settings; connector: browser, no key	Shipped
Cursor	`mnemoverse/cursor-plugin` in the local plugins folder, or `mcp.json`	browser, no key, from the desktop app	Shipped (plugin), local install steps from host documentation
Cursor on the web and Cloud Agents	remote MCP server entry, MCP dropdown at cursor.com/agents	browser, no key	From host documentation, not verified live
VS Code and Copilot Chat	extension from the Marketplace, or the Agent Plugin from source	browser, no key	Shipped (extension); Agent Plugin from host documentation
GitHub Copilot CLI	`copilot plugin install mnemoverse/claude-plugin`	browser, no key	From host documentation, not verified live
GitHub Copilot cloud agent	none	none: the host does not support remote MCP servers that use OAuth	Not supported by the host
Gemini CLI	`gemini extensions install` from `mnemoverse/gemini-extension`	browser, no key	Shipped
Kimi Code	`/plugins install` from `mnemoverse/claude-plugin` (`kimi.plugin.json`)	browser, no key	Shipped manifest; install line from host documentation
Codex CLI	plugin from `mnemoverse/claude-plugin`, or a remote MCP server entry	browser, no key, through `codex mcp login`	From host documentation, not verified live
Codex IDE extension	remote MCP server entry only; the extension does not support plugins	browser, no key	From host documentation, not verified live
ChatGPT	developer-mode app	browser, no key	From host documentation, not verified live (an existing Mnemoverse connector on ChatGPT Pro passed `memory_stats`, a write and a read; sign-in and developer-mode app creation were not run)
Kiro	`~/.kiro/settings/mcp.json` entry with `oauthScopes`; the power from the GitHub URL for the skills only	browser, no key, through the `mcp.json` entry	From host documentation, not verified live
Hermes Agent	`hermes plugins install mnemoverse/claude-plugin` for the skills, plus a server entry in `config.yaml`	not through the plugin; browser, no key through the `config.yaml` entry	Verified live (sign-in and `memory_stats` through the `config.yaml` entry); plugin install from host documentation
OpenClaw	bundle from the repository, loaded as a Claude bundle, plus a native server entry for sign-in	not through the plugin; browser, no key, through `openclaw mcp add --auth oauth` and then `openclaw mcp login`	Verified live (sign-in and `memory_stats` through the native server entry); plugin install from host documentation
Grok	Grok Build: `grok plugin install mnemoverse/claude-plugin --trust`; Grok Bot: its Marketplace, or a connector your Cursor team permits	Grok Build: browser, no key	From host documentation, not verified live
NanoClaw	template stamped from `templates/`; the host also accepts a server the operator adds with a `headers` map, under a name the plugin does not own	none through the plugin; the header path needs an API key as a bearer token, which the endpoint does not accept yet	Needs a live test; blocked on the Mnemoverse endpoint (planned, no date)
OpenHands	a manual server entry with OAuth (app MCP page or the SDK's `auth.strategy: oauth2`), without the plugin	browser, no key, through the manual entry (local app, SDK, or OpenHands Cloud); the plugin's server does not sign in	From host documentation, not verified live
Dust	remote MCP server, Spaces → Tools → Add Tool → Add MCP Server	browser, no key	From host documentation, not verified live
Amazon Quick	MCP integration, Connectors → Create for your team → Model Context Protocol (MCP)	browser, no key	From host documentation, not verified live
Langdock	MCP integration with OAuth 2.0 (Dynamic Client Registration)	browser, no key	From host documentation, not verified live
Perplexity	custom remote connector, Computer → Customize → Connectors	browser, no key	From host documentation, not verified live
Mistral Vibe	`/mcp add` with the memory scopes	browser, no key	From host documentation, not verified live
Make	MCP Client app connection, + New MCP Server	browser, no key	From host documentation, not verified live
Devin (hosted)	remote MCP server entry, Customize → MCPs → Add custom MCP	browser, no key	From host documentation, not verified live
Replit connectors	remote MCP server entry, `+ Add MCP server`	browser, no key	From host documentation, not verified live
Warp	remote MCP server entry, Settings > Agents > MCP servers (desktop app)	browser, no key, completed through Warp's own `warp://` callback	From host documentation, not verified live
Google Antigravity	remote MCP server entry in the `mcpServers` config	browser, no key	From host documentation, not verified live
Devin Desktop (formerly Windsurf)	`npx` package entry in `~/.config/devin/mcp_config.json`, or the remote URL	API key with the `npx` package; browser sign-in from Devin Local not verified	Shipped (`npx` package); config path and sign-in from host documentation, not verified live
Cline, Zed and any MCP client	remote URL or `npx` package	browser, or API key with the `npx` package	Shipped

Claude Code

/plugin marketplace add mnemoverse/claude-plugin
/plugin install mnemoverse@mnemoverse

In a session, /plugin install first opens the plugin's details and asks for an install scope; choose Install for you (user scope) to get the memory in every project. Then run /mcp: a server that comes from a plugin is listed as plugin:mnemoverse:mnemoverse, not mnemoverse. Select it and start the sign-in from its menu. The browser opens once; sign in and grant the scopes. Updates arrive with /plugin marketplace update mnemoverse.

What you get: the 11 tools from the hosted server, three commands (/mnemoverse:remember, /mnemoverse:recall, /mnemoverse:memory-status) and two skills (agent-memory-discipline, setup).

If you sign in to Claude Code with a claude.ai account, a connector you add on claude.ai, for example with Connect to Claude, is also available in Claude Code, and /mcp shows it as coming from claude.ai. With that connector you do not need the plugin as well.

Source: plugin README and Claude Code plugin marketplaces, read 2026-09-20; Install and manage plugins, read 2026-09-27: "In a session, this command doesn't install right away: it opens the /plugin panel on that plugin's details so you can review it and choose a scope first", and MCP, read 2026-09-27: plugin servers are registered as "plugin:<plugin-name>:<server-name>". A live run on 2026-09-27 (Claude Code 2.1.280) installed the plugin at user scope; /mcp showed a connected mnemoverse server with the hosted tool list, and memory_stats, a write and a read of the written record passed. The same session already had a user-level server at the same URL, so the run does not prove the calls went through the plugin's entry. Without the plugin, the one-line alternative is on the Claude Code page. Use MCP servers from claude.ai, read 2026-09-29: "If you've logged into Claude Code with a claude.ai account, MCP servers you've added in claude.ai, known as connectors, are automatically available in Claude Code", and "Servers from claude.ai appear in the list with indicators showing they come from claude.ai."

Claude Desktop

Two paths.

Custom connector, no key. Connect to Claude opens the Add custom connector dialog on claude.ai with the name and URL filled in; review them, click Add, and sign in when the browser opens. The connector then works in Claude Desktop, on claude.ai and on mobile. By hand: Customize, then Connectors, then + and Add custom connector, paste https://mcp.mnemoverse.com/mcp, sign in when the browser opens. Free plans allow one custom connector. Details on the Remote MCP page.

Desktop bundle, API key. Download mnemoverse-memory.mcpb from the latest release of mcp-memory-server. In Claude Desktop open Settings, then Extensions, then Advanced settings, find the Extension Developer section, click Install Extension… and select the file. The bundle runs the local server as a node process launched by Claude Desktop and reads your mk_live_ key from the extension settings, so this path needs a key from console.mnemoverse.com.

Source: Getting started with local MCP servers on Claude Desktop and the mcp-memory-server README, read 2026-09-20; Get started with custom connectors using remote MCP, read 2026-09-27: "Navigate to Customize > Connectors." and "Click "+" then "Add custom connector."", and read 2026-09-29: "Free users are limited to one custom connector."; Directory connectors vs custom connectors, read 2026-09-29, for the Connect to Claude link: "link to the Add custom connector dialog with the name and URL prefilled"; When to use desktop and web connectors, read 2026-09-29: "Remote connectors work across all Claude surfaces.". The Connect to Claude link has not been run live.

Cursor

MCP needs a paid Cursor plan: Cursor's pricing lists "MCPs, skills, and hooks" from the Individual plan up, and not on Hobby.

Cursor loads two plugin formats from the local plugins folder: Agent Plugins (root plugin.json) and Cursor Plugins (.cursor-plugin/plugin.json). Both Mnemoverse repositories qualify; the Cursor one also ships a rule file.

git clone https://github.com/mnemoverse/cursor-plugin ~/.cursor/plugins/local/mnemoverse

Restart Cursor, or run Developer: Reload Window. To sign in, open Customize in the sidebar (Cursor Settings → Tools & MCPs in Cursor 3.21.16) and click Connect next to the Mnemoverse server; Cursor opens the browser sign-in. Both callbacks Cursor documents are on the sign-in allowlist: the desktop app's loopback http://localhost:8787/callback, and https://www.cursor.com/agents/mcp/oauth/callback, which Cursor on the web and Cursor Agents use.

What you get: the hosted server, the agent-memory-discipline rule and skill.

Keyless alternatives without cloning: the one-click Add to Cursor link, which puts the remote server entry { "mcpServers": { "mnemoverse": { "url": "https://mcp.mnemoverse.com/mcp" } } } in ~/.cursor/mcp.json (then click Connect next to mnemoverse in Customize), or the Mnemoverse Agent Memory extension on Open VSX, which adds the hosted server to editor windows and offers Add to Cursor (all windows) for the Agents Window. With an API key, the npx entry on the Cursor page.

On the web and in Cloud Agents, see Cursor on the web and Cloud Agents.

Cursor Marketplace: the plugin is not listed there yet. Per Cursor's documentation, marketplace plugins are submitted through the Cursor team and reviewed manually.

Source: Cursor plugins (section on local testing: "put either plugin format in ~/.cursor/plugins/local"), read 2026-09-20, and Cursor MCP (the fixed OAuth redirect URLs for the desktop app, the web and Cursor Agents), read 2026-09-22; read again 2026-09-27: Cursor MCP lists only "http://localhost:8787/callback" (desktop) and "https://www.cursor.com/agents/mcp/oauth/callback" (web and Cursor Agents) and says "Open Customize in the sidebar"; Pricing: the Individual plan lists "MCPs, skills, and hooks", Hobby does not. Local install steps: from host documentation, not verified live.

Cursor on the web and Cloud Agents

Cursor on the web and Cursor's Cloud Agents take MCP servers from cursor.com/agents, not from the desktop app. Open it, add a server through the MCP dropdown with the URL:

https://mcp.mnemoverse.com/mcp

and sign in in the browser when Cursor asks. The sign-in returns to https://www.cursor.com/agents/mcp/oauth/callback, which is on the Mnemoverse sign-in allowlist. Cursor's documentation does not say that ~/.cursor/mcp.json carries over to the web, so add the server there even if the desktop app already has it. MCP needs a paid Cursor plan, as for the desktop app.

Source: Cloud agents, read 2026-09-27: "Add and manage MCP servers through the MCP dropdown in cursor.com/agents." and "OAuth is supported for MCP servers that need it."; Cursor MCP, read 2026-09-27, which gives https://www.cursor.com/agents/mcp/oauth/callback as the redirect URL for the web and Cursor Agents. A live attempt on 2026-09-27 stopped at the plan: the page requires Pro for Cloud Agents. From host documentation, not verified live.

VS Code and Copilot Chat

Extension (recommended). Install Mnemoverse Agent Memory from the Marketplace (open it in VS Code), or from a terminal:

code --install-extension Mnemoverse.mnemoverse-vscode

Click Sign In, approve in the browser, done. Works in Copilot Chat Agent Mode (VS Code 1.102 or later). Full page: VS Code and Copilot Chat.

Agent Plugin from source. Agent plugins need VS Code 1.110 or later and are an Experimental feature. With the chat.plugins.enabled setting on, run Chat: Install Plugin From Source from the Command Palette and enter:

https://github.com/mnemoverse/claude-plugin

VS Code clones the repository, detects the Agent Plugins 1.0 $schema in plugin.json, loads skills/ and starts the server from mcp.json when the plugin is enabled. To browse it as a marketplace instead, add "chat.plugins.marketplaces": ["mnemoverse/claude-plugin"] to your settings and open the Extensions view with @agentPlugins in the search field.

What you get from the Agent Plugin: the hosted server and the two skills. VS Code does not load the plugin's commands in this format, because it reads Agent Plugins commands only from a com.github.copilot/commands folder.

Source: Agent plugins in VS Code (sections "Install a plugin from source", "Configure plugin marketplaces", "Plugin formats"), read 2026-09-20; what the Agent Plugin loads was checked in the VS Code source on 2026-09-22; VS Code 1.110 release notes, read 2026-09-27: "Agent plugins (Experimental)". Agent Plugin path: from host documentation, not verified live: in particular, how VS Code runs the browser sign-in for a plugin-bundled remote server has not been checked.

GitHub Copilot CLI

Copilot CLI installs a plugin from the root of a GitHub repository by OWNER/REPO:

copilot plugin install mnemoverse/claude-plugin

Or register the repository as a marketplace first, then install by name:

copilot plugin marketplace add mnemoverse/claude-plugin
copilot plugin install mnemoverse@mnemoverse

Inside a session the same commands are /plugin marketplace add mnemoverse/claude-plugin and /plugin install mnemoverse@mnemoverse. copilot plugin list shows what is installed; copilot plugin update mnemoverse updates it.

If /mcp shows the server as needs-auth, run /mcp auth with the server name it lists; the browser opens, and the server reconnects after sign-in.

What you get: the hosted server and the two skills. Copilot CLI does not load the plugin's commands in this format, because it reads Agent Plugins commands only from a com.github.copilot/commands folder.

Source: Copilot CLI plugin reference (table "Plugin specification for install command"; which files an Agent Plugins package loads) and Finding and installing plugins, read 2026-09-20 and again 2026-09-22, and the CLI command reference (section "OAuth re-authentication"), read 2026-09-22. From host documentation, not verified live: in particular, how Copilot CLI runs the browser sign-in for a plugin-bundled remote server has not been checked.

GitHub Copilot cloud agent

Copilot cloud agent (formerly Copilot coding agent) can turn on plugins from a repository's .github/copilot/settings.json, but GitHub's documentation says it does not currently support remote MCP servers that use OAuth. The hosted server signs in only through OAuth, so Mnemoverse memory is not available in the cloud agent, through the plugin or through the remote URL. Running the local package with an API key inside the cloud agent has not been tested.

Source: About plugins and Configure MCP servers ("Copilot cloud agent and Copilot code review do not currently support remote MCP servers that leverage OAuth for authentication and authorization"), read 2026-09-22. Not supported by the host.

Gemini CLI

Gemini CLI is no longer offered to unpaid-tier and Google One users; Google points them to Antigravity CLI instead.

gemini extensions install https://github.com/mnemoverse/gemini-extension

Gemini CLI does not open the browser by itself for this server: at startup it reports that mnemoverse requires authentication. Inside Gemini CLI run:

/mcp auth mnemoverse

The browser sign-in then runs on a localhost callback. /extensions inside Gemini CLI lists what is installed, /mcp shows the server state, gemini extensions update mnemoverse-memory updates it.

What you get: the hosted server plus a GEMINI.md with the recall-before-acting discipline.

Source: extension README, Gemini CLI extensions and the extensions command reference for update, read 2026-09-20; MCP servers (the /mcp auth command), read 2026-09-27; the Gemini CLI source at main 2fe7c2d, read 2026-09-27: "Only trigger automatic OAuth if explicitly enabled in config", otherwise "requires authentication using: /mcp auth"; the extension's server entry carries no oauth block. geminicli.com, read 2026-09-27: "Unpaid tier and Google One users: Gemini CLI was replaced by Antigravity CLI on June 18th, 2026."

Kimi Code

Kimi Code installs a plugin from a GitHub repository URL and reads kimi.plugin.json at the plugin root. Inside Kimi Code:

/plugins install https://github.com/mnemoverse/claude-plugin
/reload

Kimi installs the latest release of the repository (v1.0.0, which carries kimi.plugin.json). /plugins info mnemoverse shows the manifest, the remote server and the commands; /plugins mcp enable mnemoverse mnemoverse followed by /reload re-enables the server if it was switched off. To sign in, run:

/mcp-config login mnemoverse

The browser opens for the sign-in.

What you get: the hosted server, the three commands and the two skills.

Source: Kimi Code plugins (sections "Installing from GitHub", "Plugin Manifest", "MCP Servers in Plugins"), read 2026-09-20 and again 2026-09-27 (the example runs /reload after /plugins mcp enable), and Kimi Code MCP, read 2026-09-27: "When OAuth is needed, run /mcp-config login <server-name> to complete browser-based authorization." Install line from host documentation, not verified live.

ChatGPT and Codex

Codex CLI, plugin. Codex reads the Agent Plugins manifest at the root of mnemoverse/claude-plugin and accepts the repository's .claude-plugin/marketplace.json as a marketplace:

codex plugin marketplace add mnemoverse/claude-plugin
codex plugin add mnemoverse@mnemoverse
codex mcp login mnemoverse

codex mcp login mnemoverse opens the browser once; it finds servers that come from plugins as well as servers in the Codex configuration. In the terminal UI the install is /plugins, then the mnemoverse marketplace tab. OpenAI's documentation says some plugins ask for sign-in during install and others on first use; if no browser opened, run codex mcp login mnemoverse. Start a new session afterwards.

What you get: the hosted server and the two skills. Codex does not load plugin commands for an Agent Plugins package, so the three commands are not available there.

Codex CLI, MCP entry only. Add the hosted server as a remote MCP server and sign in:

codex mcp add mnemoverse --url https://mcp.mnemoverse.com/mcp
codex mcp login mnemoverse

Codex picks the OAuth client registration method itself: CIMD when the authorization server advertises it, otherwise Dynamic Client Registration, which the Mnemoverse sign-in supports for loopback callbacks. To force one method for a single login: codex mcp login mnemoverse --oauth-client-registration dcr.

Codex IDE extension. The extension does not support plugins, per OpenAI's documentation, which sends plugin installs to the Codex CLI or the ChatGPT desktop app. It reads MCP servers from the same ~/.codex/config.toml as the CLI, so a server added with the CLI commands above also appears there. In the extension itself: open the gear menu, then MCP servers, then Add server, enter the name mnemoverse, choose Streamable HTTP, enter https://mcp.mnemoverse.com/mcp, save, select Restart extension, then Authenticate. This route carries the MCP server only, without the skills.

ChatGPT. Turn on developer mode and create a developer-mode app with the same URL; where the toggle is on each plan, and which plans can save, are on the ChatGPT page. On a Pro account the documented toggle was not visible on the date in the Source line; the ChatGPT page says what was seen instead.

Plugin directory. Only a listing in the OpenAI plugin directory, which ChatGPT and Codex share, goes through OpenAI's submission review; the Codex commands above install from GitHub without one.

Source: Package your plugin (sections "Add a marketplace from the CLI", "How local marketplaces work", "Plugin structure"), Plugins (the note that plugins are not available in the IDE extension; read again 2026-09-27: "Some plugins ask you to authenticate during install. Others wait until the first time you use them.") and Codex MCP (section "Configure in the IDE extension"), read 2026-09-22; what the plugin route loads and how codex mcp login finds plugin servers was checked in the Codex source at release rust-v0.155.1. Codex CLI and Codex IDE extension: from host documentation, not verified live. ChatGPT: from host documentation, not verified live; an existing Mnemoverse connector on ChatGPT Pro passed memory_stats, a write and a read on 2026-09-27; sign-in and developer-mode app creation were not run. On that account, Settings → Security and login showed no Developer mode toggle, and chatgpt.com/plugins opened the Plugins settings.

Kiro

Working path. Add the server to Kiro's own MCP configuration, ~/.kiro/settings/mcp.json, and name the memory scopes in oauthScopes:

json

{
  "mcpServers": {
    "mnemoverse": {
      "url": "https://mcp.mnemoverse.com/mcp",
      "oauthScopes": ["openid", "profile", "email", "memory:read", "memory:write", "offline_access"]
    }
  }
}

The oauthScopes line is required: when an entry names no scopes, Kiro asks only for openid, email, profile and offline_access, the Mnemoverse sign-in grants only the scopes a client asks for, and without memory:read and memory:write every memory tool is refused.

The power, for the skills only. Kiro powers follow the Agent Plugins specification, so the plugin repository also imports as a power:

Open the Powers panel and choose Add Custom Power.
Select Import power from GitHub.
Enter https://github.com/mnemoverse/claude-plugin and click Install.

Kiro reads plugin.json, the skills/ folder and mcp.json. Import power from a folder does the same from a local clone. A power activates when a conversation matches its keywords (for this plugin: memory, agent-memory, persistent-memory, mcp, context), and only then does Kiro load its MCP tools and skills.

The power cannot carry the memory scopes: its mcp.json has no field for them, and Kiro manages a power's server itself, so it does not appear in ~/.kiro/settings/mcp.json and the oauthScopes entry above does not change it. The power's server therefore signs in with Kiro's default scopes and cannot use memory. Install the power only if you want its skills; its server is then listed next to the mcp.json entry.

Source: Install powers, Powers (keyword activation) and MCP configuration (default scopes and oauthScopes), read 2026-09-22; Install powers, read again 2026-09-27: for the Agent Plugins format, "MCP servers are managed internally by Kiro and are not added to your user-level ~/.kiro/settings/mcp.json file", and MCP configuration, read again 2026-09-27: "When neither is specified, Kiro requests a default set of scopes (openid, email, profile, offline_access)". From host documentation, not verified live: neither the mcp.json entry nor the power has been signed in to from Kiro.

Hermes Agent

Hermes installs Agent Plugins 1.0.0 packages through its normal plugin workflow; portable packages are disabled until enabled:

hermes plugins install mnemoverse/claude-plugin --no-enable
hermes plugins list
hermes plugins enable <name printed by hermes plugins list>

This loads the two skills under a namespaced name; skills_list shows the full name. It does not sign in to the server: the plugin importer never writes auth: oauth onto the entry it converts, and Hermes' dashboard refuses outright to start OAuth for a plugin-provided server, answering HTTP 409 rather than attempting a connection.

Working path. Hermes also ships hermes mcp add mnemoverse --url https://mcp.mnemoverse.com/mcp --auth oauth, but it is discovery-first: it probes the server right away and prompts interactively, and in a local run the saved entry did not carry auth: oauth at all. Prefer a native entry in ~/.hermes/config.yaml instead, under mcp_servers, with OAuth:

yaml

mcp_servers:
  mnemoverse:
    url: "https://mcp.mnemoverse.com/mcp"
    auth: oauth

Then run hermes mcp login mnemoverse, or let the first connection start the sign-in: Hermes opens the browser itself (Python's webbrowser.open()) and waits on a loopback callback, http://127.0.0.1:<port>/callback (port 27890 in a local run), which the Mnemoverse sign-in accepts on any port. hermes mcp login --flow device is offered too, but the Mnemoverse server has no device-authorization endpoint, so that flow fails cleanly rather than hanging. Check the result with hermes mcp test mnemoverse or hermes mcp list.

Gotcha: name this entry mnemoverse, the same name the plugin uses. Hermes resolves a name clash in favor of the native entry ("native config wins"), so the native, OAuth-capable copy shadows the plugin's non-signing-in one instead of running alongside it as a confusing second server.

Source: Build a Hermes Plugin, section "Portable Agent Plugins v1 packages" and MCP (website/docs/user-guide/features/mcp.md, lines 120-136 and 345-366), read 2026-09-22; the plugin importer's missing auth: oauth, the dashboard's 409 refusal, the native-wins precedence, the rule that a plugin server keeps exactly the name its mcp.json gives it, and the OAuth loopback callback are from the Hermes source (hermes_cli/web_routers/mcp.py:271-272, tools/mcp_tool_config.py:347-359, hermes_cli/plugins_manifest.py:72-80, tools/mcp_oauth.py:1085), read 2026-09-23; hermes mcp add being discovery-first and dropping the auth field, the browser opening through Python's webbrowser.open(), the ephemeral loopback port, the --flow device failure with no device-authorization endpoint, and the mcp test/mcp list checks were confirmed in a local run on Windows, 2026-09-23, up to the sign-in URL; sign-in not completed there. Sign-in and memory_stats verified live 2026-09-25 through Hermes' own runtime, on macOS, against a test account; a full model chat through Hermes was not run.

OpenClaw

OpenClaw installs Agent Plugins, Claude, Codex and Cursor packages as bundles, and when a package carries both a client-specific marker and a root plugin.json, the client-specific format wins. This repository carries .claude-plugin/, so OpenClaw loads it as a Claude bundle whichever route installs it:

openclaw plugins marketplace list https://github.com/mnemoverse/claude-plugin
openclaw plugins install mnemoverse --marketplace https://github.com/mnemoverse/claude-plugin
openclaw plugins inspect mnemoverse

As a Claude bundle it reads .mcp.json, the skills/ folder, and commands/ as additional skills. Installation applies to the running Gateway; mapped features are available in the next session.

The bundle does not sign in to the server, and cannot be made to: OpenClaw starts OAuth only for a server whose own config entry carries auth: "oauth", and the plugin importer accepts only type, url and headers on a bundled entry, dropping any other key it finds, so a plugin-provided server can never declare auth: "oauth" and connects without a token, getting 401 with no sign-in attempt.

Working path. Add the hosted server a second time, outside the plugin, as a native OpenClaw MCP server, then sign in:

openclaw mcp add mnemoverse --transport streamable-http --url https://mcp.mnemoverse.com/mcp --auth oauth
openclaw mcp login mnemoverse

mcp add only saves the entry to ~/.openclaw/openclaw.json and makes no network call. Sign-in starts with mcp login: it registers a public OAuth client dynamically and prints the authorization URL rather than opening a browser, so open it yourself. It waits on a loopback callback, http://127.0.0.1:8989/oauth/callback, which the Mnemoverse sign-in accepts on any port. Check progress with openclaw mcp status --verbose (shows oauth: pending-authorization before you open the URL) or, once signed in, openclaw mcp probe mnemoverse, which lists the tools. The plugin's own copy still loads for the skills; this native entry is what carries the session.

Source: Plugin bundles (section "Detection precedence"), read 2026-09-22; the OAuth condition, the plugin importer's allowed keys, the mcp add flags and the OAuth callback are from the OpenClaw source (src/agents/mcp-transport.ts:196-205, src/plugins/bundle-mcp.ts:70-74,314-331, src/cli/mcp-cli.ts:1029-1039, src/agents/mcp-oauth-store.mutations.ts:4), read 2026-09-23; mcp add saving with no network call, mcp login printing the authorization URL instead of opening a browser, and the status check were confirmed in a local run on Windows, 2026-09-23, up to the sign-in URL; sign-in not completed there. Sign-in and memory_stats verified live 2026-09-25 through OpenClaw's own runtime, on macOS, against a test account; the same session confirmed that openclaw mcp probe is the command that lists a server's tools. A full model chat through OpenClaw was not run.

Grok

Grok Build (the grok terminal agent) installs a plugin straight from a GitHub repository:

grok plugin install mnemoverse/claude-plugin --trust

Without --trust, Grok shows the source, warns that installing activates the plugin's hooks, MCP servers and skills, and stops. To pick up the plugin, start a new session or press r in the Plugins tab. The first memory call opens the browser sign-in; to start it by hand, open /mcps, select the server and press i. grok plugin list shows what is installed, and grok plugin update mnemoverse updates it.

Grok reads plugin.json at the repository root, loads the skills/ and commands/ folders, and takes the server from .mcp.json, because the root manifest names no MCP servers. The sign-in runs on a loopback callback, which the Mnemoverse sign-in accepts.

What you get: the hosted server, the three commands and the two skills.

Grok Bot documents installing packaged skills and connectors from its Marketplace (sidebar, then Your plugins, then Manage plugins and skills); it does not document installing a plugin from a Git repository. For MCP servers it has no connector list of its own: it runs on a hosted computer and uses the connectors your Cursor team permits, which a team admin manages on the Plugins page of the Cursor dashboard. OAuth tokens stay on Cursor's connector backend. Neither Grok's nor Cursor's documentation gives steps for adding a custom server by URL for Grok Bot, so this page has none.

Source: Plugins (sections "Install and use a plugin", "Manage plugins") in the Grok Build repository, MCP servers and Skills and routines, read 2026-09-22; Grok Bot for teams and enterprises, read 2026-09-27: "There is no separate Grok Bot connector list, and connectors appear as plugins in the app" and "OAuth tokens stay on Cursor's connector backend, and Bots invoke tools without receiving them"; which files Grok reads, and its sign-in callback, were checked in the Grok Build source. From host documentation, not verified live.

NanoClaw

NanoClaw templates use the Agent Plugins 1.0.0 directory format and are stamped only from the local templates/ directory, so the repository is cloned there first (the clone step is not in NanoClaw's documentation and has not been run):

git clone https://github.com/mnemoverse/claude-plugin templates/mnemoverse
ncl groups create --template mnemoverse --name "Mnemoverse memory"

The display name defaults to the folder name unless --name sets it, as above. Wire the group to a channel afterwards with /manage-channels or ncl wirings create.

NanoClaw reads plugin.json, the skills and the server entry in mcp.json, but the template does not sign in to the server. NanoClaw has no OAuth client of its own: it delegates authentication to Anthropic's Agent SDK and runs headless inside a container. A plugin template may ship only the literal string "placeholder" for any secret-shaped header, never a real value, so the bundled server entry can never carry a working credential.

What the host supports, not live end to end. NanoClaw does accept a remote streamable-http server with a headers map, added directly by the operator rather than through the plugin template:

ncl groups config add-mcp-server --id <group-id> --name mnemoverse-key --url https://mcp.mnemoverse.com/mcp --headers '{"Authorization":"Bearer <key>"}'
ncl groups restart

<group-id> comes from ncl groups list. The name must not be mnemoverse: a server name owned by the plugin is refused with "owned by plugin", so the operator's entry needs its own name. This is the shape NanoClaw expects on its side, and it is not a working path until the endpoint accepts a key: the Mnemoverse remote endpoint does not accept an API key as a bearer token yet and answers malformed_token. Bearer-key support on the endpoint is planned, behind a flag, and not live; we are not giving a date. Until it ships, this page has no route from NanoClaw to Mnemoverse memory.

Source: Agent Templates (docs/templates.md:396-403, secret-shaped headers), read 2026-09-22; the absence of an MCP OAuth client, the headless container model, streamable-http/headers support, and the add-mcp-server contract with its refusal of plugin-owned names are from the NanoClaw source (src/templates/mcp.ts:21-22, src/cli/resources/groups.ts, the config add-mcp-server handler), read 2026-09-23. Needs a live test on the host side; blocked on the Mnemoverse endpoint, which does not accept a bearer API key yet (planned, no date).

OpenHands

Working path: a manual OAuth server entry, without the plugin. In the app (Agent Canvas, image ghcr.io/openhands/agent-canvas), open Customize > MCP Servers (the page at /mcp) and add a server: Server Type SHTTP, URL https://mcp.mnemoverse.com/mcp, Authentication OAuth, OAuth client auth auto, the client id, secret and scopes left blank so dynamic registration handles them. Test Connection or Add Server is where the browser sign-in starts.

The same shape works in the SDK's mcp_config; the first call then opens the browser sign-in on a localhost callback, which the Mnemoverse sign-in accepts:

python

mcp_config = {
    "mcpServers": {
        "mnemoverse-oauth": {
            "url": "https://mcp.mnemoverse.com/mcp",
            "auth": {"strategy": "oauth2"}
        }
    }
}

OpenHands Cloud (app.all-hands.dev). The same manual entry works there: open Customize → MCP Servers, add a server with Server Type SHTTP, URL https://mcp.mnemoverse.com/mcp and Authentication OAuth, and enter memory:read memory:write offline_access in the scopes field. The Mnemoverse sign-in grants only the scopes a client asks for, so without the memory scopes the sign-in succeeds but every memory tool is refused. Test Connection starts the browser sign-in. OpenHands Cloud returns to https://app.all-hands.dev/api/v1/mcp/oauth/callback, which is on the Mnemoverse sign-in allowlist. Self-hosted OpenHands on its own domain uses its own callback host and is not covered.

Why not the plugin. OpenHands checks for the Agent Plugins format first, so the plugin repository does load from GitHub (openhands --plugin github:mnemoverse/claude-plugin, [plugins] sources in ~/.openhands/config.toml, or PluginSource(source="github:mnemoverse/claude-plugin") in the SDK). It loads the two skills, but its server does not sign in: OpenHands starts OAuth only for a server entry whose auth carries strategy="oauth2", and the entry converted from the plugin's mcp.json has no auth field at all, so the server answers 401. The plugin's server uses the same URL as the manual entry, and OpenHands documents no way to turn off a plugin's server while keeping its skills. With both present they clash: the MCP form refuses a second remote server with a URL that is already configured, and on a name clash the plugin's entry wins on every load and overwrites the manual one. So use the manual entry above on its own; the plugin's skills are not available in OpenHands through this recipe.

Source: Agent plugins, Plugins (section "Using Plugins") and MCP (section "MCP with OAuth"), read 2026-09-22; the auth.strategy="oauth2" requirement is from the software-agent-sdk source (openhands-sdk/openhands/sdk/mcp/utils.py:182-188); the MCP page route and the form's fields are from the OpenHands source at 1.22.0 (src/routes/extensions-hub.tsx, src/components/features/settings/mcp-settings/mcp-server-form.tsx, src/types/mcp-auth.ts), read 2026-09-23; the plugin-wins name-clash behavior is from the same repository (openhands-sdk/openhands/sdk/plugin/plugin.py:173-202, add_mcp_config_to), read 2026-09-23; MCP settings, read 2026-09-27: "Customize > MCP Servers"; the duplicate-URL check is in the OpenHands source at main 47a1080 (validateUrlUniqueness: "ensure URL is unique across both types"), read 2026-09-27; Plugins, read again 2026-09-27, documents no way to disable a plugin's MCP server while keeping its skills. OpenHands Cloud: MCP settings, read 2026-09-27: on OpenHands Cloud the system "keeps the OAuth credential and its token state instead of flattening it into a request header"; the callback is from the OpenHands enterprise source at 0ff9566 (openhands/app_server/mcp/mcp_oauth_router.py: _CALLBACK_PATH = '/api/v1/mcp/oauth/callback'; server/constants.py: HOST = os.getenv('WEB_HOST', 'app.all-hands.dev')), read 2026-09-27; a live attempt on OpenHands Cloud on 2026-09-27 stopped at its own sign-in, which it requires before the MCP settings open. From host documentation, not verified live.

Dust

Dust adds remote MCP servers per workspace; an admin does it. Open Spaces → Tools, choose Add Tool, then Add MCP Server, and enter https://mcp.mnemoverse.com/mcp. Dust discovers that the server uses OAuth and registers itself; the first use opens the Mnemoverse sign-in in the browser. Dust returns to https://dust.tt/oauth/mcp/finalize (US), https://app.dust.tt/oauth/mcp/finalize (global) or https://eu.dust.tt/oauth/mcp/finalize (EU); all three are on the Mnemoverse sign-in allowlist. Self-hosted Dust on its own domain is not covered.

Source: Adding an MCP Server, read 2026-10-06: "navigate to Spaces > Tools … an Add Tool button … an Add MCP Server button", and the callback table under "OAuth (with Dynamic Client Registration)". From host documentation, not verified live.

Amazon Quick

In the Amazon Quick console choose Connectors, the Create for your team tab, then Model Context Protocol (MCP). Enter a name, https://mcp.mnemoverse.com/mcp as the MCP server endpoint, Public network for both connection types, and user authentication (OAuth). Mnemoverse supports Dynamic Client Registration, so Quick registers itself and no client ID or secret is needed. Each user then signs in with their own Mnemoverse account in the browser.

Quick returns to https://<region>.quicksight.aws.amazon.com/sn/oauthcallback. The allowlist covers the regions where Quick runs agents: us-east-1, us-west-2, ap-southeast-2, ap-northeast-1, eu-central-1, eu-west-1 and eu-west-2.

Source: Model Context Protocol (MCP) integration, read 2026-10-06 ("choose Connectors. Choose the Create for your team tab. Find and choose Model Context Protocol (MCP)"; "If the authorization server supports Dynamic Client Registration (DCR), then Amazon Quick automatically registers itself"); the callback per region is from the AWS Machine Learning blog post "Integrate external tools with Amazon Quick Agents using MCP" (2026-02-20) and the regions table. From host documentation, not verified live.

Langdock

In Langdock add an MCP integration: enter https://mcp.mnemoverse.com/mcp as the URL and choose OAuth 2.0 (Dynamic Client Registration) as the authentication method. Langdock discovers the OAuth metadata and scopes, registers itself, and the browser sign-in follows. Langdock's cloud returns to https://app.langdock.com/api/integrations/<integration-id>/callback, which is on the Mnemoverse sign-in allowlist. Dedicated Langdock deployments use their own host and are not covered.

Source: Model Context Protocol (MCP) ("Enter the endpoint URL of your MCP server", "OAuth 2.0 (Dynamic Client Registration)") and Bring your own OAuth (the callback format), read 2026-10-06. From host documentation, not verified live.

Perplexity

Perplexity adds remote MCP servers as custom remote connectors, on the Pro, Max and Enterprise plans. In an Enterprise organization, members can add their own only if an admin allows it.

Open Computer → Customize → Connectors (perplexity.ai/computer/connectors). Perplexity's help article calls this page Account settings → Connectors; on the Pro account we tested, the connectors page was at the Computer route instead.
Click + Custom connector, and in the pop-up select Remote.
Fill in the MCP Server URL https://mcp.mnemoverse.com/mcp, Authentication OAuth, Transport Streamable HTTP, and leave Client ID and Client Secret empty (Mnemoverse supports dynamic client registration). Click Add.
Click the connector card to start the sign-in; approve the scopes on auth.mnemoverse.com.

Perplexity returns to https://www.perplexity.ai/rest/connections/oauth_callback (Enterprise subdomain: https://enterprise.perplexity.ai/rest/connections/oauth_callback); both are on the Mnemoverse sign-in allowlist. A third-party report says Perplexity may refuse a dynamic registration that returns no client_secret; the Mnemoverse sign-in registers public clients without one, so only a live run will show whether Perplexity accepts it.

Source: Adding Custom Remote Connectors, 2026-09-27: a direct fetch returned 403, so the article was read through the r.jina.ai reader: "For your account: Account settings → Connectors", "Click + Custom connector in the top-right corner.", "In the modal pop-up, select Remote.", "Transport — Choose between Streamable HTTP or SSE", "Click the connector card to start the authentication flow and enable it.", "Organization members can add custom remote connectors if admins enable them for the organization", and "The redirect URL to register is: https://www.perplexity.ai/rest/connections/oauth_callback". The plans are from Perplexity's changelog of 13 March 2026, read 2026-09-27: "Pro, Max, and Enterprise subscribers can now connect Perplexity to any external tool or data source using the Model Context Protocol (MCP)." The client_secret report: Perplexity community forum, posted 2026-05-18, read 2026-09-27: "[API_CLIENTS_ERROR] Dynamic client registration did not return a client_secret" (a later reply says it started working again; no staff answer). A live attempt on 2026-09-27, on a Pro account, reached the connectors page at /computer/connectors (Computer → Customize → Connectors), but the + Custom connector form did not open in two attempts, so steps 2–4 and the sign-in have not been run. From host documentation, not verified live.

Mistral Vibe

Mistral Vibe (the vibe terminal agent) adds a hosted OAuth server from inside a session. Name the memory scopes, because the Mnemoverse sign-in grants only the scopes a client asks for:

/mcp add https://mcp.mnemoverse.com/mcp --name mnemoverse --scope memory:read --scope memory:write --scope offline_access

/mcp add starts the browser sign-in by default; the callback is a loopback address, which the Mnemoverse sign-in accepts on any port. If the sign-in did not complete, run:

/mcp login mnemoverse

/mcp status shows the result.

Source: the Mistral Vibe README at main 7c19608, read 2026-09-27: "/mcp add is OAuth-only. It writes auth.type = "oauth" with optional scopes and starts login by default.", and the changelog, read 2026-09-27: 2.17.0 added "/mcp login, /mcp logout, and /mcp status commands to authenticate OAuth-backed MCP servers", 2.18.1 added "/mcp add slash command for adding OAuth MCP servers", and 2.25.5 mentions "the loopback callback port". Mistral's own MCP servers page, read 2026-09-27, still says "the CLI does not yet support MCP servers that require OAuth authentication"; the README and changelog are newer. From host documentation, not verified live.

Make

Make is a no-code/low-code automation platform; its MCP Client app lets a Make scenario call any remote MCP server as a tool.

Working path. In a scenario, add an MCP Client module and click Create a connection. Give the connection a name, and in the MCP Server field choose + New MCP Server instead of a listed server. Enter the URL, leave the API key empty, and click Save:

https://mcp.mnemoverse.com/mcp

Make's own docs don't name a separate transport field for a custom connection — the URL alone drives it, over Streamable HTTP on Mnemoverse's side. If the connection screen asks you to register a redirect URI for OAuth (Make's docs word this as "some MCP servers may require you to set up a redirect URI for OAuth connections, if requested"), nothing needs adding on your end: https://www.make.com/oauth/cb/mcp is already on Mnemoverse's OAuth callback allowlist. Sign-in is the standard flow from there — Make opens the browser consent screen on console.mnemoverse.com; approve the scopes and Make stores the token on the connection.

To call a memory tool directly, use the Call a tool module with that connection: for example tool memory_stats with no arguments, or memory_read with a query argument. The Execute an action with AI module lets a model choose the tools instead.

Source: MCP Client app, read 2026-09-24: "some mcp servers may require you to set up a redirect uri for oauth connections if requested, add the following redirect uri in your mcp server settings https://www.make.com/oauth/cb/mcp."; read again 2026-09-27: "click create a connection", "select one of the verified remote mcp servers, or click + new mcp server", "click save", "if prompted, authenticate your account and confirm access", and the modules Call a tool and Execute an action with AI. From host documentation, not verified live.

Devin (hosted)

Devin is Cognition's AI software engineer. "Hosted" means app.devin.ai, the shared SaaS deployment — dedicated and custom-domain Devin deployments use a different API origin and are not covered by this recipe.

Working path. Open Customize → MCPs, choose Add MCP, then Add custom MCP, and fill in:

Field	Value
Server Name	`mnemoverse`
Server URL	`https://mcp.mnemoverse.com/mcp`
Transport Type	HTTP (Mnemoverse's endpoint is Streamable HTTP; Devin's own docs offer SSE or HTTP and recommend HTTP for new integrations)
Authentication Method	OAuth
Access	Personal (each member signs in with their own account) or Organization (all members share one connection; Devin's docs recommend a service account for it)
OAuth Credentials	leave blank — Mnemoverse supports Dynamic Client Registration, so no pre-registered Client ID/secret is needed

Click Save, then use Connect next to the server in Customize → MCPs. Sign-in opens the browser consent screen on console.mnemoverse.com; approve the scopes and Devin stores the token for the access chosen above.

Source: Model Context Protocol, read 2026-09-24: "On app.devin.ai it is https://api.devin.ai/mcp/oauth/callback; dedicated and custom-domain deployments use a different API origin."; read again 2026-09-27: "Navigate to Customize > MCPs", "Open Add MCP and choose Add custom MCP", "Access (OAuth only): Choose who uses the authenticated connection", and "For OAuth: Save the configuration, then use Connect in Customize → MCPs to complete authorization." From host documentation, not verified live.

Replit connectors

Replit's browser IDE lets Replit Agent call external services through connectors; a custom MCP server is one connector type, separate from Replit's custom API connectors.

Working path. Open replit.com/integrations, find MCP Servers for Replit Agent, and click + Add MCP server. Give it a recognizable name (mnemoverse) and paste the HTTPS endpoint:

https://mcp.mnemoverse.com/mcp

Replit's docs don't expose a separate transport field for a pasted URL. Leave Advanced settings (custom headers) empty — Mnemoverse's connector uses OAuth, not a header credential. Click Test & save: Replit connects and walks you through the OAuth sign-in, which opens the browser consent screen on console.mnemoverse.com; approve the scopes. Replit's MCP documentation does not name the OAuth callback Replit uses; the Mnemoverse sign-in allowlist accepts replit.com.

Source: Connect via MCP, read 2026-09-24: "Paste the MCP server's HTTPS endpoint. Open Advanced settings to add custom headers (e.g. X-API-Key) if the server needs authentication," and "Click Test & save. Replit attempts to connect and walks you through any OAuth flow the server requires."; read again 2026-09-27: "Provide a recognizable name — Agent uses it to reference the server in chat logs." The page names no callback URL. From host documentation, not verified live.

Warp

Warp is an AI-native terminal with its own desktop MCP client, separate from its cloud agents (Oz).

Working path. In the desktop app, open Settings > Agents > MCP servers (or Open MCP Servers from the Command Palette) and add a remote server by URL. The JSON is keyed by the server name:

json

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

Warp's docs list Streamable HTTP among the supported protocols. Sign-in is Warp's "OAuth login (one-click installation)": it opens the browser consent screen on console.mnemoverse.com as usual, but the desktop app completes the flow through its own warp://mcp/oauth2callback URL scheme (Warp Preview: warppreview://mcp/oauth2callback) rather than a loopback HTTP port — Warp registers that callback itself, so there is nothing to configure.

Source: Model Context Protocol (MCP), read 2026-09-24: "OAuth login (one-click installation): simplifies configuration by handling authentication through your browser."; read again 2026-09-27: "Settings > Agents > MCP servers", "Warp supports a variety of connection protocols, including Streamable HTTP and SSE, along with custom headers and environment variables.", and the example { "Figma": { "url": "https://mcp.figma.com/mcp" } }. Warp's own docs pages (also checked: MCP Servers for cloud agents, MCP Servers reference) do not name the warp:// callback scheme; that detail comes instead from Warp's own open-source client and is corroborated by a third-party bug report, warpdotdev/warp#8446, read 2026-09-24: "warp://mcp/oauth2callback?server_id=...". From host documentation, not verified live.

Google Antigravity

Antigravity is Google's agentic IDE; its MCP configuration is a settings file, not a UI form.

Working path. In the agent side panel, click … at the top, select MCP Servers, then Manage MCP Servers, then View raw config. This opens ~/.gemini/config/mcp_config.json (a workspace can have its own .agents/mcp_config.json). Add a remote entry to the mcpServers object; the field for a remote connection is serverUrl, not command:

json

{
  "mcpServers": {
    "mnemoverse": {
      "serverUrl": "https://mcp.mnemoverse.com/mcp"
    }
  }
}

No authProviderType or manual client credentials are needed: Mnemoverse supports OAuth Dynamic Client Registration, which Antigravity's own docs say it handles automatically, and Antigravity's OAuth client is itself Google-hosted (antigravity.google) rather than something you register yourself. Sign-in opens the browser consent screen on console.mnemoverse.com; approve the scopes and the browser returns to https://antigravity.google/oauth-callback.

Source: Antigravity's OAuth client metadata, read 2026-09-24: "redirect_uris": ["https://antigravity.google/oauth-callback"], and MCP, read 2026-09-24: "ensure the following is registered as a redirect URI in your OAuth provider: https://antigravity.google/oauth-callback," and "Antigravity can automatically handle OAuth for servers that support dynamic client registration (DCR). For these servers, no additional configuration is needed."; read again 2026-09-27: Manage MCP Servers, View raw config, and the global file ~/.gemini/config/mcp_config.json. From host documentation, not verified live.

Any other MCP client

Cline, Zed, JetBrains and any client that speaks MCP (Devin Desktop, formerly Windsurf, has its own page):

Can complete a browser sign-in (loopback callback or an allowlisted host): add the remote server https://mcp.mnemoverse.com/mcp. Which callbacks are accepted is listed on the Remote MCP page.
Cannot: run the local package with an API key; the remote URL does not take a key. Ready config blocks for Claude Desktop, Cursor, VS Code and Devin Desktop are in the Quick Setup; any other client takes the same command, args and env under the key it uses for MCP servers (Zed calls it context_servers):

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"
      }
    }
  }
}

Verify on any host

Ask: Remember that this project uses pnpm, not npm.
Start a new session, in the same tool or in another one connected to the same account, and ask: Which package manager does this project use?

The answer should come from memory. memory_stats (or /mnemoverse:memory-status where the plugin commands exist) shows the count.

Integrations: every published form in one list, with versions
Quick Setup: detect your environment, configs, verify step
Remote MCP Server: how the sign-in works, which clients can sign in
MCP Server: the local npm package and its tools
Make Your AI Agent Actually Use Persistent Memory: the memory rules and the setup_memory prompt

Editors

Benchmarks

Install by host

Summary

Claude Code

Claude Desktop

Cursor

Cursor on the web and Cloud Agents

VS Code and Copilot Chat

GitHub Copilot CLI

GitHub Copilot cloud agent

Gemini CLI

Kimi Code

ChatGPT and Codex

Kiro

Hermes Agent

OpenClaw

Grok

NanoClaw

OpenHands

Dust

Amazon Quick

Langdock

Perplexity

Mistral Vibe

Make

Devin (hosted)

Replit connectors

Warp

Google Antigravity

Any other MCP client

Verify on any host

Install by host ​

Summary ​

Claude Code ​

Claude Desktop ​

Cursor ​

Cursor on the web and Cloud Agents ​

VS Code and Copilot Chat ​

GitHub Copilot CLI ​

GitHub Copilot cloud agent ​

Gemini CLI ​

Kimi Code ​

ChatGPT and Codex ​

Kiro ​

Hermes Agent ​

OpenClaw ​

Grok ​

NanoClaw ​

OpenHands ​

Dust ​

Amazon Quick ​

Langdock ​

Perplexity ​

Mistral Vibe ​

Make ​

Devin (hosted) ​

Replit connectors ​

Warp ​

Google Antigravity ​

Any other MCP client ​

Verify on any host ​

Related ​

Install by host

Summary

Claude Code

Claude Desktop

Cursor

Cursor on the web and Cloud Agents

VS Code and Copilot Chat

GitHub Copilot CLI

GitHub Copilot cloud agent

Gemini CLI

Kimi Code

ChatGPT and Codex

Kiro

Hermes Agent

OpenClaw

Grok

NanoClaw

OpenHands

Dust

Amazon Quick

Langdock

Perplexity

Mistral Vibe

Make

Devin (hosted)

Replit connectors

Warp

Google Antigravity

Any other MCP client

Verify on any host

Related