Install by host

Mnemoverse keeps memories across conversations and connected apps. Sign in to the same Mnemoverse account in each app to share your memories.

Choose your app

Start with the app you are using. Each guide puts its recommended route first:

Your app	Easiest starting point
ChatGPT	Install the published Mnemoverse Memory plugin, then sign in in your browser.
Claude Desktop, web or mobile	Open Connect to Claude, confirm the connector, then sign in in your browser.
Claude Code	Add the hosted server with one command and authenticate in the browser.
Cursor	Use Add to Cursor, then Connect and browser sign-in.
VS Code	Install the Mnemoverse Agent Memory extension and follow its sign-in steps.
Codex CLI or IDE	Add the hosted MCP server and sign in in your browser.
Devin Desktop	Follow the local MCP setup with an API key stored in private client configuration.
Your own app, script or backend	Use the REST API or SDK with a private API key.

Connect only one route per app, then verify access and any requested save. If your app is not here, find it in the full host table. Installation, sign-in and a successful memory call are separate steps.

Package and compatibility reference

The sections below describe optional packages, host-specific support and manual alternatives. You do not need to compare them before following your app's guide.

There are three ways a host gets the memory:

1. 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.
2. 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.
3. 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). A client that cannot complete the sign-in but can send a fixed header can also use the remote URL with an API key, sent as Authorization: Bearer mk_live_YOUR_KEY; the host sections below say when they use it. The sign-in and the local package 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) and seven skills. 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 seven skills, from the plugin's skills/ folder:

• agent-memory-discipline: the standing rules for when to recall and what is worth saving. It is CC0, names no vendor and works with any memory backend.
• setup: connecting the server and fixing a sign-in that failed.
• memory-search: search memory before answering, then rate which recalled memories helped.
• memory-save: save one decision, preference, correction or lesson as a self-contained fact, never a secret.
• memory-catch-up: list what was added since a given time, in personal memory or in a shared room (beta).
• memory-onboard: seed memory with a project's conventions and decisions from its README, CLAUDE.md and AGENTS.md.
• mnemoverse-docs: for a developer adding Mnemoverse memory to their own app or agent; it picks the form and points to the docs page, and needs no memory tools.

The plugin README describes them too. The four memory-* skills check for the memory tools first; when the tools are missing they say so and point to setup or this page. The setup skill's instructions are written for Claude Code, with one section for Hermes Agent, so on any other host follow that host's section on this page instead.

The last five skills arrived in plugin version 1.0.3 on 2026-10-30. An install made before then has only agent-memory-discipline and setup, and gets the other five only after the plugin is updated on that host; the host sections give the update command where the host documents one. Kimi Code installs the newest GitHub release, not the default branch, so what it gets is in its section.

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. Sign-in verified by replay means Mnemoverse sent that host's own sign-in requests, taken from its source at the version named, to the production server, completed the sign-in and made memory calls, without running the host application itself. 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	hosted MCP entry (recommended); plugin from mnemoverse/claude-plugin for commands and skills	browser, no key	Shipped
Claude Desktop	custom connector (Connect to Claude, recommended); .mcpb bundle as a local alternative	connector: browser, no key; bundle: API key in extension settings	Shipped; connector link from host documentation, not verified live
Cursor	Add to Cursor link (recommended); mnemoverse/cursor-plugin for the rule and skill	browser, no key, from the desktop app	Hosted setup checked in Cursor 3.21.16 on 2026-09-23; shipped plugin, local plugin 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	remote MCP server entry in the repository's Copilot → MCP servers settings	an API key as a bearer token from an Agents secret prefixed COPILOT_MCP_; the cloud agent does not support remote servers that sign in with OAuth	From host documentation, not verified live
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	remote MCP server entry (recommended); plugin from mnemoverse/claude-plugin for skills	browser, no key; codex mcp add starts the sign-in itself	MCP entry verified live 2026-10-26 (Codex CLI 0.164.0); plugin route from host documentation
Codex IDE extension	remote MCP server entry only; the extension does not support plugins	browser, no key	From host documentation, not verified live
ChatGPT	published Mnemoverse Memory plugin	browser, no key	Published; fresh Free/mobile installation and runtime not yet verified
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, started from /mcps with the key i	Grok Build verified live 2026-10-27 (Grok Build 1.0.70: plugin install, sign-in, memory_stats); Grok Bot from host documentation, not verified live
NanoClaw	template stamped from templates/ for the skills, plus a server the operator adds with a headers map, under a name the plugin does not own	none through the plugin; an API key as a bearer token through the operator's entry	From host documentation, not verified live (the operator's entry; not run from NanoClaw)
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, or vibe mcp add with an API key	browser, no key; or an API key as a bearer token	From host documentation, not verified live
Make	MCP Client app connection, + New MCP Server	browser, no key	From host documentation, not verified live
UiPath	Remote MCP Server in Orchestrator, MCP Servers → Add MCP Server → Remote	API key as a bearer token, in a header that reads an Orchestrator asset	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
OpenCode	remote server entry in ~/.config/opencode/opencode.json	browser, no key; opencode mcp auth mnemoverse starts it by hand	From host documentation, not verified live
Pi	pi mcp add mnemoverse --url, entry in ~/.pi/agent/mcp.json	browser, no key, through pi mcp login mnemoverse	From host documentation, not verified live
Kilo Code	remote server entry in ~/.config/kilo/kilo.jsonc (VS Code extension and CLI)	browser, no key	From host documentation, not verified live
Qoder	custom MCP server, Extensions → Connectors → Add Connector (desktop app)	browser, no key, through Authorize on the connector card	From host documentation, not verified live (sign-in run live 2026-10-27 in Qoder 0.4.11; no memory call was made through Qoder)
Goose	goose://extension link, or a streamable_http extension	browser, no key	From host documentation, not verified live
Qwen Code	qwen mcp add --transport http, entry in ~/.qwen/settings.json	browser, no key, from the /mcp dialog	From host documentation, not verified live
Augment (Auggie CLI)	auggie mcp add --transport http, entry in ~/.augment/settings.json	browser, no key (from the Auggie package, not its documentation)	From host documentation, not verified live
Amp	amp mcp add, local amp.mcpServers entry	browser, no key	From host documentation, not verified live
Crush	mcp add ... --oauth true in crushrc	browser, no key	From host documentation, not verified live
Factory Droid	droid mcp add --type http, entry in ~/.factory/mcp.json	browser, no key, through /mcp	From host documentation, not verified live
Trae	trae:// install link for the npx package	API key; the host's MCP pages do not describe a browser sign-in for remote servers	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
LobeHub	HTTP server entry under Settings → Connectors	API key as a bearer token; the browser sign-in from LobeHub Cloud is not on the allowlist	From host documentation, not verified live
Bolt	custom MCP server, chatbox plus icon → Connectors → Manage connectors → Custom MCP server (Pro, Teams and Enterprise plans)	API key, through Bolt's API key authentication; Bolt's documentation does not name its MCP OAuth callback	From host documentation, not verified live
Cline	remote server entry, Remote Servers tab or cline_mcp_settings.json	browser, no key, through Authenticate; or an API key as a bearer token	Sign-in verified by replay, 2026-10-18 (Cline 4.1.25's requests; the Cline extension itself was not run); the API-key entry from host documentation, not verified live
LibreChat	server added in the app from MCP Settings → Add MCP, or a mcpServers entry in librechat.yaml	an API key with the Bearer header format, one shared key or each user's own (v0.8.8 and later)	From host documentation, not verified live
LM Studio	remote entry in mcp.json, opened from Integrations → + Install → Edit mcp.json (the Program tab in LM Studio's 0.3.17 documentation)	browser sign-in from 0.4.10, or an API key as a bearer token in headers	From host documentation, not verified live
TypingMind	custom MCP server, Plugins → Store → MCPs → + Add MCP, with Custom HTTP headers (personal version); or the npx package through a Private MCP Connector	an API key as a bearer token in a custom header; or an API key with the npx package; TypingMind's sign-in callback is not on the allowlist	From host documentation, not verified live
LangSmith Fleet	remote MCP server entry, Connections → Add connection → + Add custom MCP, or Fleet → Integrations → + Custom MCP	an API key as a bearer token (Static Headers)	From host documentation, not verified live
ElevenLabs Agents	remote MCP server, Add Custom MCP Server in the MCP server integrations dashboard, or POST /v1/convai/mcp-servers	an API key as a bearer token in the Secret Token field, which ElevenLabs describes as the Authorization header value; the ElevenLabs MCP page describes no browser sign-in	From host documentation, not verified live
Dify	MCP server, Integrations → MCP → Add MCP Server (HTTP) (Dify Cloud, self-hosted 1.15.0 or later)	an API key as a bearer token on the Headers tab; without it Dify starts its own sign-in, which on Dify Cloud returns to cloud.dify.ai, not on the allowlist	From host documentation, not verified live
Relevance AI	agent's Tools tab → Add MCP → Connect my own	an API key as a bearer token through the Custom headers authentication	From host documentation, not verified live
Lindy	Integrations → + Add → MCP	an API key as a bearer token, under Advanced in the connect dialog	From host documentation, not verified live
Gumloop	Customize → Connectors → Add Custom MCP, then added to an agent's Connectors	an API key as a bearer token: API Key / Credentials → Headers, Authorization: Bearer mk_live_...; Gumloop's sign-in returns to api.gumloop.com or api.gumstack.com, neither of which is on the allowlist	From host documentation, not verified live
Vapi	MCP tool created with POST https://api.vapi.ai/tool ("type": "mcp"), then added on the assistant's Tools tab	an API key as a bearer token in server.headers; the Vapi MCP page describes no browser sign-in	From host documentation, not verified live
Microsoft Copilot Studio	remote MCP server through the MCP onboarding wizard of a standard-harness agent, Tools page → Add a tool → New tool → Model Context Protocol	an API key in a header the maker names: Authorization with Bearer mk_live_…, by default entered by each user of the agent; Copilot Studio's OAuth returns to a consent.azure-apim.net host, which is not on the allowlist	From host documentation, not verified live
Zapier Agents	MCP Client app connection (beta), then the connection as a tool of an agent	an API key in the connection's Bearer Token field	From host documentation, not verified live
Voiceflow	Add MCP server dialog, from Global tools, a playbook's tools or a workflow's MCP step	an API key as a bearer token in a header, kept as a project secret	From host documentation, not verified live
Retell AI	remote MCP server, MCPs → Add MCP in a single or multi-prompt agent, an MCP node in a conversation flow, or the mcps list in the Retell API	an API key as a bearer token in Headers; Retell runs no OAuth sign-in for MCP servers	From host documentation, not verified live
Manus	custom MCP server, Settings → Integrations → Custom MCP Servers → Add Server	an API key as a bearer token; the Manus page names API keys and bearer tokens as the credentials of a custom server	From host documentation, not verified live
Lovable	chat connector, Connectors → Add custom → MCP server (all plans)	an API key, through Bearer token or API key; Lovable's documentation does not name the callback of its default OAuth	From host documentation, not verified live
Zed and any MCP client	remote URL or npx package	browser; an API key as a bearer token; or an API key with the npx package	Shipped

Claude Code

Hosted MCP entry (recommended). Run this in your terminal to add memory in every project:

claude mcp add --scope user --transport http mnemoverse https://mcp.mnemoverse.com/mcp

Start a new Claude Code session, run /mcp, select mnemoverse and choose Authenticate. Complete sign-in in the browser, then ask Claude to call memory_stats with {}. A successful result confirms read access; the Claude Code guide explains how to verify a save when you request one. The guide also retains the local API-key alternative.

Plugin alternative, with commands and skills. Choose this instead if you want the plugin's extras:

/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.

What you get: the 11 tools from the hosted server, three commands (/mnemoverse:remember, /mnemoverse:recall, /mnemoverse:memory-status) and the seven skills listed at the top of this page.

Updates. Auto-update is off by default for a marketplace added this way, so an earlier install keeps its version. To update, run claude plugin update mnemoverse@mnemoverse in your shell, or open the plugin on the Installed tab of /plugin and choose Update now; then run /reload-plugins or start a new session. To have later versions arrive on their own, select mnemoverse on the Marketplaces tab of /plugin and choose Enable auto-update.

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. The recommended hosted command and authentication steps are detailed 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." Install and manage plugins, read 2026-10-30, section "Keep plugins updated": auto-update is "Off by default" for "every other marketplace, including the community marketplace, third-party marketplaces, and local development marketplaces", and "To update one plugin, open it on the Installed tab in /plugin during a session and select Update now, or run claude plugin update <plugin>@<marketplace> in your shell." The seven skills and the version 1.0.3 were read from the plugin repository at main 3201dd0 (skills/*/SKILL.md, .claude-plugin/plugin.json) on 2026-10-30.

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.

Add to Cursor (recommended). Open Add to Cursor and confirm in Cursor. It puts the remote server entry { "mcpServers": { "mnemoverse": { "url": "https://mcp.mnemoverse.com/mcp" } } } in ~/.cursor/mcp.json; the link carries only the server address, no key. Open Customize in the sidebar (Cursor Settings → Tools & MCPs in Cursor 3.21.16), click Connect next to mnemoverse and sign in through the browser. Ask the agent to call memory_stats with {}; a successful result confirms read access. The Cursor guide records the hosted setup check from 2026-09-23 and explains how to verify a requested save.

Plugin alternative, with the memory rule and skill. Choose this instead if you want those extras:

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.

Another keyless alternative without cloning is 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, use 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 seven 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 seven 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) works on issues and pull requests in its own environment on GitHub. A repository administrator gives it MCP servers in the repository settings. It does not support remote servers that sign in with OAuth, but a remote server entry can send headers whose values come from an Agents secret, so the cloud agent connects with a Mnemoverse API key as a bearer token (with an API key).

1. Create a key for this repository alone on console.mnemoverse.com and copy it: it is shown only once.
2. Add a repository-level Agents secret named COPILOT_MCP_MNEMOVERSE_AUTH with the value Bearer mk_live_YOUR_KEY (Configure secrets and variables for Copilot cloud agent). Only secrets whose names start with COPILOT_MCP_ reach the MCP configuration.
3. In the repository's Settings, click Copilot and then MCP servers in the sidebar, and enter this in the MCP configuration section:

{
  "mcpServers": {
    "mnemoverse": {
      "type": "http",
      "url": "https://mcp.mnemoverse.com/mcp",
      "headers": { "Authorization": "$COPILOT_MCP_MNEMOVERSE_AUTH" },
      "tools": ["memory_read", "memory_list_recent"]
    }
  }
}

4. Click Save MCP configuration.

The secret holds the whole header value, Bearer and the key, because GitHub's page maps a header either to a secret reference or to a literal string and shows no example that combines the two.

The cloud agent calls the tools it is given without asking for approval, and GitHub recommends allowing specific read-only tools. On the hosted server's server card, read 2026-11-04, memory_read, memory_list_recent, memory_stats, memory_list_rooms, vault_list and memory_graph carry readOnlyHint: true. The entry above lets it recall only. To let it also save what it learns, add "memory_write" to tools; it then writes to memory on its own. The key itself can read and write the whole memory of its account, and tools only limits what the agent calls, so give the repository its own key.

To check the connection, assign an issue to Copilot, open the session with View session and expand the Start MCP Servers step: when the server has started, its tools are listed at the bottom of the logs. The cloud agent uses MCP tools only, not resources or prompts. Turning on the plugin from .github/copilot/settings.json does not connect the memory here: the plugin's server entry carries no key and relies on the OAuth sign-in. This entry has not been run from the cloud agent.

Source: Configure MCP servers for your repository, read 2026-11-03: "For MCP servers configured in repository settings or custom agent profiles, Copilot cloud agent and Copilot code review do not currently support remote servers that use OAuth for authentication and authorization.", "Repository administrators can configure MCP servers by following these steps:", "click Copilot then MCP servers", "Click Save MCP configuration.", "Only Agents secrets and variables with names prefixed with COPILOT_MCP_ will be available to your MCP configuration.", "We strongly recommend that you allowlist specific read-only tools, since the agent will be able to use these tools autonomously and will not ask you for approval first.", "url (string): Required. The MCP server's URL.", "headers (object): Optional. The headers to attach to requests to the server.", "A substitution reference to a secret or variable in your Copilot environment, such as $COPILOT_MCP_API_KEY or ${COPILOT_MCP_API_KEY}.", "A literal string value.", "Click the Start MCP Servers step to expand the logs.", "If your MCP servers have been started successfully, you will see their tools listed at the bottom of the logs." and "Copilot cloud agent and Copilot code review only support MCP tools."; Configure secrets and variables for Copilot cloud agent, read 2026-11-03: "Copilot cloud agent has its own dedicated Agents secrets and variables" and "You must be a repository administrator to configure Agents secrets and variables for a repository."; About plugins, read 2026-09-22, for the plugins in .github/copilot/settings.json. From host documentation, not verified live.

Gemini CLI

Since June 18, 2026, Gemini CLI is no longer offered to unpaid-tier and Google One users; Google points them to Antigravity CLI, which takes the same remote entry as Google Antigravity.

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 and again 2026-10-30: "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 newest release of the repository, not its default branch, so it gets the skills of that release. On 2026-10-30 the newest release is v1.0.2, which carries kimi.plugin.json and two skills, agent-memory-discipline and setup; the five added in 1.0.3 are only on the default branch so far. To install from the default branch instead, run /plugins install https://github.com/mnemoverse/claude-plugin/tree/main, then /reload. /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 skills of the version installed: two from the v1.0.2 release, all seven from tree/main.

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." Kimi Code plugins, read again 2026-10-30, section "Installing from GitHub": "https://github.com/<owner>/<repo>: Install the latest release; falls back to the default branch if no release exists" and "https://github.com/<owner>/<repo>/tree/<ref>: Install a specific branch, tag, or short commit SHA". The release list and the skills in v1.0.2 were read on GitHub on 2026-10-30. Install lines from host documentation, not verified live.

ChatGPT and Codex

Codex CLI, hosted MCP (recommended). Add the hosted server as a remote MCP server and sign in:

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

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. Checked live on 2026-10-26 with Codex CLI 0.164.0 on Windows: codex mcp add detected the sign-in and started it in the browser by itself (Dynamic Client Registration, callback on 127.0.0.1), and a memory_stats call through the server succeeded. Run codex mcp login mnemoverse only if no browser opened.

Codex CLI, plugin alternative with skills. 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 seven skills. Codex does not load plugin commands for an Agent Plugins package, so the three commands are not available there.

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 the MCP entry added with codex mcp add 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. Install Mnemoverse Memory from the public card, complete Mnemoverse browser sign-in when prompted, and verify memory_stats in a conversation using the plugin. No custom MCP server setup or API key is needed. See the ChatGPT guide for the contact-saving flow and availability checks.

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, MCP entry: sign-in and memory_stats verified live 2026-10-26 through Codex CLI 0.164.0 on Windows. Codex CLI plugin route and Codex IDE extension: from host documentation, not verified live. ChatGPT custom-server alternative (historical check, separate from the published plugin): an existing Mnemoverse connector on ChatGPT Pro passed memory_stats, a write and a read on 2026-09-27; sign-in and creating the custom MCP server were not run. On that account, Settings → Security and login showed no Developer mode toggle, and chatgpt.com/plugins opened the Plugins settings. Connecting custom MCP servers in ChatGPT, read 2026-10-21 through the r.jina.ai reader: "You don’t need to turn on Developer Mode first."

Kiro

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

{
  "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:

1. Open the Powers panel and choose Add Custom Power.
2. Select Import power from GitHub.
3. 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 seven skills, each under a namespaced name; skills_list shows the full names. 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:

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.

Checked live on 2026-10-27 with Grok Build 1.0.70 on Windows: after the install, /mcps listed the server under Plugin: mnemoverse as needing sign-in; pressing i on it opened the browser sign-in, which completed by itself, and a memory_stats call through the server succeeded. Grok names the tools with the server in front, so the call shows as mnemoverse__memory_stats. A non-interactive run (grok -p) does not start the sign-in, so sign in from /mcps first.

What you get: the hosted server, the three commands and the seven 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. Grok Build: plugin install, sign-in from /mcps and memory_stats verified live 2026-10-27 through Grok Build 1.0.70 on Windows, with Grok's reading of Claude Code servers turned off ([compat.claude] with mcps = false in ~/.grok/config.toml), so the server came from the plugin. Grok Bot: 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.

Route: the operator's own entry with an API key (not verified live). NanoClaw accepts a remote streamable-http server with a headers map, added directly by the operator rather than through the plugin template, and the hosted server accepts a Mnemoverse API key as a bearer token (with an API key). Create a key on console.mnemoverse.com and put it in place of mk_live_YOUR_KEY:

ncl groups config add-mcp-server --id <group-id> --name mnemoverse-key --url https://mcp.mnemoverse.com/mcp --headers '{"Authorization":"Bearer mk_live_YOUR_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. The Mnemoverse side of this path answers as it should: on 2026-10-21 a made-up key sent in this header got 401 invalid_api_key ("This API key is not recognized"), which is the key check, not a refusal of the header. Nobody has run the path from NanoClaw yet, so it is not verified live.

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. The endpoint's answer to a bearer key was checked 2026-10-21 with a made-up key, without NanoClaw. From host documentation, not verified live.

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:

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 seven 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.

1. 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.
2. Click + Custom connector, and in the pop-up select Remote.
3. 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.
4. 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.

With an API key instead. The hosted server also accepts a Mnemoverse API key as a bearer token in the Authorization header, and the CLI can send one as static authentication. Create a key on console.mnemoverse.com and copy it: it is shown only once. Set MNEMOVERSE_API_KEY to the key in the shell that starts vibe, then add the server from that shell:

vibe mcp add mnemoverse --url https://mcp.mnemoverse.com/mcp --transport streamable-http --api-key-env MNEMOVERSE_API_KEY

With --api-key-env, Vibe uses static authentication instead of OAuth and by default sends the key as Authorization: Bearer <key>. If you already added mnemoverse with /mcp add above, run vibe mcp remove mnemoverse first, or give this entry another name. The key reads and writes the memory of the Mnemoverse account it was created in, so keep it like a password.

Source: Mistral's MCP servers page, read 2026-10-21, now describes both kinds of remote server: "For a remote server that uses OAuth, pass its name and URL. Vibe opens your browser to sign in", "For a remote server that uses an API key or static headers, pass --api-key-env or --header" and "Remove a server with vibe mcp remove <name>."; the defaults api_key_header "Authorization" and api_key_format "Bearer {token}" are from the configuration reference, read 2026-10-21; the Mistral Vibe README at main dd2c04c, read 2026-10-21: "Static auth is selected when --api-key-env or --header is provided; otherwise the server uses OAuth and starts browser login by default." 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.

UiPath

UiPath Orchestrator registers an external MCP server as a Remote MCP Server and passes calls from UiPath agents to it. Orchestrator does not run a browser sign-in against the external server: it sends the headers you configure. So the route on UiPath is a Mnemoverse API key as a bearer token, which the hosted server accepts in place of the sign-in (with an API key).

Working path (not verified live).

1. Create a key on console.mnemoverse.com.
2. In Orchestrator, store the whole header value in an asset, for example an asset named MnemoverseAuth with the value Bearer mk_live_YOUR_KEY, so the key is never typed into the server form.
3. On the MCP Servers page, select Add MCP Server, choose the Remote type, and enter a name such as mnemoverse (3 to 50 characters; it becomes the last part of the server's Preview URL).
4. Set Remote URL to:

https://mcp.mnemoverse.com/mcp

5. Under Headers, add Authorization with the value %ASSETS/MnemoverseAuth%.
6. Leave Connection empty and select Add.

UiPath does not forward its own bearer token to the remote server, so the hosted server sees only the header configured here. A Connection attached to the server would replace that header with an Integration Service sign-in; this page does not cover that route, because that sign-in has not been checked against Mnemoverse.

Source: Creating a remote MCP Server and MCP Server types, read 2026-10-28 through the r.jina.ai reader (both pages render with a script, and a made-up page on the same host also answers 200, so the reader's text is what was checked): "These headers are often used for authentication, such as API keys", "If the remote endpoint expects a prefix such as Bearer, store the full header value in the asset. For example, store Bearer <token> in the RemoteBearerToken asset, then configure the header as Authorization: %ASSETS/RemoteBearerToken%", "When a connection is attached, it supplies the Authorization header for every call, and any Authorization header configured in Headers is ignored", "UiPath-specific headers, including the bearer token, are not forwarded to the remote server", and "the remote endpoint must speak Streamable HTTP". 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: this path signs in with OAuth. 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:

{ "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:

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

Antigravity CLI reads the same two files: add the same entry to ~/.gemini/config/mcp_config.json (or the workspace .agents/mcp_config.json), then type /mcp inside the CLI to open its MCP manager and see the server's status.

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; read again 2026-10-30, now covering Antigravity CLI: "Antigravity CLI supports both local stdio processes and remote host MCP server configurations.", "Antigravity CLI loads MCP server definitions from two configuration files", "Global configuration: ~/.gemini/config/mcp_config.json", "Remote MCP servers must use the Streamable HTTP transport. Set the server's endpoint in serverUrl (url also works).", and "Type /mcp inside the prompt panel and press Enter to open the interactive MCP Manager Overlay." From host documentation, not verified live.

OpenCode

OpenCode is an open-source coding agent.

Working path. Add the hosted server to your global OpenCode config, ~/.config/opencode/opencode.json, as a remote server under mcp:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "mnemoverse": {
      "type": "remote",
      "url": "https://mcp.mnemoverse.com/mcp"
    }
  }
}

OpenCode sees that the server needs a sign-in, registers itself through Dynamic Client Registration and asks you to sign in the first time the server is used. To start the sign-in by hand:

opencode mcp auth mnemoverse

The browser opens; OpenCode waits on the loopback callback http://127.0.0.1:19876/mcp/oauth/callback, which the Mnemoverse sign-in accepts on any port. With no oauth.scope in the entry, OpenCode asks for the scopes the server advertises, which include memory:read and memory:write. opencode mcp list shows the server and its sign-in state.

Source: MCP servers, read 2026-10-13: "OpenCode automatically handles OAuth authentication for remote MCP servers", "Use Dynamic Client Registration (RFC 7591) if supported by the server", "If the server requires authentication, OpenCode will prompt you to authenticate when you first try to use it" and "you can manually trigger the flow with opencode mcp auth <server-name>"; Config, read 2026-10-13: "Place your global OpenCode config in ~/.config/opencode/opencode.json". The callback is from the OpenCode source at dev ecc4916 (packages/opencode/src/mcp/oauth-provider.ts: OAUTH_CALLBACK_PORT = 19876, OAUTH_CALLBACK_PATH = "/mcp/oauth/callback"), and the scope fallback from the MCP TypeScript SDK 1.29.0 that OpenCode pins (client/auth.js: scope || resourceMetadata?.scopes_supported), read 2026-10-07. From host documentation, not verified live.

Pi

Pi is the pi coding agent; it connects to MCP servers over streamable HTTP.

Working path. From a shell:

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

pi mcp add writes a user-level entry to ~/.pi/agent/mcp.json:

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

pi mcp login opens the authorization page and waits for the browser. Inside a session, Sign in in /mcp or /mcp login mnemoverse does the same. Pi registers itself with the Mnemoverse sign-in through Dynamic Client Registration, asks for the scopes the server advertises, and waits on http://127.0.0.1:<port>/callback, a loopback address the Mnemoverse sign-in accepts on any port. pi mcp list connects to the server and prints its tools.

Pi's default exposure for a server is codemode: the model reaches its tools through scripts. To let the model call the memory tools directly, add "exposure": "direct" to the entry.

Source: MCP Servers in the Pi repository at main 3daa202 (@earendil-works/pi-coding-agent 1.2.0), read 2026-10-13: "When the server rejects an unauthenticated connection, /mcp shows that it needs sign-in. Select "Sign in", run /mcp login sentry, or run pi mcp login sentry.", "Pi registers itself with the authorization server", "Otherwise, Pi requests the advertised scopes.", "callbackPort uses http://127.0.0.1:<port>/callback", the exposure table row "codemode (default)" and, for direct exposure, "Small, frequently used tool sets."; CLI, section "MCP commands", read 2026-10-13: "pi mcp add <server> [options] --url <url>" and "pi mcp login <server> [--timeout <seconds>]". The default callback without callbackPort is from the same repository at the same commit (packages/mcp/src/oauth/callback.ts: host "127.0.0.1", path "/callback"). From host documentation, not verified live.

Kilo Code

Kilo Code reads MCP servers from the Kilo config file, in the VS Code extension and in the kilo CLI alike.

Working path. Add the hosted server to ~/.config/kilo/kilo.jsonc, the configuration that applies to all projects:

{
  "mcp": {
    "mnemoverse": {
      "type": "remote",
      "url": "https://mcp.mnemoverse.com/mcp"
    }
  }
}

Kilo connects over Streamable HTTP and starts the OAuth flow when it connects. In the VS Code extension, a server that waits for sign-in shows the status needs_auth and a notification; click it to sign in. In the CLI, run:

kilo mcp auth mnemoverse

Kilo registers itself through Dynamic Client Registration and waits on the loopback callback http://127.0.0.1:19876/mcp/oauth/callback, which the Mnemoverse sign-in accepts on any port.

Source: Using MCP in Kilo Code, read 2026-10-13: ~/.config/kilo/kilo.jsonc "applies to all projects", "Remote servers support OAuth 2.0 authentication. If the server supports it, Kilo Code will automatically start the OAuth flow when you connect.", "Kilo Code tries StreamableHTTP first, then falls back to SSE automatically.", "For remote servers with OAuth, the extension will show a notification to start the auth flow. Click it to authenticate." and the CLI table row "kilo mcp auth: Authenticate with an MCP server". The registration, the callback and the auth [name] argument are from the Kilo source at main 20fb047206 (packages/opencode/src/mcp/oauth-provider.ts: client_name: "Kilo", OAUTH_CALLBACK_PORT = 19876, OAUTH_CALLBACK_PATH = "/mcp/oauth/callback"; packages/opencode/src/cli/cmd/mcp.ts: command: "auth [name]"), read 2026-10-07. From host documentation, not verified live.

Qoder

Qoder is a desktop agentic coding app; MCP servers are its connectors.

Working path. Select Extensions in the left sidebar, open the Connectors tab and select Add Connector. In Add custom MCP, choose Form, enter the MCP name mnemoverse, choose the HTTP transport and enter the URL:

https://mcp.mnemoverse.com/mcp

Leave the other fields empty, put no key anywhere, and select Add MCP. Qoder saves the server as a user-level entry under mcpServers in ~/.qoder/settings.json:

{
  "mcpServers": {
    "mnemoverse": {
      "type": "streamable-http",
      "url": "https://mcp.mnemoverse.com/mcp"
    }
  }
}

Adding the connector does not start the sign-in. Open the mnemoverse card under Extensions → Connectors and select Authorize: Qoder registers itself through Dynamic Client Registration, opens the browser sign-in and waits on a loopback callback, http://127.0.0.1:<port>/oauth/callback, which the Mnemoverse sign-in accepts. To use the server in a task, type / and select mnemoverse from the connector suggestions; begin with a read-only request such as memory_stats.

Source: Connectors, read 2026-10-27: "Select Extensions in the left sidebar.", "Open the Connectors tab.", "Select Add Connector to open Add custom MCP. The resulting server is user-level and its configuration is saved under mcpServers in ~/.qoder/settings.json.", "Form: enter an MCP name, choose a transport, and complete the fields shown for that transport." and "To choose a connector explicitly, type / and select it from the connector suggestions."; release notes, read 2026-10-27: Qoder 0.4.11, October 23, 2026. The documentation does not describe the sign-in for a custom server: the transport names (STDIO, HTTP, SSE) and the Authorize label are from the Qoder 0.4.11 app. Sign-in run live 2026-10-27 in Qoder 0.4.11 on Windows: the form saved the entry above with the status needing sign-in, Authorize registered the client and opened the browser, the callback on 127.0.0.1 completed, and the server reached the ready state. No memory call was made through Qoder's chat, so the section stays from host documentation, not verified live.

Goose

Goose is an open-source agent with a desktop app and a CLI; MCP servers are its extensions.

One link. Goose installs extensions from goose:// links. This one adds the hosted server as a remote extension:

goose://extension?url=https%3A%2F%2Fmcp.mnemoverse.com%2Fmcp&type=streamable_http&id=mnemoverse&name=Mnemoverse&description=Mnemoverse%20memory&timeout=300

Add to Goose

By hand. In the CLI, run goose configure, choose Add Extension, then Remote Extension (Streamable HTTP), and enter https://mcp.mnemoverse.com/mcp. Or add the entry to ~/.config/goose/config.yaml:

extensions:
  mnemoverse:
    name: Mnemoverse
    type: streamable_http
    uri: https://mcp.mnemoverse.com/mcp
    enabled: true
    timeout: 300

No client ID is needed: Goose obtains one through Dynamic Client Registration, which the Mnemoverse sign-in supports, and requests the scopes the server advertises. The browser sign-in returns to 127.0.0.1 on an ephemeral port, a loopback address the Mnemoverse sign-in accepts on any port.

Source: Using Extensions, read 2026-10-13: "goose://extension?url=<remote-streamable-http-url>&type=streamable_http&id=<id>&name=<n>&description=<description>", "All parameters in the deeplink must be URL-encoded.", "Remote Extension (Streamable HTTP)", "Remote (streamable_http) extensions that require OAuth normally obtain a client ID automatically, using Client ID Metadata Documents or Dynamic Client Registration.", "When omitted, scopes are selected from the server's advertised metadata" and "The OAuth callback is served on 127.0.0.1 with an ephemeral port". From host documentation, not verified live.

Qwen Code

Qwen Code is a terminal coding agent.

Working path.

qwen mcp add --scope user --transport http mnemoverse https://mcp.mnemoverse.com/mcp

This writes the server to ~/.qwen/settings.json; by hand the entry is:

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

Qwen Code discovers the OAuth metadata, registers itself through Dynamic Client Registration and asks for the scopes the server advertises. If the browser does not open on its own, open /mcp, select mnemoverse and use the Auth actions there. The sign-in returns to http://localhost:7777/oauth/callback, a loopback address the Mnemoverse sign-in accepts.

Run Qwen Code on the machine where your browser is. For remote machines and cloud IDEs, Qwen's documented workaround is a public redirect URL on your own domain, and the Mnemoverse sign-in refuses callbacks on custom domains (which clients can sign in).

Source: MCP servers, read 2026-10-13: http is "Recommended for remote services; works well for cloud MCP servers" with the JSON field httpUrl, "By default, Qwen Code uses http://localhost:7777/oauth/callback.", clientId is "optional with dynamic registration", "When running Qwen Code on remote servers, cloud IDEs, or web terminals, the default localhost redirect will NOT work." and "Use the /mcp dialog within Qwen Code to inspect MCP servers and manage authentication interactively."; Settings, read 2026-10-13, for ~/.qwen/settings.json. The dynamic registration, the scope choice and the /mcp instruction are from the Qwen Code source at main ad6039a (packages/core/src/mcp/oauth-provider.ts: registerClient; packages/core/src/mcp/oauth-utils.ts: "Protected resource scopes take precedence"; packages/cli/src/ui/commands/mcpCommand.ts: "MCP OAuth is now managed in the /mcp dialog", then "use the Auth actions there"), read 2026-10-07. From host documentation, not verified live.

Augment (Auggie CLI)

Auggie is Augment's terminal agent.

Working path.

auggie mcp add mnemoverse --transport http --url https://mcp.mnemoverse.com/mcp

This writes the server to ~/.augment/settings.json, which Auggie loads on startup; /mcp shows it. By hand the entry is:

{
  "mcpServers": {
    "mnemoverse": { "type": "http", "url": "https://mcp.mnemoverse.com/mcp" }
  }
}

Augment's documentation does not describe a sign-in for a custom remote server. The Auggie package does carry one: it registers itself through Dynamic Client Registration as Augment Code, asks for the scopes the server advertises, opens the browser and waits on http://localhost:<port>/callback, a loopback address the Mnemoverse sign-in accepts on any port. Start it from /mcp when the server shows that it needs authentication.

The Augment IDE extensions add a remote server with + Add remote MCP in the Settings panel; their documentation does not describe a sign-in for a custom server, so this page has no extension steps yet.

Source: Integrations and MCP, read 2026-10-13: "You can persist MCP servers in the Augment settings file ~/.augment/settings.json, which will initialize on startup and can be checked with /mcp." and the options "-t, --transport <transport>" and "-u, --url <url>"; Setup Model Context Protocol servers, read 2026-10-13: "click the "+ Add remote MCP" button in the MCP section". The sign-in is from the @augmentcode/auggie 0.36.0 package (augment.mjs: CLIENT_NAME="Augment Code", the redirect http://localhost:${port}/callback, the scopes from the resource metadata or scopes_supported, and "Opening browser for MCP authentication..."), read 2026-10-07. From host documentation, not verified live.

Amp

Amp has two kinds of MCP configuration: local amp.mcpServers entries on your machine, and remote definitions stored by ampcode.com. The working path below uses the local kind.

Working path.

amp mcp add mnemoverse https://mcp.mnemoverse.com/mcp

or, in ~/.config/amp/settings.json:

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

Start the Amp TUI: Amp registers itself and opens the browser sign-in. Amp's documentation does not name the callback of this automatic sign-in: it gives http://localhost:8976/oauth/callback only for a manually registered client, and says that a runner's sign-in opened on another device ends on a localhost page. The Mnemoverse sign-in accepts a loopback callback on any port. The documentation also does not say which scopes Amp requests; if memory writes are refused, see Troubleshooting on the Remote MCP page. If the sign-in has to be repeated, amp mcp oauth logout mnemoverse clears the stored credentials, and the next start signs in again.

Remote definitions. Remote MCP definitions (MCP server settings on ampcode.com, or amp mcp remote) handle OAuth through ampcode.com, which is on the Mnemoverse sign-in allowlist; amp mcp remote login prints the ampcode.com OAuth URL. Amp's documentation gives them as one route for orbs, where browser-based OAuth flows are unavailable. This page has no steps for remote definitions yet.

Source: MCP, read 2026-10-13: "Local MCP configuration is stored in amp.mcpServers", "Remote MCP definitions are stored by ampcode.com. You can manage them in MCP server settings or with amp mcp remote.", "User config (amp.mcpServers in ~/.config/amp/settings.json)", "Some MCP servers like Linear support automatic OAuth client registration.", "When you start the Amp TUI after adding a URL entry to amp.mcpServers, Amp will automatically start the OAuth flow in your browser.", "From any other device, the browser ends on a localhost page that fails to load.", under "Manual OAuth Client Registration", "Redirect URI: http://localhost:8976/oauth/callback", and, for orbs, "Browser-based OAuth flows are unavailable in orbs.", "use remote MCP definitions, which handle OAuth through ampcode.com" and "Run amp mcp remote login to print the ampcode.com OAuth URL." That ampcode.com is on the sign-in allowlist is on the Remote MCP page. From host documentation, not verified live.

Crush

Crush is Charm's terminal coding agent. Its configuration is a crushrc file; the global one is ~/.config/crush/crushrc on Unix-like systems and %USERPROFILE%\.config\crush\crushrc on Windows.

Working path. Add this line to the global crushrc:

mcp add mnemoverse --type http --url https://mcp.mnemoverse.com/mcp --oauth true

The older JSON format (crush.json, deprecated) takes the same entry:

{
  "mcp": {
    "mnemoverse": {
      "type": "http",
      "url": "https://mcp.mnemoverse.com/mcp",
      "oauth": true
    }
  }
}

With oauth on and no client ID, Crush registers itself through Dynamic Client Registration and asks for the scopes the server advertises. When the server needs a sign-in, Crush opens an authentication dialog; confirming it opens the browser. The callback is http://localhost:<port>/callback on the first free port from 40704 to 40713, a loopback address the Mnemoverse sign-in accepts on any port.

Source: README, sections "MCPs" and "MCP OAuth", read 2026-10-13: "HTTP and SSE MCP servers that require OAuth can use Crush's built-in authorization-code flow instead of a static Authorization header." and "When omitted, Crush attempts dynamic registration automatically"; Configuration, read 2026-10-13: "global config lives at ~/.config/crush/crushrc on Unix-like systems and %USERPROFILE%\.config\crush\crushrc on Windows", the mcp add flag --oauth bool, "enable OAuth 2.1 flow (HTTP only)", and "JSON is still supported but is deprecated". The --oauth true form is from the Crush source at main d6edc32 (internal/shellconfig/mcp.go: [--oauth true|false]), read 2026-10-13. The dialog, the callback ports and the client name are from the Crush source at main 140e8cb (internal/ui/model/mcp_auth.go: "openMCPAuthDialog opens the MCP authentication dialog if any servers are pending auth"; internal/oauth/mcp/handler.go: ports 40704 to 40713, "http://localhost:%d%s" with callbackPath = "/callback", ClientName: "Crush"), and the scope choice from the MCP Go SDK it pins (auth/authorization_code.go: requestedScopes = prm.ScopesSupported), read 2026-10-07. From host documentation, not verified live.

Factory Droid

Droid is Factory's coding agent.

Working path.

droid mcp add mnemoverse https://mcp.mnemoverse.com/mcp --type http

This writes the server to your user config, ~/.factory/mcp.json:

{
  "mcpServers": {
    "mnemoverse": { "type": "http", "url": "https://mcp.mnemoverse.com/mcp" }
  }
}

droid mcp list shows the server as needs authentication until you sign in. Run /mcp inside Droid and authenticate the server: Droid discovers the Mnemoverse authorization server, registers itself through Dynamic Client Registration, requests the discovered scopes and completes the sign-in in the browser on a localhost callback, which the Mnemoverse sign-in accepts on any port.

Source: Model Context Protocol (MCP), read 2026-10-13: "droid mcp add <name> <urlOrCommand...> --type <stdio|http|sse>", "Many remote servers require OAuth. After adding one, run /mcp to complete the browser authentication flow.", "Servers that require OAuth show needs authentication until you finish the sign-in flow with /mcp.", "Droid discovers the authorization server, registers a client automatically via Dynamic Client Registration (DCR)", scopes: "OAuth scopes to request instead of the discovered defaults", callbackPort: "Fixed localhost port for the OAuth callback (1-65535)", and the user config ~/.factory/mcp.json. From host documentation, not verified live.

Trae

Trae adds a remote MCP server by url, with optional headers. Its changelog lists OAuth support for MCP servers from TRAE v3.5.51, but its MCP pages do not describe that sign-in: how it starts, or which callback it returns to. Until a sign-in from Trae has been run, this page gives the local package with an API key from console.mnemoverse.com (free tier, no credit card).

Install link. Paste this link into your browser's address bar and press Enter, confirm that the browser may open TRAE, then in the Configure Manually window replace mk_live_YOUR_KEY with your key and click Confirm:

trae://trae.ai-ide/mcp-import?type=stdio&name=mnemoverse&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBtbmVtb3ZlcnNlL21jcC1tZW1vcnktc2VydmVyQGxhdGVzdCJdLCJlbnYiOnsiTU5FTU9WRVJTRV9BUElfS0VZIjoibWtfbGl2ZV9ZT1VSX0tFWSIsIk1ORU1PVkVSU0VfQVBJX1VSTCI6Imh0dHBzOi8vY29yZS5tbmVtb3ZlcnNlLmNvbS9hcGkvdjEifX0%3D

By hand. Open Settings, then MCP; in the Agent window, select Local as the runtime environment first. Click Add, then Create Manually, paste this into the Configure Manually window and click Confirm:

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

The local package runs through npx, so Node.js must be installed.

Source: Add MCP servers, read 2026-10-13: "In the IDE or Agent window, go to Settings>MCP.", "(Agent window only) Select a runtime environment for the MCP server", "Local MCP server can only be used in local and worktree tasks.", "In the upper-right corner of the MCP Servers Management area, click Add>Create Manually.", "The Configure Manually window appears.", "If you want to add a completely new MCP server, enter the JSON configuration into the input box and then click the Confirm button.", the HTTP server fields url and headers ("Custom HTTP request headers, used to carry additional information in the request (such as authentication information and more)"), and "For MCP servers marked as "Local", NPX or UVX needs to be installed locally before they can be used."; MCP server install links, read 2026-10-13: "trae://trae.ai-ide/mcp-import?type=${TYPE}&name=${NAME}&config=${BASE64_ENCODED_CONFIG}", "Available values: stdio, http.", "Serialize the config JSON object using JSON.stringify(), then encode it in Base64, and finally URL encode it.", "In the browser's pop-up, confirm that you want to open TRAE." and "In the Configure Manually window that pops up in TRAE, confirm this MCP server's configuration, then click the Confirm button." Neither page mentions OAuth. Changelog, read 2026-10-13, under TRAE v3.5.51 (April 14, 2026): "Supported the full OAuth authorization flow for MCP servers, including authorization, execution, invocation, and revocation." The three Trae pages render in the browser, so they were read through the r.jina.ai reader. From host documentation, not verified live.

LobeHub

LobeHub adds an MCP server by URL under Settings → Connectors, with authentication or headers. The browser sign-in does not complete from LobeHub Cloud (app.lobehub.com), because its callback is not on the registration allowlist, so connect with an API key:

1. Create a key on console.mnemoverse.com and copy it: it is shown only once.
2. In LobeHub, open Settings → Connectors, add an MCP server manually and choose HTTP Server.
3. Enter https://mcp.mnemoverse.com/mcp as the URL and add the header Authorization: Bearer mk_live_YOUR_KEY, or the key as a bearer token if the authentication setting offers it.
4. Turn the connector on for an agent: Agent Settings → Connectors, select the server, set the tool permissions and save.

Give LobeHub its own key: a key reads and writes the whole memory of its account, and revoking it in the console stops only this connection (with an API key).

Source: MCP Marketplace (docs/usage/community/mcp-market.mdx in the LobeHub repository at canary 0abdcb8), read 2026-10-26: "If an MCP server is not listed in the marketplace, open Settings → Connectors to add it manually.", "Enter the MCP server URL and add authentication or headers when the service uses them.", "Keep API keys and tokens in Connector authentication settings".

Bolt

Bolt is an AI app builder in the browser. Its agent uses remote MCP servers through connectors, which Bolt includes on its Pro, Teams and Enterprise plans, not on Free. In a shared project, only the project owner can connect MCP servers and prompt Bolt to use them. Connect with an API key:

1. Create a key on console.mnemoverse.com and copy it: it is shown only once.
2. On the Bolt homepage, click the plus icon in the chatbox, then Connectors and Manage connectors. On the Connectors (MCP) page, click Custom MCP server.
3. Enter mnemoverse as the name and https://mcp.mnemoverse.com/mcp as the URL, choose the HTTP transport and the API key authentication with mk_live_YOUR_KEY, and click Connect. Bolt checks the key and shows Connected in the upper-right corner.
4. In a project, click the plus icon in the chatbox, click Connectors and turn on the toggle next to mnemoverse.

Bolt's connector page does not name the header that carries the key, and the hosted server accepts a key only as a bearer token (with an API key), so this route works only if Bolt sends the key in that form; it has not been run from Bolt. Choose API key rather than MCP OAuth: Bolt's documentation does not name the callback of its sign-in, and the Mnemoverse sign-in accepts callbacks only on listed hosts.

Give Bolt its own key: a key reads and writes the whole memory of its account, and revoking it in the console stops only this connection. Bolt turns on all of a connector's tools when you add it, for all your projects; to keep Bolt to recall, edit the connector and deselect the tools that write.

Source: Connect to an MCP server, read 2026-11-02: "From the Bolt homepage, in the chatbox, click the plus icon.", "Click Connectors, then click Manage connectors.", "From the Connectors (MCP) page, click Custom MCP server.", "Select API key and enter your key, or select MCP OAuth to use a sign-in flow.", "Bolt verifies these credentials when you set up your connection.", "a Connected status appears in the upper-right corner of the screen", "Turn on the toggle next to the connector's name.", "When you add a connector, all available tools are turned on by default." and "The tools you enable in the connector apply to all projects."; Collaborate with others, read 2026-11-02: "only the project owner can connect MCP servers and prompt Bolt to use those connectors"; Pricing, read 2026-11-02: "Connectors & MCPs", "Not included" for Free and "Included" for Pro, Teams and Enterprise. The connector page names neither the header that carries the API key nor the callback of MCP OAuth. From host documentation, not verified live.

Cline

In the Cline panel, click the MCP Servers icon and open the Remote Servers tab. Enter mnemoverse as Server Name and https://mcp.mnemoverse.com/mcp as Server URL, choose Streamable HTTP and click Add Server. The server asks for a sign-in, so its row shows an Authenticate button: click it, sign in in the browser and approve the scopes. Cline waits on a loopback callback, http://127.0.0.1:1456/mcp/oauth/callback (ports 1457 to 1461 when 1456 is taken), which the Mnemoverse sign-in accepts on any port.

The same entry by hand goes under mcpServers in the file that Configure → Configure MCP Servers opens (the Cline CLI reads ~/.cline/data/settings/cline_mcp_settings.json):

{
  "mcpServers": {
    "mnemoverse": {
      "type": "streamableHttp",
      "url": "https://mcp.mnemoverse.com/mcp"
    }
  }
}

Keep "type": "streamableHttp": without it Cline uses the legacy SSE transport. In the Cline CLI, the Authorize OAuth action of cline mcp runs the browser sign-in.

With an API key instead. Add "headers": { "Authorization": "Bearer mk_live_YOUR_KEY" } to the entry, with a key from console.mnemoverse.com; the hosted server accepts it in place of the sign-in (with an API key). This entry has not been run from Cline.

Source: MCP overview (docs/mcp/mcp-overview.mdx in the Cline repository at main 0adccbd), read 2026-10-21: "use the Remote Servers tab", "Choose Transport Type: Streamable HTTP (recommended)", "Click Add Server.", "Authorize OAuth | Run or rerun browser authorization for a remote server", a remote example with "type": "streamableHttp", "url" and "headers": { "Authorization": "Bearer your-token" }, and "Omitting it defaults to the legacy sse transport"; the Authenticate button is from the Cline source at tag v4.1.25 (apps/vscode/webview-ui/src/components/mcp/configuration/tabs/installed/server-row/ServerRow.tsx), and the callback address and ports from apps/vscode/src/services/mcp/McpOAuthManager.ts at the same tag, read 2026-10-21. Sign-in verified by replay on 2026-10-18 against the production server: a script sent the requests Cline 4.1.25 sends from Authenticate, with the MCP SDK version Cline ships (1.30.0), the client name Cline and the callback http://127.0.0.1:1456/mcp/oauth/callback, after Cline's own code had been run against a local copy of the server and its requests matched the script's in order and content. On production the sign-in completed, the token carried memory:read and memory:write, the tool list came back, and one memory_write and one memory_read worked. The Cline extension itself was not run.

LibreChat

LibreChat is an open-source chat app that teams host themselves. It connects remote MCP servers over Streamable HTTP and can send an API key as Authorization: Bearer, so Mnemoverse connects with an API key (with an API key). A user whose role may create MCP servers adds one in the app, with no restart; an operator adds one for everyone in librechat.yaml. These steps follow LibreChat v0.8.8 and later. The API key options arrived in v0.8.2, and from v0.8.2 to v0.8.7 LibreChat sends a server whose users each provide their own key to a sign-in instead of using the key, so on those versions use one shared key.

In the app:

1. Create a key on console.mnemoverse.com and copy it: it is shown only once.
2. In the side panel, open MCP Settings and click Add MCP (the + button). If MCP Settings or the button is missing, your role may not create MCP servers: an admin turns that on with Allow users to create MCP servers under Admin Settings in the MCP panel.
3. Enter Mnemoverse as Name, https://mcp.mnemoverse.com/mcp as MCP Server URL and choose Streamable HTTPS as Transport.
4. Under Authentication, choose API Key in place of the default None (Auto-detect), which finds the hosted server's sign-in and switches the server to it; that sign-in completes only when LibreChat is reached at localhost (which clients can sign in). Paste the key alone, mk_live_... without Bearer , which LibreChat adds; or check Each user provides their own key so that every user enters theirs through Configure. Choose Bearer as Header Format.
5. Check I trust this application and click Create.

A server created in the app belongs to whoever created it. Other users see it only after the owner shares it from the server's Edit dialog, which needs Allow users to share MCP servers, off by default for the USER role.

In librechat.yaml: put the key in .env as MNEMOVERSE_API_KEY, add the entry under mcpServers and restart LibreChat:

mcpServers:
  mnemoverse:
    type: streamable-http
    url: https://mcp.mnemoverse.com/mcp
    requiresOAuth: false
    apiKey:
      source: admin
      key: "${MNEMOVERSE_API_KEY}"
      authorization_type: bearer

For each user's own key, write source: user in place of source: admin and leave out the key line; each user then enters their key in LibreChat, and nothing goes in .env. Keep requiresOAuth: false: LibreChat's detection probes the server without the configured key, and the hosted server, which also offers a sign-in, answers that probe like a server that needs one. Choose Bearer, or authorization_type: bearer, and not Custom, which sends X-Api-Key when no header name is given, and the hosted server refuses that header. If the operator has set mcpSettings.allowedDomains in librechat.yaml, add mcp.mnemoverse.com to that list, or LibreChat refuses the server as not allowed; the list applies to servers added in the app as well.

To use the memory in a chat on any endpoint other than Agents or Assistants, turn the server on from the composer's + palette under MCP Servers and pick a model that supports tool calls; for an agent, add the server from the Agent Builder's Tool Library. A wrong or revoked key shows as Error or Disconnected on the server in MCP Settings, not as Needs Auth: enter the key again with Configure for each user's own key, with Edit for a key pasted in the app, or in .env followed by a restart. Needs Auth on this server means LibreChat treats it as a sign-in server, which happens when it was saved with None (Auto-detect) or by a version before v0.8.8: open it with Edit, choose API Key and save it.

A key reads and writes the whole memory of its Mnemoverse account. With one shared key, a key pasted in the app on a server its owner shares or source: admin in librechat.yaml, every LibreChat user who can use the server, and every agent it is added to, works in that one memory. The tools that change memory are memory_write, memory_feedback, memory_create_room, memory_invite_to_room and memory_join_room, and the tools that read can return anything stored in that account to whoever is chatting. Let each user provide their own key when users should not share one memory. This entry has not been run from LibreChat.

Source: MCP, read 2026-11-04: "If your role allows it, click Add MCP (the + button) in MCP Settings to register a remote server without touching librechat.yaml or restarting.", "Fill in the MCP Server URL and pick a Transport: Streamable HTTPS or SSE.", "None (Auto-detect): LibreChat probes the server and switches to OAuth if the server asks for it.", "API Key: enter one shared key, or check Each user provides their own key so every user enters theirs through Configure. Choose the Header Format: Bearer, Basic, or Custom with your own header name.", "Check I trust this application and click Create. The server is available right away.", "The owner can share one from its Edit dialog with specific users, groups, roles, or everyone", "Servers defined in librechat.yaml are available to everyone with permission to use MCP.", "open the composer's + palette (Attach and tools) and look under MCP Servers.", "Pick a model that supports tool calls", "In the Agent Builder, click Add next to Tools to open the Tool Library" and "If an API-key server created with an older version is stuck on Needs Auth, open it with Edit and save it once."; MCP Servers Object Structure, read 2026-11-04: "API key is provided by the user through the UI", "The API key value, shared by all users.", "Sent as Authorization: Bearer <key>", "Defaults to X-Api-Key when omitted", "Set requiresOAuth: false for servers protected only by a static Authorization header (e.g. a Bearer API key).", "Auto-detection probes the server without your configured headers", "mcpSettings domain and address restrictions apply." and "Servers in librechat.yaml are initialized at startup, so changes to this file need a restart."; MCP Settings Object Structure, read 2026-11-04: "When configured, only listed domains are allowed."; LibreChat v0.8.2: "Includes API key authentication support", and LibreChat v0.8.8: "Honor User-Provided MCP API Key Instead of Forcing OAuth", both read 2026-11-04; the labels Admin Settings, Allow users to create MCP servers and Allow users to share MCP servers, and how a key error shows, are from the LibreChat repository at main (v0.8.9-rc1), read 2026-11-04. From host documentation, not verified live.

LM Studio

LM Studio runs models on your own computer. From version 0.3.17 it connects local and remote MCP servers listed in its mcp.json, which follows Cursor's format. From 0.4.10 it can sign in to a remote server through the browser, and a remote entry can also carry headers, so Mnemoverse connects with the browser sign-in or with an API key as a bearer token (with an API key).

With the browser sign-in (LM Studio 0.4.10 and later):

1. In LM Studio, open Integrations (the hammer icon at the top of the right-hand sidebar, or next to the message box) and click + Install → Edit mcp.json. LM Studio's own page, written for 0.3.17, calls this the Program tab in the right-hand sidebar → Install → Edit mcp.json. The 0.4 names come from screenshots on LM Studio's bug tracker, not from its documentation.
2. Add the entry, inside the existing mcpServers object if the file has one, and save:

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

3. In Integrations, turn on mcp/mnemoverse for the chat and sign in to Mnemoverse in the browser when LM Studio asks.

LM Studio's MCP Integrations page says integrations that require authentication connect without copying tokens or configuring headers. The callback it documents, http://127.0.0.1:33389/mcp-oauth-callback, is a loopback address, which the Mnemoverse sign-in accepts on any port. This route has not been run from LM Studio; if no sign-in opens, use a key.

With an API key: create a key for LM Studio alone on console.mnemoverse.com (it is shown only once) and give the same entry a header:

{
  "mcpServers": {
    "mnemoverse": {
      "url": "https://mcp.mnemoverse.com/mcp",
      "headers": { "Authorization": "Bearer mk_live_YOUR_KEY" }
    }
  }
}

An open report on LM Studio's bug tracker describes Edit mcp.json opening an empty file while other servers are working; if you see that, add the entry to the file itself at the path below. LM Studio reloads the servers in the file when it is saved. When a model calls a tool, LM Studio shows a confirmation dialog unless you chose to always allow that tool. In LM Studio 0.4 the per-tool choices show under the server in Integrations; 0.3.17 named the place App Settings → Tools & Integrations. Edit the file from the app, as LM Studio recommends. Its documentation puts it at ~/.lmstudio/mcp.json on macOS and Linux and %USERPROFILE%/.lmstudio/mcp.json on Windows, and one report on LM Studio's bug tracker found it in ~/.cache/lm-studio on macOS. With a key, the file holds it in plain text, so keep it like a password; revoking the key in the console stops only this connection.

If you turn on Allow calling servers from mcp.json in LM Studio's Server Settings, every API client with an LM Studio API token can use this server with your sign-in or your key. With Serve on Local Network on, that includes other devices on your network. The tools that change memory are memory_write, memory_feedback, memory_create_room, memory_invite_to_room and memory_join_room. The tools that read can return anything stored in that Mnemoverse account to whoever sends the request. Leave that switch off unless those clients should share this memory. This entry has not been run from LM Studio.

Source: Use MCP Servers, read 2026-11-04: "Starting 0.3.17 (b10), LM Studio supports both local and remote MCP servers.", "LM Studio currently follows Cursor's mcp.json notation.", "tab in the right hand sidebar.", "Click Install > Edit mcp.json.", "This will open the mcp.json file in the in-app editor." and a remote example whose headers set Authorization to Bearer <YOUR_HF_TOKEN>; MCP in LM Studio, read 2026-11-04: "When you save the mcp.json file, LM Studio will automatically load the MCP servers defined in it.", "When a model calls a tool, LM Studio will show a confirmation dialog to the user.", "If you choose to always allow a tool, LM Studio will not show the confirmation dialog for that tool in the future.", "You can manage this later in App Settings > Tools & Integrations.", "mcp.json lives in ~/.lmstudio/mcp.json on macOS and Linux, and in %USERPROFILE%/.lmstudio/mcp.json on Windows." and "It's recommended to use the in-app editor to edit this file."; LM Studio 0.4.0, read 2026-11-04: "A completely revamped UI experience" and "Updated style for Integrations panel and select"; Server Settings, read 2026-11-04: "Allow API clients to use servers you defined in your mcp.json in LM Studio." and "Allow other devices on the same local network to access the API server."; Download LM Studio, read 2026-11-04: "Experiment with LLMs on your computer."; MCP Integrations, read 2026-11-05: "connect integrations that require authentication without copying tokens or configuring headers." and "When configuring your OAuth app, use the following callback URL:"; LM Studio 0.4.10, read 2026-11-05: "Add OAuth support for MCP servers"; the empty editor from issue 1699 on LM Studio's bug tracker, open on 2026-11-05: "mcp.json is empty (even though 4 custom MCP are functioning)"; the 0.4 panel, its + Install button and the mcp/<name> toggles from screenshots on that bug tracker, issues 1699 and 2365 ("In the chat Integrations panel (hammer icon)", LM Studio 0.4.23), and the ~/.cache/lm-studio location from issue 1371. From host documentation, not verified live.

TypingMind

TypingMind is a chat interface for AI models, sold as a personal license for the app at typingmind.com and as TypingMind Teams. Its documented OAuth callbacks are on www.typingmind.com for the personal version and on each Teams workspace's own host, and neither is on the Mnemoverse registration allowlist. A custom MCP server in TypingMind can send custom HTTP headers, so Mnemoverse connects with an API key as a bearer token (with an API key). These steps are for the personal version.

1. Create a key for TypingMind alone on console.mnemoverse.com and copy it: it is shown only once.
2. In TypingMind, click Plugins in the left sidebar. Under Store, click MCPs, then + Add MCP. The Add Custom MCP Server URL page opens.
3. Enter https://mcp.mnemoverse.com/mcp as Server URL and Mnemoverse Memory as Connection name.
4. Open Advanced options, turn on Custom HTTP headers and add a header with the Header name Authorization and the Header value Bearer mk_live_YOUR_KEY: the word Bearer, a space, then the whole key. Leave the OAuth client settings empty.
5. Click Create connection. The new entry shows Connection Required via Select Connector: click Connect, choose TypingMind Cloud in the Select MCP Connector dialog and click Select Connector. TypingMind Cloud needs a free TypingMind Cloud account; a Private MCP Connector that you run yourself works too.
6. When the entry shows Connected via TypingMind Cloud, open its Tools tab: each tool has its own toggle.
7. In a chat, click the plugin selector next to the model name and turn on Mnemoverse Memory under MCP.

The connector is a server between the TypingMind app and Mnemoverse: with TypingMind Cloud, TypingMind's server relays the requests, the Authorization header with them; with a Private MCP Connector, the connector you run on your own computer or server does. A 401 when connecting means the server did not accept the header: check that the name is Authorization and the value is Bearer, a space and the whole key. The server reads only that form, so a key sent without Bearer, or in another header such as X-Api-Key, also gets 401.

TypingMind's guides name the entry point in three ways: Plugins → Store → MCPs → + Add MCP in its newest guide, tested on 2026-11-04 and 2026-11-05; Plugin → MCP Connectors → Add Connector in its older integration guides; and Add custom connector under the MCP Store on its MCP overview page. Its pricing page lists "Unlimited plugins & MCPs" only under the Premium personal license, and its Plans & Pricing page checks "Use unlimited plugins" only for Premium; neither says whether the Standard or Extended license can add an MCP server.

The key reads and writes the whole memory of its Mnemoverse account; give TypingMind its own key. The tools that change memory are memory_write, memory_feedback, memory_create_room, memory_invite_to_room and memory_join_room; turn off in the Tools tab any that TypingMind should not call. This entry has not been run from TypingMind.

In TypingMind Teams, MCP servers are plugins that an admin creates under Admin Panel → Plugins → Create New Plugin, with Model Context Protocol as the implementation and the server configuration in JSON. TypingMind's Teams pages show a remote server in that JSON with a URL and no header, so this page has no Teams steps. A key written into a Teams plugin would serve every member the plugin is visible to, all in that key's one memory.

On a computer with Node.js 18 or later, the npx package also runs through a Private MCP Connector on that computer. In Settings → Advanced Settings → Model Context Protocol, click Setup Connector, choose This Device, run the command it shows in a terminal and keep the terminal open. Then click Edit Servers, add the entry under mcpServers, save, and turn the server on under Plugins:

{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": ["-y", "@mnemoverse/mcp-memory-server@latest"],
      "env": { "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY" }
    }
  }
}

Source: TypingMind MCP + n8n, tested by TypingMind with TypingMind MCP Connector 1.4.1, read 2026-11-05: "Click Plugins in the left sidebar.", "Under Store, click MCPs, then click + Add MCP (top right).", "The Add Custom MCP Server URL page opens", "Open Advanced options, turn on Custom HTTP headers, and add:", "Type the word Bearer, a space, and then the token.", "Click Create connection.", "The new entry shows Connection Required via Select Connector. Click Connect. In the Select MCP Connector dialog, choose TypingMind Cloud, then click Select Connector.", "When it works, the entry shows ✓ Connected via TypingMind Cloud.", "each with a toggle and a Read-only or Destructive badge", "Click the plugin selector next to the model name", "401 Unauthorized: the access token is wrong, was regenerated (the old one is revoked), or the header is missing the" and "click Setup Connector, choose This Device, and run the command it shows in a terminal. Keep the terminal open."; Overview of MCP in TypingMind, read 2026-11-05: "Plugins → MCP Store → Add custom connector", "Main redirect URL: https://www.typingmind.com/oauth/callback", "Example redirect URL: https://{your-workspace-url}/oauth/callback", "MCP Connector is an intermediate server to facilitate your connection between the TypingMind app and the remote MCP servers." and "You will need to signup for an account with TypingMind Cloud first"; TypingMind MCP + Github, read 2026-11-05: "Go to Plugin → MCP Connectors → Add Connector"; Use MCP with Private MCP Connector, read 2026-11-05: "In TypingMind, go to Settings → Advanced Settings → Model Context Protocol to start setup your MCP servers.", "Your device must support NodeJS 18+ to run the MCP Connector." and "In TypingMind for Teams, MCP are implemented as plugins. Go to your Admin Panel → Plugins → Create New Plugin."; Connect Multiple MCP Servers, read 2026-11-05: "environment variables required for authentication or configuration" and "enable each MCP server as a separate plugin"; Plans & Pricing, read 2026-11-05: "Use unlimited plugins", checked only in the Premium column; Pricing, read 2026-11-05: "Unlimited plugins & MCPs"; TypingMind Teams - Model Context Protocol (MCP), read 2026-11-05: "In the admin panel, create a new plugin and pick Model Context Protocol under Implementation, then paste your server config JSON." and an example server entry with a url and no headers; Restrict Plugin Access, read 2026-11-05: "choose the user group that can access to the Plugin". From host documentation, not verified live.

LangSmith Fleet

LangSmith Fleet (formerly Agent Builder) adds remote MCP servers to one agent or to every agent in a LangSmith workspace, and it can send a fixed header with every request, so it connects with a Mnemoverse API key. Adding a server needs the MCP Server Create permission in the workspace.

Create a key for Fleet alone on console.mnemoverse.com and copy it: it is shown only once. Then, for one agent:

1. Open the agent and expand the Connections drawer in the sidebar.
2. Click Add connection, then + Add custom MCP.
3. Enter mnemoverse as the name and https://mcp.mnemoverse.com/mcp as the URL.
4. Choose Static Headers as the authentication type and add one header: Key Authorization, Value Bearer mk_live_YOUR_KEY.

Fleet then discovers the memory tools and sends the header both when it lists them and when the agent calls them. To offer the server to every agent in the workspace, add the same entry under Fleet > Integrations with + Custom MCP, or under Settings > MCP servers with Add server, and click Save server. The key reads and writes the whole memory of the Mnemoverse account it was created in (with an API key), so every agent that uses this entry shares that memory; keep the key like a password.

Each tool has an approval mode in the Connections drawer, Auto or Ask. The tools that change memory are memory_write, memory_feedback, memory_create_room, memory_invite_to_room and memory_join_room; the rest only read. Fleet stores tool references by server URL, so if you later change the URL of the entry, remove and re-add the Mnemoverse tools in each agent that uses them. Fleet's OAuth 2.1 (Auto) option has not been run against Mnemoverse; use the API key.

Source: Remote MCP servers, read 2026-10-26: "Open your agent, then in the sidebar expand the Connections drawer.", "Click Add connection, then click + Add custom MCP.", "Enter the server name and URL, then configure authentication", "Static Headers: Add key-value pairs sent with every request. The most common pattern is using an Authorization bearer token", "Value: Bearer API_KEY", "The configured headers are applied to both tool discovery requests and tool execution requests.", "Click + Custom MCP at the bottom of the left sidebar.", "Click Add server", "Click Save server.", "Adding MCP servers requires the MCP Server Create permission." and "Fleet stores tool references by MCP server URL."; Essentials, read 2026-10-26: "Each tool has an approval mode you can set in the Connections drawer", "Auto: The tool runs automatically without approval." and "Ask: The agent pauses and waits for your approval before the tool runs."; Fleet overview, read 2026-10-26: "Agent Builder is now LangSmith Fleet." From host documentation, not verified live.

ElevenLabs Agents

ElevenLabs Agents (ElevenAgents in the ElevenLabs documentation) gives an agent the tools of a remote MCP server that the workspace adds as an integration. The ElevenLabs MCP page describes a secret token and HTTP headers for connecting to a server, not a browser sign-in, so this connection uses a Mnemoverse API key as a bearer token. Create a key on console.mnemoverse.com and copy it: it is shown only once.

MCP is off in every ElevenLabs workspace until one member opts in for the whole workspace. In the dashboard this happens the first time someone adds a server: a dialog asks them to accept the Model Context Protocol Server Terms. With the API, the same switch is the can_use_mcp_servers workspace setting. Workspaces in Zero Retention Mode or with HIPAA compliance cannot use MCP servers.

Open the MCP server integrations dashboard and click Add Custom MCP Server. Enter Mnemoverse as Name, Long-term memory as Description and https://mcp.mnemoverse.com/mcp as Server URL. In Secret Token, which the ElevenLabs page describes as the "Authorization header value", enter Bearer mk_live_YOUR_KEY. Click Add Integration: ElevenLabs tests the connection and lists the tools. The ElevenLabs pages do not say whether ElevenLabs adds the Bearer prefix itself: if the test does not list the tools, enter the key in Secret Token without the prefix. Then add the server to the agent that should have the memory.

With the API. ElevenLabs asks for credentials to be kept as workspace secrets. Create one with POST https://api.elevenlabs.io/v1/convai/secrets and the body {"type": "new", "name": "mnemoverse-key", "value": "Bearer mk_live_YOUR_KEY"}; the response carries a secret_id. Then create the server with POST https://api.elevenlabs.io/v1/convai/mcp-servers (both requests carry your ElevenLabs key in the xi-api-key header):

{
  "config": {
    "name": "Mnemoverse",
    "url": "https://mcp.mnemoverse.com/mcp",
    "transport": "STREAMABLE_HTTP",
    "secret_token": { "secret_id": "YOUR_SECRET_ID" }
  }
}

Keep "transport": "STREAMABLE_HTTP": the API's default is SSE. The reference describes secret_token as the Authorization header; as in the dashboard, the pages do not say whether the Bearer prefix belongs in the secret's value. Add the id the response returns to the agent's conversation_config.agent.prompt.mcp_server_ids.

The key reads and writes the whole memory of the Mnemoverse account it was created in, and every conversation of every agent the server is attached to uses that one key, whoever is speaking. For an agent that members of the public talk to, choose Fine-Grained Tool Approval for the server and disable the tools that change data (memory_write, memory_feedback, memory_create_room, memory_invite_to_room, memory_join_room), or attach the memory only to agents your own team uses. This entry has not been run from ElevenLabs.

Source: the ElevenLabs Model Context Protocol page, read 2026-10-26: "MCP is disabled by default for every workspace", "one member of the workspace must opt in on the workspace's behalf", "You can enable or disable MCP for the workspace directly by updating the can_use_mcp_servers workspace setting", "click Add Custom MCP Server", "Secret Token (optional): Authorization header value", "Click Add Integration to save the integration and test the connection to list available tools", "MCP support is not currently available for users on Zero Retention Mode or those requiring HIPAA compliance" and "Fine-Grained Tool Approval: Disable and pre-select tools which can run automatically and those requiring approval", with an API example that attaches a server through "agent": {"prompt": {"mcp_server_ids": [server.id]}}; the Create MCP server reference, read 2026-10-26: "transport (enum, optional, default: SSE)", "Allowed values: SSE, STREAMABLE_HTTP" and, for secret_token, "The secret token (Authorization header) stored as a workspace secret or in-place secret", with "secret_token": {"secret_id": "secret_id"} in its example response; the Create secret reference, read 2026-10-26: POST https://api.elevenlabs.io/v1/convai/secrets with "type ("new", required)", "name (string, required)" and "value (string, required)"; the API Authentication page, read 2026-10-26: "All API requests should include your API key in an xi-api-key HTTP header"; the MCP integration security page, read 2026-10-26: "use any available secret management features within the ElevenLabs platform to store these credentials securely". From host documentation, not verified live.

Dify

Dify builds AI apps and agent workflows, on Dify Cloud or self-hosted. It connects remote MCP servers over HTTP and can send custom headers with every request to a server, so Mnemoverse connects with an API key as a bearer token (with an API key). The steps follow Dify Cloud and self-hosted Dify 1.15.0 or later, where MCP servers are under Integrations. In earlier versions, such as 1.14.0, they are on the Tools page in the top bar. Versions before 1.9.0 have no Headers field and cannot send the key. In Dify 1.19.0 the Add MCP Server (HTTP) button shows only to members allowed to manage MCP servers, which by default are the workspace owner and admins.

1. Create a key for Dify alone on console.mnemoverse.com and copy it: it is shown only once.
2. In Dify, open Integrations, choose MCP in the sidebar and click Add MCP Server (HTTP).
3. Enter https://mcp.mnemoverse.com/mcp as Server URL, Mnemoverse under Name & Icon and mnemoverse as Server Identifier (apps refer to the server by this identifier, so keep it).
4. The dialog opens on the Authentication tab. Switch to the Headers tab, click Add Header and enter Authorization as Header Name and Bearer mk_live_YOUR_KEY as Header Value.
5. Click Add & Authorize. Dify connects with the header and imports the memory tools.
6. Use the tools in an app: as Tool nodes or inside an Agent node of a workflow or chatflow, or in an Agent app. A legacy Agent app on Dify Cloud stops offering new tools once it has 10, and the memory server has 11, so add the ones the agent needs.

Set the header before you click Add & Authorize, because Dify connects as soon as the server is added. In Dify 1.19.0 the connection uses the headers when they are present. Dify starts its own sign-in only when the server answers that the request is not authorized. That sign-in returns to the console address of the Dify installation (cloud.dify.ai on Dify Cloud), and the Mnemoverse sign-in accepts callbacks only on listed hosts and on loopback addresses. So if Add & Authorize opens a sign-in page, or ends in an error about registering an OAuth client, instead of listing the tools, Mnemoverse did not accept the key. Check that Header Value is Bearer, one space, then the key. Dify's documentation names no plan for MCP servers.

The key reads and writes the whole memory of the Mnemoverse account it was created in, and every app in the workspace that uses the server uses that one key, whoever is talking to the app. For an app that members of the public use, do not add the tools that change data (memory_write, memory_feedback, memory_create_room, memory_invite_to_room, memory_join_room). The tools that read can still return anything stored in that account to whoever is talking, so attach the memory only to apps whose users may see it. This entry has not been run from Dify.

Source: Dify Tools, read 2026-11-04: "Manage all your tools from Integrations > Tools.", "Only MCP servers with HTTP transport are supported.", "Add a server by providing its URL, a name, and a unique server identifier. Dify connects, authorizes if needed, and imports the server's tools so your apps can call them.", "Apps reference a server by its identifier." and "Send additional HTTP headers with every request to the server. Commonly used for servers that authenticate with a static token or API key (e.g., Authorization: Bearer <token>) rather than OAuth, but applicable whenever the server expects custom headers.", and it names "Workflow / Chatflow apps, as standalone Tool nodes or within Agent nodes" among the places that use tools; the same text on the self-hosted Dify Tools page, read 2026-11-04; the interface labels from the Dify repository at release 1.19.0, read 2026-11-04: tools.json: "Add MCP Server (HTTP)", "Server URL", "Name & Icon", "Server Identifier", "Authentication", "Headers", "Add Header", "Header Name", "e.g., Authorization", "Header Value", "e.g., Bearer token123" and "Add & Authorize", and navigation.json: "Integrations"; who may add a server, the sidebar entry MCP, the tab the dialog opens on, when the sign-in starts and the tool cap of a legacy Agent app are from the Dify source at release 1.19.0 (the limit also appears as data-max-tools-num="10" on cloud.dify.ai, read 2026-11-04), and the versions that have Integrations and Headers are from the source at releases 1.8.0, 1.9.0, 1.14.0 and 1.15.0, read 2026-11-04. From host documentation, not verified live.

Relevance AI

Relevance AI is a platform for building AI agents for sales, customer success, marketing and HR teams. An agent can use the tools of a remote MCP server over Streamable HTTP, and the connection dialog's Authentication menu offers Custom headers, so Mnemoverse connects with an API key as a bearer token (with an API key).

1. Create a key for Relevance AI alone on console.mnemoverse.com and copy it: it is shown only once.
2. Open the agent and go to the Tools tab in the agent builder. Click Add MCP, then Connect my own.
3. Enter https://mcp.mnemoverse.com/mcp as the URL and Mnemoverse as the label; tool descriptions show it as (MCP: Mnemoverse).
4. In Authentication, choose Custom headers and add one header: Authorization with the value Bearer mk_live_YOUR_KEY, typed in directly rather than through the secrets template the dialog suggests; once saved, the dialog shows it only as "Encrypted for protection - cannot be viewed." The authentication type cannot be changed after the connection is created.
5. Choose the connection mode. The dialog starts on Per-user connection, which asks each person who runs the agent to connect their own credentials first, so each of them needs their own Mnemoverse key; Shared connection uses this one key for everyone who runs the agent.
6. Click Connect. The Mnemoverse card on the Tools tab lists the memory tools under Available tools. If it shows No tools available, check the header first: the name is Authorization and the value is Bearer , a space and the whole key. To correct it, remove the server with Remove from Agent and connect it again.

Choose Custom headers rather than Access token / API key, whose header the dialog does not name, and rather than OAuth: Relevance AI completes that sign-in on its own hosts (the app's return address is https://app.relevanceai.com/oauth-complete/...), and no Relevance AI host is on the Mnemoverse sign-in's listed hosts. Do not put the key under Advanced Options → Custom Configuration Headers: the dialog says those are configuration headers, not authentication headers. Relevance AI's pricing and plan pages do not mention MCP. On Enterprise organizations with role-based access, the Viewer and Chat project roles cannot create or edit agents, so they cannot add the server.

With a shared connection, every run of the agent uses one key, whoever is talking to it, and that key reads and writes the whole memory of its Mnemoverse account. The tools that change data are memory_write, memory_feedback, memory_create_room, memory_invite_to_room and memory_join_room; the rest only read, and they can return anything stored in that account to whoever is talking. If the Mnemoverse card offers Don't allow next to each tool under Available tools, choose it for those five; if it does not, the agent gets every tool the server lists, so use a shared connection only in agents whose users may read and change that memory. This entry has not been run from Relevance AI.

Source: MCP client, read 2026-11-04: "Navigate to the Tools tab in the Agent builder.", "Click Add MCP.", "Custom connection: Click Connect my own, add the server URL, label the connection, and enter any required authentication details.", "The connection label you provide will appear in Tool descriptions as (MCP: connection-name).", "Once connected, the Agent automatically fetches and displays the available Tools from the MCP server.", "Ensure the external MCP server supports the Streamable HTTP transport" and "Check that any required authentication credentials are entered correctly"; Pricing and Plans and credits, read 2026-11-04, which do not mention MCP; Role-based access controls (RBAC), read 2026-11-04, for the roles that cannot create assets; the Authentication options (None, Access token / API key, Custom headers, OAuth), the connection modes and the default Per-user connection, the note that the authentication type cannot be changed after creation, the note that the advanced configuration headers are not authentication headers, the OAuth return address, No tools available, Remove from Agent and the per-tool choices Always allow, Ask every time and Don't allow (shown only on some accounts) are from the interface of app.relevanceai.com as served on 2026-11-04. From host documentation, not verified live.

Lindy

Lindy is an AI assistant that works across a team's connected tools, privately for each person and as a shared teammate in Slack. It connects hosted MCP servers over a public HTTPS Streamable HTTP endpoint, and a server with a static credential can receive it as an Authorization bearer token, so Mnemoverse connects with an API key (with an API key). Lindy's pricing page lists MCP support under "Everything included right out of the box", and MCP is not among the things Lindy's billing page says depend on the plan.

1. Create a key for Lindy alone on console.mnemoverse.com and copy it: it is shown only once.
2. In Lindy, open Integrations in the left sidebar, click + Add and choose MCP.
3. In Connect MCP server, enter https://mcp.mnemoverse.com/mcp as Server URL and Mnemoverse Memory as Display name.
4. Open Advanced, leave Send as on Authorization header (Bearer) and paste mk_live_YOUR_KEY into Bearer token.
5. Click Connect. The server appears with its host and two tool counts; the count of tools available in Lindy should not be zero.

The field label suggests that Lindy adds the Bearer prefix itself, so paste the key alone; Lindy's page does not write out the header it sends. The Mnemoverse server checks the key before it answers, so if Connect fails or starts a sign-in instead of listing the server, the key did not arrive in a form Mnemoverse accepts: copy the whole key again, and if that does not help, enter Bearer mk_live_YOUR_KEY in Bearer token. Lindy's page does not name the callback of its own sign-in, and the Mnemoverse sign-in accepts callbacks only on listed hosts, so use the key.

Every new connection starts as Only you; setting Availability to Your workspace shares it with everyone in the workspace and with Lindy Teammate, Guardrails decide whether Lindy asks before it uses the server, and Actions lists every tool with a toggle, all on at first. The key reads and writes the whole memory of its Mnemoverse account, and Lindy's Integrations page says a shared connection acts as the account that connected it, so everyone the connection is shared with uses that one key. Lindy's MCP page says workspace admins "cannot grant it or reconnect the credential on your behalf", so the person who connected the server is the one who shares it. Before you share it, turn off under Actions the tools that change data (memory_write, memory_feedback, memory_create_room, memory_invite_to_room, memory_join_room) unless every member should change the memory; the tools that read can still return anything stored in that account to whoever asks Lindy. Do not count on Guardrails for this: Lindy's Integrations page says reads are never guarded and guardrails apply in shared Slack threads only. Give Lindy its own key, so revoking it in the console stops only this connection. This entry has not been run from Lindy.

Source: MCP servers, read 2026-11-04: "Lindy connects to hosted servers that expose a public HTTPS streamable-HTTP endpoint.", "Go to Integrations, click + Add, and choose MCP.", "In Connect MCP server, paste the Server URL and set a Display name.", "If yours authenticates with a static credential instead, open Advanced and send it as an Authorization bearer token, a custom header, or a query parameter.", "Click Connect. The server appears in your list with its host and its tool counts.", "Lindy shows two numbers: the tools the server reports, and the tools available in Lindy.", "Every new connection starts here.", "Everyone in the workspace, and Lindy Teammate", "cannot grant it or reconnect the credential on your behalf", "Guardrails decide whether Lindy asks before it uses the server." and "They all arrive on."; the labels Send as, Authorization header (Bearer) and Bearer token are from the video embedded on that page and from the page's own text, both of 2026-08-21 (page history); Integrations, read 2026-11-04: "everyone's Lindy reads that tool as that account and acts with its permissions", "Reads are never guarded." and "Guardrails apply in shared Slack threads only."; Set up Lindy, read 2026-11-04: "open Integrations in the left sidebar"; What is Lindy?, read 2026-11-04: "It acts as a personal executive assistant for you and a shared teammate for your team."; Pricing, read 2026-11-04: "Everything included right out of the box." and "MCP support, connect any tool"; Billing, read 2026-11-04: "A few things depend on your plan". From host documentation, not verified live.

Gumloop

Gumloop builds AI agents and workflows. Any user can add a remote MCP server over Streamable HTTP or SSE and give the connection an Authorization header, so Mnemoverse connects with an API key as a bearer token (with an API key). Gumloop's help lists custom MCP servers on any plan.

1. Create a key for Gumloop alone on console.mnemoverse.com and copy it: it is shown only once.
2. In Gumloop, select Customize in the left sidebar, open the Connectors tab and click Add Custom MCP. For a connection your team shares, open the team from Teams in the left sidebar and choose Customize in the team's menu instead: the dialog has no separate choice between personal and team. Gumloop's help says team connectors are added by team owners and members with permission to manage them.
3. In Connect MCP Server, enter https://mcp.mnemoverse.com/mcp as MCP Server URL and click Connect.
4. On Configure, keep the Server Name or enter Mnemoverse. Detected Auth should read OAuth 2.0, because this server publishes its OAuth metadata. Do not click Authenticate: open the Authentication dropdown and choose API Key / Credentials.
5. Under Headers, click Add Header, enter Authorization as the name and Bearer mk_live_YOUR_KEY as the value, and click Connect. Gumloop connects with the header and discovers the memory tools.
6. Open your agent, click + Add in the Connectors section, search for the server, click + next to it and click Save. Then ask the agent to list its tools.

The header value carries the word Bearer itself: the Headers editor sends a header as you type it. If your dialog shows an Access Token / API Key field instead of Headers, paste the key there without Bearer: Gumloop's Custom MCP servers page says that field is sent as Authorization: Bearer. If Gumloop says it could not load the tools, type the header again by hand, because spaces, line breaks or curly quotes from copy and paste break it, and check that the key has not been revoked. Do not send the key as X-Api-Key or as a query parameter: the hosted server reads a key only from Authorization: Bearer. If Gumloop says the server is already connected in your organization, continue: your connection joins the existing server and keeps its name, so search for that name in step 6. With GPT and Claude models the model provider, not Gumloop, connects to the server with the key. Gumloop's page says Claude models receive the bearer token but do not forward custom headers, and it does not say which of the two a header added under Headers counts as; if the tools load but the agent's memory calls fail on a Claude model, switch the agent to a GPT or Gemini model. Gumloop's sign-in returns to https://api.gumloop.com/auth/callback or https://api.gumstack.com/auth/callback, and neither host is on the Mnemoverse sign-in's listed hosts, so Authenticate would fail.

By default a shared Gumloop agent runs the connectors of whoever uses it: a server you add on your own Connectors page is yours alone, and a teammate who runs the agent adds the server with a key of their own. One key serves many people in three cases: a team connector, which everyone who runs the team's agents uses; a connector set to Agent-owned on the agent, which everyone who can access the agent uses, including people it is shared with; and a Slack channel trigger, which runs the trigger owner's connection for the whole channel. The key reads and writes the whole memory of its Mnemoverse account, and by default Gumloop asks for no approval before a tool runs. For an agent that other people use through one key, open the connector on the agent and turn off the tools that change data (memory_write, memory_feedback, memory_create_room, memory_invite_to_room, memory_join_room); the tools that read can still return anything stored in that account to whoever is talking to the agent. In an organization, an admin's custom roles decide which connectors each group of members can use, and Agent-owned stays disabled until an admin grants it. This entry has not been run from Gumloop.

Source: Custom MCP servers, read 2026-11-04: "Select Customize in the left sidebar, then the Connectors tab.", "Click Add Custom MCP in the top-right corner of the page. The Connect MCP Server dialog opens.", "Enter your server's address in MCP Server URL, then click Connect.", "Gumloop probes the server and shows the Detected Auth method. If the server supports OAuth, click Authenticate and sign in to connect your account. Otherwise, open the Authentication dropdown to supply a token, API key, or custom header instead.", "When you provide an Access Token / API Key, Gumloop sends it as an Authorization: Bearer <token> header with every request to your MCP server.", "Streamable HTTP or Server-Sent Events (SSE)", "Native MCP: The provider (OpenAI/Anthropic) connects directly to your MCP server and executes tools.", "Anthropic models don't forward custom headers.", "There are no approval prompts before tool execution.", "Open your agent and click + Add in the Connectors section." and "to verify the connection is working before relying on it."; Why won't my custom MCP server connect?, read 2026-11-04: "https://api.gumloop.com/auth/callback", "https://api.gumstack.com/auth/callback", "Someone in your org already added that URL. Your connection joins the existing server and keeps its name." and "Trailing spaces, line breaks, or curly quotes from copy and paste break the header."; Custom, proxied, and hosted MCP, read 2026-11-04: "Any user" under "Who sets it up", "Any" under "Plan", and for a custom MCP "That teammate's own copy" and "The shared team connection"; Connectors, read 2026-11-04: "When you explicitly set a connector to Agent-owned, everyone who can access the agent uses the pinned accounts when tools are called, including people you share it with." and "For organizations, agent-owned credentials are restricted by default."; Add team connectors, read 2026-11-04: "In the team's menu, select Customize. The Connectors tab opens." and "Team owners and members with permission to manage team connectors."; Roll out an agent, read 2026-11-04: "The trigger owner (one shared connection)"; Give an agent a connector, read 2026-11-04: "Open the connector on the agent and turn off tools you don't want"; the documentation index, read 2026-11-04, on custom roles: "Control which connectors, tools, and AI models each group of members can access."; the labels Server Name, API Key / Credentials, Headers, Add Header and the Connect button of the Configure step are from the Connect MCP Server dialog of www.gumloop.com as served on 2026-11-04. From host documentation, not verified live.

Vapi

Vapi is a developer platform for voice agents. An assistant gets the tools of a remote MCP server through an MCP tool, and Vapi connects to the server over Streamable HTTP by default. The Vapi MCP page describes a server URL and custom headers for that connection, not a browser sign-in, so this connection uses a Mnemoverse API key as a bearer token. Create a key on console.mnemoverse.com and copy it: it is shown only once.

Create the MCP tool with POST https://api.vapi.ai/tool. That request carries your private Vapi API key as Authorization: Bearer; the Mnemoverse key goes in the body:

{
  "type": "mcp",
  "server": {
    "url": "https://mcp.mnemoverse.com/mcp",
    "headers": { "Authorization": "Bearer mk_live_YOUR_KEY" }
  }
}

Leave metadata.protocol unset: its default, shttp, is Streamable HTTP. Then open Dashboard > Assistants, select the assistant, go to the Tools tab, select the new MCP tool and click Publish. For the MCP tool form in the Dashboard (Dashboard > Tools > Create Tool > MCP), the Vapi MCP page names a name, a description and the Server URL field, and no header field, so this entry sets the key through the API. The same page also shows the server object with headers inline in an MCP entry of an assistant's model.tools.

The key reads and writes the whole memory of the Mnemoverse account it was created in, and every call to every assistant with this tool uses that one key, whoever is on the line. Vapi imports every tool the server exposes and does not filter them per tool, so the tools that change data (memory_write, memory_feedback, memory_create_room, memory_invite_to_room, memory_join_room) come with the rest. Add the tool only to assistants whose callers may read and change that memory. This entry has not been run from Vapi.

Source: the Vapi MCP tools page, read 2026-10-26: "Select MCP from the available options", "Provide a name and description", "Server URL: The URL of your MCP server", "In an API request, configure the same value as server.url", "server.headers: Custom headers to include in requests to the MCP server", with "Authorization": "Bearer your-token" in its example, ""shttp" (default): Uses Streamable HTTP protocol", "Go to the Tools tab", "Click Publish to save your changes" and "Vapi imports the complete tool list exposed by the configured server and does not apply its own per-tool filter"; the Create Tool reference, read 2026-10-26: "POST https://api.vapi.ai/tool", "send it in the Authorization header as Bearer <token>" and, for the server object of a tool, "Configuration for requests Vapi sends to a customer server, including URL, authentication, headers" and "These are the headers to include in the request". From host documentation, not verified live.

Microsoft Copilot Studio

Microsoft Copilot Studio builds agents for Microsoft 365 and other channels. An agent maker adds a remote MCP server through the MCP onboarding wizard, over Streamable HTTP, and the wizard's API key authentication sends the key in a header whose name the maker types, so Mnemoverse connects with an API key as a bearer token (with an API key). MCP needs generative orchestration, which the Teams plan does not have; a trial license can build and test an agent but not publish it.

The steps below are for an agent on Copilot Studio's standard harness, which Microsoft's MCP onboarding pages describe. On the Copilot Studio home page, Other ways to build creates a standard-harness agent, and Open classic experience, under the three dots (…) at the bottom of the side bar, opens existing ones. An agent cannot be moved from one harness to the other. In an agent on the GitHub Copilot harness, MCP servers are added in preview from the Add a tool dialog: Add next to the search bar, then Model Context Protocol (MCP). Microsoft's page for that path does not list its authentication options, so it is not documented whether it can send the key in an Authorization header.

1. Create a key on console.mnemoverse.com and copy it: it is shown only once. With the default credentials of the person using the agent, each user creates a key of their own (see below); with Maker-provided credentials, create a key for this agent alone.
2. In Copilot Studio, open the agent, go to the Tools page and select Add a tool, then New tool. In the Create new section, select Model Context Protocol.
3. In the wizard, enter Mnemoverse Memory as Server name, a short description of the memory tools as Server description (the orchestrator reads it to decide when to call the server) and https://mcp.mnemoverse.com/mcp as Server URL.
4. Select API key as the authentication type, Header as the type of API key and enter Authorization as the name of the header. Select Create.
5. In the Add tool dialog, select Create a new connection, enter Bearer mk_live_YOUR_KEY as the API key (the word Bearer, one space, then the key), create the connection, and then select Add to agent.

Copilot Studio turns all of the server's tools on. To switch single tools off, select the server on the agent's Tools tab and turn off Allow all: each tool then gets its own toggle, and tools the server adds later stay off until someone turns them on. The server becomes a Power Platform custom connector in the environment, so a data policy that blocks Power Platform connectors blocks it too. The Copilot Studio MCP page does not say that the key value is sent as typed. The Bearer prefix in the value follows the Power Platform custom connector documentation, and the Copilot Studio guides of two other MCP servers, Ahrefs and DataHub, give the same Authorization header with Bearer typed before the key. The hosted server accepts a key only as a bearer token, so this route works only if the wizard sends the value in that form. It has not been run from Copilot Studio.

Choose API key rather than OAuth 2.0: Copilot Studio's sign-in returns to a consent.azure-apim.net host, and the Mnemoverse sign-in accepts callbacks only on listed hosts. By default a tool runs with the credentials of the person using the agent. Each user of the agent is asked for a key of their own the first time the agent calls the server, enters it the same way (Bearer mk_live_…), and works with the memory of the account that key belongs to. Copilot Studio asks a user for their own credentials only on channels that support user authentication for tools; its list includes Teams, SharePoint and a custom website, and leaves out the demo website and the mobile app, and in Teams it needs single sign-on set up, or authentication fails for every user. If the maker sets Credentials to use to Maker-provided credentials on the server's page, everyone who uses the agent works with the maker's key, and a key reads and writes the whole memory of the Mnemoverse account it was created in. For an agent shared that way, turn off the tools that change data (memory_write, memory_feedback, memory_create_room, memory_invite_to_room, memory_join_room), or attach the memory only to agents your own team uses. Revoking a key in the console stops only the connections that use it.

Source: Connect your agent to an existing Model Context Protocol (MCP) server, read 2026-11-04: "This article describes features used in agents or agent flows powered by the standard harness.", "Currently, Copilot Studio supports the Streamable transport type.", "Go to the Tools page for your agent.", "Select Add a tool.", "Select New tool.", "In the Create new section, select Model Context Protocol. The MCP onboarding wizard appears.", "Fill in the required fields Server name, Server description, and Server URL. Write a brief, but clear description of what your MCP server does. The agent orchestrator uses this information to identify whether to call your server at runtime.", "Select API key as the authentication type. More fields appear for you to configure the API key.", "Header: Select this option if your MCP server requires the API key to be sent in the request header.", "Enter the name of the header or query parameter where the API key should be included.", "The user of the agent provides the API key, and the agent includes it in the requests to the MCP server.", "Select Create. The Add tool dialog appears.", "On Add tool, select Create a new connection for your MCP server or use an existing one.", "Select Add to agent to finish adding the MCP server to your agent.", "To edit your MCP connector or add custom parameters:" and "Go to the Power Apps or Power Automate portal and select Custom connectors."; Add tools and resources from a Model Context Protocol (MCP) server to your agent, read 2026-11-04: "All tools are turned on by default when you add an MCP server. The Allow all toggle is turned on.", "Turn off the Allow all toggle. Toggles become available for each of the individual tools." and "When you turn off Allow all, any new tools added to the MCP server are turned off by default."; Extend your agent with Model Context Protocol, read 2026-11-04: "You must turn on generative orchestration to use MCP."; Access standard harness agents and agent flows, read 2026-11-04: "On the home page, select the three dots (…) at the bottom of the side bar, and then select Open classic experience." and "To create new agents and agent flows powered by the standard harness, select Other ways to build on the home page."; GitHub Copilot harness overview, read 2026-11-05: "can't be transferred to the standard harness, and vice versa"; Add a Model Context Protocol (MCP) server to your agent as a tool (GitHub Copilot) (preview), read 2026-11-04: "In the Add a tool dialog, select Add next to the search bar, and then select Model Context Protocol (MCP)." and "Authentication: choose the authentication method the server requires, and enter the credentials or configuration values that method needs."; Use connectors in Copilot Studio agents, read 2026-11-04: "By default, connectors ask users (users of your agent) to enter their credentials for the associated service when they use the tool." and "Under Details > Additional details > Credentials to use, select Maker-provided credentials."; Configure user authentication for tools, read 2026-11-04, its channel table: Demo Website and Mobile App "Not supported", and for Teams "authentication always fails for users in Teams"; Create a custom connector from scratch, read 2026-11-04: "For APIs that require bearer authentication, add Bearer and one space before the API key."; Configure data policies for agents, read 2026-11-04: "Blocking Power Platform connectors also blocks access to tools in connected MCP servers, which rely on Power Platform connectors for connectivity."; Get access to Copilot Studio, read 2026-11-04: "The trial license gives you access to Copilot Studio to create agents. You can test your agents using the test chat panel. However, you can't publish the agent." and, for the Teams plan, generative orchestration "Not available"; the callback host of the OAuth sign-in from Authenticate your API and connector with Microsoft Entra ID, read 2026-11-04: "https://global.consent.azure-apim.net/redirect/samplecustomconnector123-5f98284236d845b802-5f21c6202f06d65e16", and from two Microsoft Q&A posts by users of the MCP onboarding wizard, 2026-09-22: "redirect_uri=https://global.consent.azure-apim.net/redirect/" and 2026-10-01: "Redirect URI: global.consent.azure-apim.net/redirect/", both read 2026-11-04; the Copilot Studio guides of Ahrefs, read 2026-11-04: "Header name: Authorization" and "Paste the key into Copilot, making sure to add the Bearer prefix: Bearer YOUR_API_KEY.", and DataHub, read 2026-11-04: "Include the Bearer prefix in the API key value." From host documentation, not verified live.

Zapier Agents

Zapier Agents runs AI agents that use Zapier's app actions as tools. A remote MCP server joins Zapier as a connection of the MCP Client app, which Zapier's help describes as a beta feature, and the connection form has a Bearer Token field, so Mnemoverse connects with an API key (with an API key). Zapier Agents is an add-on with its own activity limits, and Zapier is moving Agents into the AI by Zapier step of the Zap editor, with no date set for turning Agents off; tools in that step need a paid Zapier plan. On a Zapier Enterprise account created on or after 2026-10-05, members can use only apps an admin has allowed, so an admin may first have to allow MCP Client.

1. Create a key for Zapier alone on console.mnemoverse.com and copy it: it is shown only once.
2. In Zapier, open the Apps page, click + Add connection, search for and select MCP Client, and click Add connection.
3. On the Connect an Account page, enter https://mcp.mnemoverse.com/mcp as Server URL, choose Streamable HTTP as Transport, set OAuth to No and enter mk_live_YOUR_KEY in Bearer Token. Click Yes, Continue to MCP Client, then rename the connection so that it includes Mnemoverse.
4. In Zapier Agents, open the agent. Under Tools this agent can use, click + Add Tool, search for and select MCP Client, and select Run tool. Then select the added action under Tools this agent can use, pick the Mnemoverse connection from the dropdown, choose Let your agent select a value for this field for Tool, and click Save.

Zapier's help does not name the header that the Bearer Token field fills or say whether Zapier adds the Bearer prefix itself, and the hosted server accepts a key only as Authorization: Bearer, so enter the key alone first, without Bearer. If Zapier asks you to reconnect right after Yes, Continue to MCP Client, or the Tool field of Run tool lists no memory tools, reconnect with the value Bearer mk_live_YOUR_KEY. Choose OAuth: No: with Yes, Zapier ignores the token; the callback host of Zapier's sign-in is not named in its documentation, and no Zapier host is on the Mnemoverse sign-in's listed hosts. Every run of every agent that uses the connection uses that one key, which reads and writes the whole memory of its Mnemoverse account; give the connection its own key, so revoking it in the console stops only Zapier. The tools that change data are memory_write, memory_feedback, memory_create_room, memory_invite_to_room and memory_join_room; for an agent that should only recall, set Tool to a reading tool such as memory_read instead of leaving it to the agent. In the AI by Zapier step, the same connection is added under Settings, Tools and Knowledge, with + Add tool: tool type App action, app MCP Client, action Run tool and the Mnemoverse connection as Account; tools work only with an Advanced or Premium model. Zapier's help does not say how a tool's own fields, such as the text to save, reach the server when Tool is left to the agent; if the agent cannot fill them, add Run tool once for each memory tool it needs, with that tool set as the value of Tool. This entry has not been run from Zapier.

Source: Connect remote MCP servers to Zapier using MCP Client, read 2026-11-04: "MCP Client is a beta feature. It’s available for use, but still in active development and may change.", "Go to the Apps page.", "Click + Add connection.", "Search for and select MCP Client.", "Click Add connection.", "Server URL: Enter the server URL.", "Transport: Select which transport your client supports: Streamable HTTP SSE", "OAuth: Select if the remote MCP server requires OAuth connection or not.", "the Bearer Token field will be ignored.", "(Optional) Bearer Token: Enter the bearer token, if required for authentication.", "Click Yes, Continue to MCP Client.", "If the account name does not include the server name, you should rename it now.", "If you connect to a remote MCP server but are immediately asked to reconnect, check the following:" and "MCP Client only supports connecting to remote MCP servers that use either Streamable HTTP and SSE for their transport methods."; Use actions on Zapier Agents, read 2026-11-04: "In the section Tools this agent can use, click + Add Tool.", "The agent will add this action and select the best option for required fields.", "From the section Tools this agent can use, select an action.", "Select a connection from the dropdown menu, or create a new connection by clicking the Settings icon", "Let your agent select a value for this field. The agent will automatically determine the best value to use based on what the task requires." and "Every time an action runs, it consumes one activity from your activity limit."; How is Zapier Agents usage measured?, read 2026-11-04: "Zapier Agents is billed as an add-on to your Zapier account."; Migrating from Agents to AI by Zapier, read 2026-11-04: "Zapier is migrating Agents (agents.zapier.com) to AI by Zapier, a more powerful AI experience built directly into the Zap editor." and "Zapier has not set a date to turn off Agents yet."; Add tools to your AI by Zapier step, read 2026-11-04: "Under Settings, expand the Tools and Knowledge section", "In the Tools and Knowledge section, click + Add tool.", "App action: Use any Zapier app and action as a tool", "In the Account field, select the connected account to use.", "Tool calls and knowledge sources are only available when you connect an Advanced or Premium model." and "On a Free plan, you cannot add tools or publish a Zap with an AI by Zapier step."; App access policies in Zapier, read 2026-11-04: "Enterprise accounts created on or after October 5, 2026 use the allowed apps setting"; the labels Run tool and Tool from the action data of the MCP Client by Zapier app page, read 2026-11-04 (the help article writes the action with a capital T). The help pages name neither the header behind the Bearer Token field nor the callback of the OAuth option. From host documentation, not verified live.

Voiceflow

Voiceflow is a platform for building customer-facing agents. It connects hosted MCP servers only, through an Add MCP server dialog with a server name, a URL and headers, and a header value can reference a project secret, so Mnemoverse connects with an API key as a bearer token (with an API key) kept in a secret.

1. Create a key for Voiceflow alone on console.mnemoverse.com and copy it: it is shown only once.
2. In the agent, open Secrets, click New secret, name it mnemoverse_api_key, paste the key as its value and choose the Restricted visibility. A secret created in one environment has no value in the others until you set it there.
3. Open the Agent tab, find Global tools in the right editor and click +, then choose to add an MCP server. Global tools are used where the agent decides on its own (the agent, its playbooks and crews); a scripted workflow step reaches the memory only through its own MCP step. You can also add the server from a playbook's tools or from a workflow's MCP step; Voiceflow's documentation says servers can be managed centrally in Settings → MCP servers.
4. Enter Mnemoverse as Server name and https://mcp.mnemoverse.com/mcp as Server URL. Click + next to Headers and add one header with the key Authorization and the value Bearer {mnemoverse_api_key}: after Bearer , type {, switch to the Secrets tab of the dropdown and select mnemoverse_api_key.
5. Click Add MCP server. Voiceflow fetches the memory tools; select the ones the agent should have, and refresh the server later to pick up new ones.

A secret that has no value in the current environment is sent as its placeholder text, which the server refuses with 401 and the agent continues without a warning, so set the value in every environment the agent runs in. Voiceflow's documentation does not name the transport of a custom server (the specification field of its MCP server API offers the 2025-03-26 and 2025-06-18 revisions of the protocol) and does not say which plans include MCP tools. Every conversation of every agent with this server uses that one key, which reads and writes the whole memory of its Mnemoverse account; for an agent that members of the public talk to, do not select the tools that change data (memory_write, memory_feedback, memory_create_room, memory_invite_to_room, memory_join_room), and remember that the tools that read can still return anything stored in that account to whoever is talking; or attach the memory only to agents your own team uses. This entry has not been run from Voiceflow.

Source: MCP tool, read 2026-11-04: "Voiceflow supports hosted MCP servers accessible from the internet. Local MCP servers are not supported.", "You can also add MCP servers from within a workflow using the MCP step", "Servers can be managed centrally in Settings → MCP servers.", "Optional key-value pairs for authentication (API keys, tokens)" (for Headers) and "Once connected, Voiceflow fetches the available tools from your server. Select the ones you want your agent to have access to - you don't have to enable all of them and can refresh the server when you choose to access new tools."; Global tools, read 2026-11-04: "Open the Agent tab and find the Global tools section in the right editor. Click the + to open the tool configuration panel" and "Global tools are only available when your agent is in an agentic context"; Secrets, read 2026-11-04: "Open Secrets in your agent's navigation and click New secret in the top right.", "Restricted secrets cannot be revealed after creation.", "In any input field within a tool, type { to open the dropdown, then switch to the Secrets tab and select the secret you need." and "a header entered as Bearer {my_api_key} goes out as Bearer {my_api_key}. The service you're calling rejects it, usually with a 401, the step takes its failure path, and the conversation continues. Nothing warns you at run time"; Create MCP server, read 2026-11-04: "The URL and header values are plain strings that can reference a project secret as {secret_name}" and, for a header's key, "The name of the HTTP header sent to the MCP server.", and for specification, "McpServerSpecification: type: string enum: - 2025-03-26 - 2025-06-18"; the button label Add MCP server is from the dialog screenshot on the MCP tool page. From host documentation, not verified live.

Retell AI

Retell AI voice and chat agents can call the tools of a remote MCP server during a live conversation. Retell authenticates to an MCP server only with the headers and query parameters you set and runs no OAuth sign-in, so this connection uses a Mnemoverse API key as a bearer token. Create a key on console.mnemoverse.com and copy it: it is shown only once.

In a single or multi-prompt agent, open the MCPs section and click Add MCP. Enter mnemoverse as the name and https://mcp.mnemoverse.com/mcp as the URL. Under Headers, click New key value pair and add the key Authorization with the value Bearer mk_live_YOUR_KEY. Click Save. On the saved server, click Add Tools, pick a tool in Select Tool and save it; repeat this for each tool the agent should have, because only the tools added here reach the agent. Then say in the agent's prompt when it should call each tool.

In a conversation flow agent, add the MCP server first, with the same URL and Authorization header, and then create an MCP node and select the tool it calls; each MCP node calls one tool of the server at its place in the flow.

With the API. The same entry goes in the mcps list of a Retell LLM (create-retell-llm, update-retell-llm) or of a conversation flow (create-conversation-flow, update-conversation-flow):

{
  "mcps": [
    {
      "name": "mnemoverse",
      "url": "https://mcp.mnemoverse.com/mcp",
      "headers": { "Authorization": "Bearer mk_live_YOUR_KEY" }
    }
  ]
}

This entry connects the server only. The tools are separate entries: an MCP tool of a Retell LLM is a tool of type mcp with an mcp_id, and an MCP node of a flow names an mcp_id and an mcp_tool_name. The reference does not say which mcp_id value points to an entry of mcps, so this page does not cover adding the tools through the API.

These requests themselves carry your Retell API key in their own Authorization header; the Mnemoverse key goes only inside headers of the entry.

The key reads and writes the whole memory of the Mnemoverse account it was created in, and every call of every agent that has the server uses that one key, whoever is on the line. For an agent that members of the public call, do not add the tools that change data (memory_write, memory_feedback, memory_create_room, memory_invite_to_room, memory_join_room), or attach the memory only to agents your own team uses. Retell passes at most 15,000 characters of a tool's response to the model by default. This entry has not been run from Retell.

Source: the Retell MCP tools for single and multi-prompt agents page, read 2026-10-26: "during a live voice or chat conversation", "In your agent, open the MCPs section and click Add MCP.", "enter a name for the server and its URL", "Under Headers, add the key/value pairs Retell sends with the MCP connection request", "Click New key value pair for each header.", "On the saved server, click Add Tools.", "open the Select Tool dropdown and pick a tool", "Only the tools you add here are exposed to the agent.", "In your prompt, say explicitly when the agent should call each tool", "Retell connects over Streamable HTTP.", "it doesn't run an interactive OAuth authorization flow", "caps it at 15,000 characters by default" and "The server configuration (URL, headers, query params) is the same"; the MCP node in conversation flow page, read 2026-10-26: "To create an MCP node, we first need to add an MCP server.", "Headers and query parameters are the only way Retell authenticates to your MCP server", "Retell doesn't run an interactive OAuth flow" and "Select MCP Tool"; the Create Retell LLM reference, read 2026-10-26: mcps, "A list of MCPs to use for this LLM.", for headers "Headers to add to the MCP connection request." with the example Authorization: Bearer 1234567890, for the mcp tool's mcp_id "Unique id of the MCP.", and for the API key "Authentication header containing API key (find it in dashboard)."; the Create Conversation Flow reference, read 2026-10-26: mcps, "A list of MCP server configurations to use for this conversation flow", and for the MCP node's mcp_tool_name "Name of the MCP tool to call". From host documentation, not verified live.

Manus

Manus is a general AI agent. It connects custom remote MCP servers next to its prebuilt connectors, and its page for them names API keys and bearer tokens as the credentials, so Manus connects with a Mnemoverse API key.

1. Create a key for Manus alone on console.mnemoverse.com and copy it: it is shown only once.
2. In Manus, go to Settings → Integrations → Custom MCP Servers and click Add Server.
3. Enter Mnemoverse as the server name and https://mcp.mnemoverse.com/mcp as the server URL, and give mk_live_YOUR_KEY as a bearer token under the authentication.
4. Manus checks that it can reach the server and lists its tools. Then mention the memory in a prompt, for example Using Mnemoverse, recall what we decided about the pricing page.

The Manus page does not show the authentication form or name the header that carries the credential, and the hosted server accepts a key only as a bearer token (with an API key), so this route works only if Manus sends the key in that form: where the form offers a bearer token and an API key separately, choose the bearer token. The Manus pages read for this entry do not say which plans include custom MCP servers.

Give Manus its own key: a key reads and writes the whole memory of its account, and revoking it in the console stops only this connection. This entry has not been run from Manus.

Source: Custom MCP Servers, read 2026-11-03: "navigate to Settings → Integrations → Custom MCP Servers and click Add Server", "Server name", "Server URL", "API key, Bearer token, or other credentials required", "Manus will verify it can communicate with your server and retrieve the list of available tools." and "Reference them in prompts just like prebuilt connectors." From host documentation, not verified live.

Lovable

Lovable is an AI app builder. A custom MCP server joins it as a chat connector: Lovable reads from it in the project chat and in Chats while it builds, on all plans. A chat connection is personal: only the person who connects it can use it, and it never becomes part of the published app. Connect with an API key:

1. Create a key on console.mnemoverse.com and copy it: it is shown only once.
2. Open Connectors, select Add custom in the top right of the catalog and choose MCP server. If MCP server is greyed out, a workspace admin has turned custom MCP servers off.
3. Enter Mnemoverse as the server name and https://mcp.mnemoverse.com/mcp as the server URL. If a Connection dropdown appears, keep Direct connection.
4. Choose Bearer token or API key as the authentication, enter mk_live_YOUR_KEY and click Add server.
5. Ask Lovable something the memory can answer, for example Using the Mnemoverse connector, recall what we decided about the signup flow.

Choose Bearer token or API key, not the default OAuth: Lovable's documentation does not name the callback of its sign-in, and the Mnemoverse sign-in accepts callbacks only on listed hosts. Lovable's page does not name the header that carries the key either, and the hosted server accepts a key only as a bearer token (with an API key), so this route works only if Lovable sends the key in that form.

Before a tool that the server does not mark as read-only runs, Lovable shows an approval card; Always allow skips it for that tool from then on. Give Lovable its own key: a key reads and writes the whole memory of its account, and revoking it in the console stops only this connection. This entry has not been run from Lovable.

Source: Connect a custom MCP server as a chat connector, read 2026-11-03: "Custom MCP servers are available on all plans.", "Like all chat connections, they are personal to you, and they are never part of your published app.", "select Add custom in the top right of the catalog, and choose MCP server", "If MCP server is greyed out, a workspace admin has disabled custom MCP servers for your workspace.", "Keep Direct connection unless your server is behind a firewall that only accepts traffic from allowlisted IPs.", "OAuth (default): Lovable uses OAuth by default.", "Bearer token or API key: For servers that don't support OAuth, authenticate with a bearer token or API key." and "Click Add & authorize (OAuth) or Add server."; Chat connectors, read 2026-11-03: "only you can use the connection", "Tools the server marks as read-only run without asking. Before any other tool runs, Lovable shows an approval card." and "Select Always allow to skip the approval for that tool from then on". Neither page names the header that carries the key or the callback of the OAuth sign-in. From host documentation, not verified live.

Any other MCP client

Zed, JetBrains and any client that speaks MCP (Cline has its own section, and 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 sign in, but can send a fixed header: add the remote server https://mcp.mnemoverse.com/mcp with the header Authorization: Bearer mk_live_YOUR_KEY, using an API key from console.mnemoverse.com (what the key can do).
• Runs only local (stdio) servers: add the mcp-remote bridge, a separate open-source bridge that runs through npx (Node.js 20.18.1 or later). It forwards to the same URL and opens the same browser sign-in on first start, so no key is needed. The entry goes under the key the client uses for MCP servers (Zed calls it context_servers):

{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.mnemoverse.com/mcp"]
    }
  }
}

The bridge keeps its sign-ins in ~/.mcp-auth. If a sign-in gets stuck, its README says to delete that folder and restart the client.

• No browser on the machine (a server, CI): run the local package with an API 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:

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

1. Ask the connected app to call memory_stats. A successful result confirms that this conversation can reach your memory account. If you only asked to connect, stop here; no test memory needs to be created.
2. When you want to save something, ask it to remember one real, harmless fact or contact you actually want stored. For a photo, use its readable details and the space you requested; ask about unclear text instead of filling it in. Check that the memory_write result confirms the record was stored.
3. Start a new conversation in the same app and select the connection if needed. Ask it to retrieve that fact without repeating its contents. Check that the memory_read result contains the saved details. To check another app, connect it to the same Mnemoverse account and repeat the retrieval there.

A tool list, memory count, or ordinary assistant answer alone does not prove a save or a recall. If a step fails, report that step and its actual error; do not claim it succeeded or substitute the host's built-in memory. Share neither credentials nor unrelated memories when reporting the error.

Related

• 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