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:

A plugin repository. mnemoverse/claude-plugin carries an Agent Plugins 1.0.0 manifest (plugin.json and mcp.json at the repository root), a Claude Code manifest (.claude-plugin/plugin.json and .claude-plugin/marketplace.json, with the server in .mcp.json), and a Kimi Code manifest (kimi.plugin.json). Most hosts that read one of these formats install it straight from GitHub; NanoClaw takes it from a local clone. The plugin points at the hosted server https://mcp.mnemoverse.com/mcp. On hosts that run a sign-in for a server that comes from a plugin, the sign-in is a browser flow (OAuth 2.1 with PKCE), started on first use or by the host's sign-in command, and there is no API key to paste. Hermes Agent, OpenClaw, NanoClaw and OpenHands load the plugin but run no sign-in for its server; their sections say what to do instead.
A host-native package. The Cursor plugin, the Gemini CLI extension, the VS Code extension and the Claude Desktop .mcpb bundle from the mcp-memory-server releases.
A plain MCP entry. The remote URL https://mcp.mnemoverse.com/mcp in any client that can complete a browser sign-in, or the local package npx -y @mnemoverse/mcp-memory-server@latest with an API key from console.mnemoverse.com (free tier, no credit card). 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.
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 [email protected] 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
AWS 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, Plugins → Add custom → Add MCP connector	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 under `mcp.servers` in the global configuration, with the memory scopes	browser, no key, through `/mcps` or `opencode mcp auth mnemoverse`	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 on wider screens), 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, Tools → Create Tool → MCP in the Dashboard or `POST https://api.vapi.ai/tool`, then added to the assistant	an API key as a bearer token under HTTP Headers (`server.headers`); Vapi supports 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
Glean	remote MCP server added by an admin, Admin console → Platform → Tools → Add → Import tools from MCP server	an API key, which Glean sends as `Authorization: Bearer` by default; one key for everyone the tools are published to	From host documentation, not verified live
Open WebUI	MCP connection an admin adds under Settings > Admin > Integrations, or mcpo as an OpenAPI tool server	API key as a bearer token, entered once by the admin; everyone given access shares that account's memory	From host documentation, not verified live
Visual Studio	remote MCP server from Copilot Chat in Agent mode, tools icon → + (Add custom MCP server in Visual Studio 2026), with an `Authorization` header; or the `npx` package in `%USERPROFILE%\.mcp.json`	an API key as a bearer token under Headers; or an API key with the `npx` package; Visual Studio's documentation does not name the callback of its sign-in	From host documentation, not verified live
JetBrains IDEs	Junie: remote entry in `~/.junie/mcp/mcp.json`, from Settings → Tools → Junie → MCP Settings or Junie CLI; GitHub Copilot for JetBrains: remote entry in its `mcp.json`, from Add MCP Tools in Agent mode; AI Assistant: STDIO entry for the `mcp-remote` bridge, Settings → Tools → AI Assistant → Model Context Protocol (MCP); organizations: a remote server with a header, set by an IDE Services administrator	Junie and GitHub Copilot: an API key as a bearer token in a header; AI Assistant: browser, no key, through the bridge; Junie's own Authorize has not been run with Mnemoverse, and AI Assistant's documentation describes no sign-in	From host documentation, not verified live
Zed	remote server entry under `context_servers` in the settings file, from Settings → AI → MCP Servers → `Add Server` → `Add Remote Server`	browser, no key (Zed v1.18.0 and later); or an API key as a bearer token in `headers`	From host documentation, not verified live
Raycast	Mnemoverse entry in Raycast's Model Context Protocol Registry extension (macOS), installed as a Standard Input/Output server that runs the `mcp-remote` bridge; or an HTTP server from Install MCP Server with HTTP Headers (macOS, Windows, iOS); or the `npx` package (macOS, Windows); MCP is a Raycast Pro feature	browser, no key, through the bridge; or an API key as a bearer token in HTTP Headers; or an API key with the `npx` package	From host documentation, not verified live
AnythingLLM	`streamable` entry in `plugins/anythingllm_mcp_servers.json` in the storage directory, reloaded with Refresh on Settings → Agent Skills (Desktop and self-hosted Docker, v1.8.1 and later; in multi-user mode an Admin); or the `npx` package as a stdio entry	an API key as a bearer token in `headers`; or an API key with the `npx` package; AnythingLLM's MCP client runs no sign-in	From host documentation, not verified live
Cherry Studio	remote server, Settings → MCP → MCP Servers → Add → Quick Create with type Streamable HTTP (streamableHttp), or Import from JSON; then enabled for an Agent under Work	an API key as a bearer token, one `Authorization=Bearer` line under Advanced Settings → Headers; Cherry Studio's documentation describes no browser sign-in	From host documentation, not verified live
Jan	remote server entry, Settings → MCP Servers → + Add MCP Server, transport HTTP (Jan Desktop v0.6.9 and later); or the `npx` package as a STDIO server	an API key as a bearer token in Headers; or an API key with the `npx` package; Jan's own Sign in has not been run with Mnemoverse	From host documentation, not verified live
Msty Studio	HTTP tool, Toolbox → Tools → Add New Tool (Msty Studio Desktop 3.x), then its toolset selected in the conversation; or the `npx` package as a STDIO / JSON tool	an API key through the bearer token authentication; Msty's documentation does not name the callback of its OAuth	From host documentation, not verified live
Figma	custom MCP connector in the Figma agent and Figma Make, Add context → Connectors → Manage → Created by you → Create, with custom request headers; Professional, Education, Organization and Enterprise plans	an API key as a bearer token in a custom request header; Figma's own sign-in returns to a callback that is not on the Mnemoverse sign-in allowlist	From host documentation, not verified live
Mistral Vibe Work	custom connector, Context → Connectors → New connector → Add custom connector; an administrator adds it	browser sign-in (OAuth2.1), no key; or an API key as a bearer token (API Token Authentication)	Verified live 2026-11-13 (sign-in: connection Valid, memory tools listed) and 2026-11-09 (Free plan: API key, `memory_stats` from a chat)
Any other 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:

bash

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

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"; Cursor has been part of SpaceX since 14 August 2026 ("Cursor has officially been acquired by SpaceX", Cursor blog). Its pricing page, read 2026-11-13, now sells plans named Free, Plus, Premium, Super, Ultra, Teams and Enterprise that also list X and Grok features ("Post, reply, and follow", "Premium checkmark", "Grok API access"); its only MCP row, "Repository, model, and MCP access controls", is checked for Enterprise alone, and the MCP page names no plan requirement, so this section no longer states one (the pricing page read earlier listed "MCPs, skills, and hooks" from the Individual plan up). 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.

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

Create a key for this repository alone on console.mnemoverse.com and copy it: it is shown only once.
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.
In the repository's Settings, click Copilot and then MCP servers in the sidebar, and enter this in the MCP configuration section:

json

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

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:

json

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

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

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

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

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

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

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

Hermes Agent

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

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

This loads the 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:

yaml

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

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

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

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

OpenClaw

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

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

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

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

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

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

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

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

Grok

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

grok plugin install mnemoverse/claude-plugin --trust

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

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

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 & MCPs page of the Cursor dashboard; members find them under Connect apps. 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 members find permitted connectors under Connect apps in Grok Bot." and "Set which servers members can use from your Team Marketplace on the dashboard's Plugins & MCPs page" (both read 2026-11-11) 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:

python

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

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

Why not the plugin. OpenHands checks for the Agent Plugins format first, so the plugin repository does load from GitHub (openhands --plugin github:mnemoverse/claude-plugin, [plugins] sources in ~/.openhands/config.toml, or PluginSource(source="github:mnemoverse/claude-plugin") in the SDK). It loads the 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.

AWS Quick (formerly Amazon Quick)

In the AWS 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-11-11 ("In the AWS Quick console, 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 AWS Quick automatically registers itself"); the same page read 2026-10-06 named the product Amazon Quick, and the product page, read 2026-11-11, is titled "AI Workspace - AWS Quick - AWS"; the callback per region is from the AWS Machine Learning blog post "Integrate external tools with Amazon Quick Agents using MCP" (2026-02-20) and the regions table. From host documentation, not verified live.

Langdock

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

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

Perplexity

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

Open Plugins in the sidebar, or Customize → Connectors if you don't see Plugins yet.
Open Add custom → Add MCP connector, and in the dialog select Remote.
Enter a Name, for example Mnemoverse, and https://mcp.mnemoverse.com/mcp as the MCP server URL. Under Advanced, set Authentication to OAuth, Transport to Streamable HTTP and Network access to Public, and leave the Client ID and Client Secret empty (Mnemoverse supports dynamic client registration). Select the acknowledgement checkbox, then Add; the connector appears on the Plugins page.
Select 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, read 2026-11-11: "For your account: open Plugins in the sidebar (or Customize → Connectors if you don't see Plugins yet).", "For your account, open Add custom → Add MCP connector.", "For your account, select Remote in the dialog.", "Under Advanced, set Authentication to OAuth, API Key, or None (see Authentication options), Transport to Streamable HTTP or SSE, and Network access to Public (the default) or Cloudflare Access.", "If the server uses OAuth and does not support dynamic client registration, have its Client ID and Client Secret ready", "Select Add. If you added the connector for your own account, it appears on the Plugins page.", "Select the connector card to start the authentication flow and enable it.", "Organization members can add custom remote connectors if an administrator enables them for the organization." and "The redirect URL to register is: https://www.perplexity.ai/rest/connections/oauth_callback". The same article on 2026-09-27 named Account settings → Connectors and + Custom connector for these steps. 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 to 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 said on 2026-09-27 that the CLI did not yet support OAuth servers; read 2026-11-11, it says "You can also add an OAuth server from inside a session with /mcp add <url>. It accepts the same --name, --scope, --transport, and --no-login options" and "After you approve access, the browser redirects to http://127.0.0.1:<redirect_port>/callback". 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 2026-11-11); 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).

Create a key on console.mnemoverse.com.
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.
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).
Set Remote URL to:

https://mcp.mnemoverse.com/mcp

Under Headers, add Authorization with the value %ASSETS/MnemoverseAuth%.
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 Devin in the browser: the shared deployment at app.devin.ai and the dedicated and custom-domain deployments, such as *.devinenterprise.com. All of them sign in through the same callback, https://api.devin.ai/mcp/oauth/callback, which is on the Mnemoverse sign-in allowlist.

Working path. Open Customize → MCPs (on app.devin.ai), 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-11-11: "It is https://api.devin.ai/mcp/oauth/callback for every Devin deployment, including dedicated and custom-domain ones such as *.devinenterprise.com." (read 2026-09-24, the same page said dedicated and custom-domain deployments used a different API origin); read 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:

json

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

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

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

Google Antigravity

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

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

json

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

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-11-11: "Antigravity automatically handles OAuth 2.0 with Proof Key for Code Exchange (PKCE) for remote MCP servers that support Client ID Metadata Documents (CIMD) or Dynamic Client Registration (DCR). For these servers, no additional client configuration is needed", "Dynamic Client Registration (DCR): Registers a client dynamically if the authorization server metadata includes a registration_endpoint." and "If you provide client credentials manually, ensure the following URL is registered as a redirect URI in your OAuth provider" (the Mnemoverse sign-in metadata, read 2026-11-11, includes a registration_endpoint); read 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 configuration, as a remote server under mcp.servers, and name the memory scopes, because the Mnemoverse sign-in grants only the scopes a client asks for:

json

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "servers": {
      "mnemoverse": {
        "type": "remote",
        "url": "https://mcp.mnemoverse.com/mcp",
        "oauth": { "scope": "memory:read memory:write offline_access" }
      }
    }
  }
}

opencode mcp add mnemoverse --global --url https://mcp.mnemoverse.com/mcp writes the same entry without the oauth line; add the scope to it afterwards. Earlier versions of this page, following the OpenCode docs of October 2026, put the server name directly under mcp; their V2 format does not, so move such an entry under mcp.servers.

If opencode mcp list shows needs authentication, open OpenCode, run /mcps, select mnemoverse and sign in in the browser; opencode mcp auth mnemoverse starts the same flow from the terminal. OpenCode registers itself through dynamic client registration and waits for the browser on a loopback address, which the Mnemoverse sign-in accepts on any port. A connected server shows as connected in opencode mcp list.

Source: MCP servers, read 2026-11-11: "Add --global to make it available in every project", "Remote servers use OAuth by default. If the list shows needs authentication, open OpenCode, run /mcps, select the server, and sign in.", "To configure a server by hand, give it a unique name under mcp.servers. V2 does not place server names directly under mcp.", "If the server needs authentication, run /mcps, select it, and complete authorization in the browser. The CLI can start the same flow", "Space-delimited scopes to request. Defaults to the scope the server names when it rejects an unauthenticated request.", "Neither of the above applies. OpenCode registers a client and reuses it on later sign-ins." and "Authorization servers accept any loopback port for these redirects". The Mnemoverse sign-in metadata, read 2026-11-11, advertises a registration endpoint and no client ID metadata documents, so OpenCode takes the registration route. 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:

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 identifies itself to the authorization server with its Client ID Metadata Document or by registering a client" and "Otherwise it registers a client dynamically." (read 2026-11-11; the Mnemoverse sign-in advertises no client ID metadata documents), "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> [-l] [--timeout <seconds>]" (read 2026-11-11). 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:

json

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

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:

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:

json

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

json

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

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)", "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."; read again 2026-11-11: "Many MCP servers, like Linear, need no setup to sign in. When you start the Amp TUI after adding a URL entry to amp.mcpServers, Amp opens the server's sign-in page in your browser." and "Amp supports Client ID Metadata Documents (CIMD), and it falls back to dynamic client registration for servers that do not support CIMD." (the Mnemoverse sign-in offers dynamic client registration). 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:

bash

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

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

json

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

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:

json

{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": ["-y", "@mnemoverse/mcp-memory-server@latest"],
      "env": {
        "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY",
        "MNEMOVERSE_API_URL": "https://core.mnemoverse.com/api/v1"
      }
    }
  }
}

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:

Create a key on console.mnemoverse.com and copy it: it is shown only once.
In LobeHub, open Settings → Connectors, add an MCP server manually and choose HTTP Server.
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.
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:

Create a key on console.mnemoverse.com and copy it: it is shown only once.
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.
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.
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):

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 (what one key shares).

In the app:

Create a key on console.mnemoverse.com and copy it: it is shown only once.
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.
Enter Mnemoverse as Name, https://mcp.mnemoverse.com/mcp as MCP Server URL and choose Streamable HTTPS as Transport.
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.
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:

yaml

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):

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.
Add the entry, inside the existing mcpServers object if the file has one, and save:

json

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

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:

json

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

Create a key for TypingMind alone on console.mnemoverse.com and copy it: it is shown only once.
In TypingMind, click Plugins in the left sidebar. Under Store, click MCPs, then + Add MCP. The Add Custom MCP Server URL page opens.
Enter https://mcp.mnemoverse.com/mcp as Server URL and Mnemoverse Memory as Connection name.
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.
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.
When the entry shows Connected via TypingMind Cloud, open its Tools tab: each tool has its own toggle.
In a chat, click the plugin selector next to the model name and turn on Mnemoverse Memory under MCP.

TypingMind describes the MCP Connector as "an intermediate server to facilitate your connection between the TypingMind app and the remote MCP servers": with TypingMind Cloud that server is TypingMind's, with a Private MCP Connector it is the one you run on your own computer or server. 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 (what one key shares).

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:

json

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

Open the agent and expand the Connections drawer in the sidebar.
Click Add connection, then + Add custom MCP.
Enter mnemoverse as the name and https://mcp.mnemoverse.com/mcp as the URL.
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 (what one key shares); 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):

json

{
  "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 (what one key shares). 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.

Create a key for Dify alone on console.mnemoverse.com and copy it: it is shown only once.
In Dify, open Integrations, choose MCP in the sidebar and click Add MCP Server (HTTP).
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).
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.
Click Add & Authorize. Dify connects with the header and imports the memory tools.
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 (what one key shares). 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).

Create a key for Relevance AI alone on console.mnemoverse.com and copy it: it is shown only once.
Open the agent and go to the Tools tab in the agent builder. Click Add MCP, then Connect my own.
Enter https://mcp.mnemoverse.com/mcp as the URL and Mnemoverse as the label; tool descriptions show it as (MCP: Mnemoverse).
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.
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.
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 (what one key shares). 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.

Create a key for Lindy alone on console.mnemoverse.com and copy it: it is shown only once.
In Lindy, open Integrations in the left sidebar, click + Add and choose MCP.
In Connect MCP server, enter https://mcp.mnemoverse.com/mcp as Server URL and Mnemoverse Memory as Display name.
Open Advanced, leave Send as on Authorization header (Bearer) and paste mk_live_YOUR_KEY into Bearer token.
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 (what one key shares). 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.

Create a key for Gumloop alone on console.mnemoverse.com and copy it: it is shown only once.
In Gumloop, select Customize in the left sidebar, open the Connectors tab and click + in the top-right corner (on wider screens it is labeled 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.
In Connect MCP Server, enter https://mcp.mnemoverse.com/mcp as MCP Server URL and click Connect.
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.
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.
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 (what one key shares), 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 the + button in the top-right corner of the page. On wider screens, this button is labeled Add Custom MCP. The Connect MCP Server dialog opens." (read 2026-11-11), "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. For key-based authentication, open the Authentication dropdown and select API Key / Credentials to supply a token, API key, or custom header." (read 2026-11-11), "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. A voice agent gets the tools of a remote MCP server through an MCP tool, over Streamable HTTP. Vapi authenticates to the server with a header or a saved credential and does not support 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.

In the Vapi Dashboard, go to Tools, click Create Tool and select MCP.
Under Tool Settings, enter a Tool Name and Description, for example Mnemoverse memory.
Under Server Settings, enter https://mcp.mnemoverse.com/mcp as the Server URL.
Under HTTP Headers, add the header Authorization with the value Bearer mk_live_YOUR_KEY. A saved Bearer token credential selected under Authorization works too; a header named Authorization takes precedence over the credential.
Under MCP Settings, keep Streamable HTTP selected.
Save the tool. Vapi queries the server and lists its tools under Available Tools; if the list is empty, check the URL and the header, save again and refresh.
Open your assistant, add the MCP tool to its tools and publish.

Through the API, create the same tool with POST https://api.vapi.ai/tool, your private Vapi API key as Authorization: Bearer, and the Mnemoverse key in the body:

json

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

The model sees each tool with a prefix taken from the server's domain, for example mnemoverse-memory_read; use that name if your system prompt refers to a tool.

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 (what one key shares). Vapi adds every tool the server lists and has no setting to include or exclude individual tools, 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-11-11: "Go to Tools, click Create Tool, and select MCP.", "Under Tool Settings, enter a Tool Name and Description so you and your team can identify this MCP tool.", "Under Server Settings, enter the Server URL.", "If the server needs authentication, select a saved credential under Authorization, or add the auth header under HTTP Headers.", "Under MCP Settings, keep Streamable HTTP selected.", "Save the tool. Vapi then queries your MCP server for its list of tools and shows them in the Available Tools section" and "Open your assistant, add the MCP tool to its tools, and publish."; Configure MCP tools, read 2026-11-11: "A header in server.headers.", "Vapi doesn't support servers that require a user to sign in through a browser.", "If server.headers contains an Authorization header, it takes precedence over the credential.", "Vapi adds every tool the server lists. It has no setting to include or exclude individual tools." and "Vapi adds a prefix to each tool name so tools from different servers don't clash."; the Create Tool reference, read 2026-10-26: "POST https://api.vapi.ai/tool" and "send it in the Authorization header as Bearer <token>". 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.

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.
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.
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.
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.
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 always fails for users in Teams. 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 (what one key shares). 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 (Microsoft has since removed the 2026-10-01 post: its address answered 410 Gone on 2026-11-14, and the Wayback Machine holds no copy), and AWS's list of the clients its MCP server accepts through dynamic client registration, Configure OAuth access to AWS MCP Server, read 2026-11-14: "Microsoft Copilot Studio" with "https://global.consent.azure-apim.net/redirect/*"; 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.

Create a key for Zapier alone on console.mnemoverse.com and copy it: it is shown only once.
In Zapier, open the Apps page, click + Add connection, search for and select MCP Client, and click Add connection.
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.
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 (what one key shares); 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 yourself to memory_read or another tool that only reads, instead of the option "Let your agent select a value for this field". 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.

Create a key for Voiceflow alone on console.mnemoverse.com and copy it: it is shown only once.
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.
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.
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.
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 (what one key shares); 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):

json

{
  "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 (what one key shares). 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.

Create a key for Manus alone on console.mnemoverse.com and copy it: it is shown only once.
In Manus, go to Settings → Integrations → Custom MCP Servers and click Add Server.
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.
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:

Create a key on console.mnemoverse.com and copy it: it is shown only once.
Open Connectors, select Add custom and choose MCP server. If MCP server is grayed out, a workspace admin has turned the Custom MCP setting off.
Enter Mnemoverse as the server name and https://mcp.mnemoverse.com/mcp as the server URL. If a Connection dropdown appears, keep Direct connection.
Choose Bearer token or API key as the authentication, enter mk_live_YOUR_KEY and click Add server.
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.", "Open Connectors, select Add custom, and choose MCP server." and "If MCP server is grayed out, a workspace admin has disabled the Custom MCP setting" (both read 2026-11-11), "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.

Glean

Glean is a work assistant and agent platform for companies. A Glean admin connects a remote MCP server once and publishes its tools to Glean Assistant and Glean Agents for the organization. Glean's API Key authentication sends the key as Authorization: Bearer <key> by default, which is the form the hosted server reads (with an API key), so Glean connects with a Mnemoverse API key. Adding the server needs access to Platform → Tools in the Glean Admin console. Glean asks you to look in its Connectors catalog first and to use Platform → Tools for a server that is not listed there; the steps below add Mnemoverse that way.

Create a key for Glean alone on console.mnemoverse.com and copy it: it is shown only once.
In Glean, open the Admin console, go to Platform → Tools and open the Vendor Provided Tools (via MCP) tab.
Click Add. In the Add tools dialog, open the Vendor provided tools (via MCP) tab and select Import tools from MCP server.
Enter Mnemoverse as the MCP server name, Long-term memory as the description and https://mcp.mnemoverse.com/mcp as the MCP server URL. Choose Streaming HTTP as the transport type and API Key as the authentication method, enter mk_live_YOUR_KEY and keep the default Authorization: Bearer <key> header format.
Click Connect to server and follow the dialog. Glean discovers the memory tools.
Click Edit settings. Enable the tools for Agents, so agent creators can use them in Agent Builder, and, if people should call them in conversation, for Glean. Click Save.

The admin enters one key in the server configuration, so every person the tools are published to reads and writes the same memory: the memory of the Mnemoverse account the key was created in (what one key shares). That fits a memory the team shares; it does not keep one person's memory apart from another's. For each tool, the admin enables it for Agents and, optionally, for Glean, which lets Glean call it in conversation. To keep the tools that change memory (memory_write, memory_feedback, memory_create_room, memory_invite_to_room, memory_join_room) out of conversation, leave Glean off for them; Glean's optional role-based access can also limit which creators or departments can add them to agents. In agents, Glean offers MCP tools only in Plan and execute steps and in autonomous agents, and describes MCP servers in agents as beta.

Choose API Key, not Dynamic Client Registration or OAuth: Glean's page does not name the callback of its sign-in, and the Mnemoverse sign-in accepts callbacks only on listed hosts. Glean's prerequisites mention OAuth 2.0, but its authentication section says to choose the method that matches your server and lists API Key for servers that take a static key or bearer token. Revoking the key in the console stops this connection without touching other hosts. This entry has not been run from Glean.

Source: Connect remote MCP servers to Glean, read 2026-11-07 and again 2026-11-08: "Glean fully supports remote MCP servers in Glean and currently offers beta support for servers in agents.", "Glean deployments created on or after September 22, 2026, use Connectors to set up catalog-backed MCP integrations.", "For earlier deployments, check Connectors first. If the integration isn't listed there, use Platform → Tools.", "Use this page for a custom or unlisted remote MCP server", "Supports OAuth 2.0 with authorization code flow, with or without Dynamic Client Registration (DCR).", "choose the method that matches your MCP server's requirements.", for API Key "You provide your own API key to Glean, and are responsible for managing usage capacity. By default, Glean sends the key as a Bearer token in the Authorization header." and "Servers that authenticate with a static API key, API token, or Bearer token.", "For custom MCP servers that use API Key authentication, Glean sends Authorization: Bearer <key> by default.", "You must be able to open the Admin console and access Platform → Tools.", "Open the Vendor Provided Tools (via MCP) tab.", "In the Add tools dialog, open the Vendor provided tools (via MCP) tab.", "Under Add tools, select Import tools from MCP server.", "Transport type: choose SSE or Streaming HTTP, depending on how your MCP server is implemented.", "Connect to server using the provided instructions.", "for each tool you want to make available", "Enable it for Agents so agent creators can use it in Agent Builder.", "Optionally, enable it for Glean, so it can call the tool in conversational flows.", "Optionally, apply role-based access so only specific creators or departments can add or configure sensitive tools in agents." and "MCP servers are only available in Plan and execute steps and in autonomous agents." The page names neither the callback of its OAuth methods nor whether the key can differ per user. From host documentation, not verified live.

Open WebUI

Open WebUI is a self-hosted chat interface. This section is for an instance served from its own domain, such as chat.example.com. There the sign-in cannot be set up: the Mnemoverse sign-in registers callbacks only on known hosts (why), so registering Open WebUI's callback on your domain is refused and Open WebUI shows "Registration failed". Open WebUI connects instead with a Mnemoverse API key, which the hosted server https://mcp.mnemoverse.com/mcp accepts as Authorization: Bearer <key> (with an API key).

Open WebUI connects to MCP servers natively from v0.6.31, over Streamable HTTP only. Only an Open WebUI admin can add an MCP server.

Create a key for this instance. On the API Keys page of console.mnemoverse.com, enter a name such as open-webui-chat.example.com under Create New Key, click Create Key and copy the key: the console shows it only once. Use this key for this instance and nowhere else, so that revoking it on the same page cuts off this instance alone and leaves your other tools working.

Add the connection (admin).

Open Settings > Admin > Integrations. Under External Tool Servers, click + Add Connection.
Click Type until it reads MCP Streamable HTTP. A new connection starts at OpenAPI.
Enter Name Mnemoverse (the Connection ID fills in from the name) and URL https://mcp.mnemoverse.com/mcp.
Set Auth to Bearer and paste the key into the API Key field next to it. Do not choose OAuth 2.1 on your own domain: Mnemoverse refuses its Register Client step there.
Click Verify Connection beside the URL. When the key is accepted, Open WebUI connects, reads the tool list and shows "Connection successful".
Click Access Control and add the users or groups who should use this memory. Until you do, the connection is private and only admins can use it.
Click Save.

Use it in a chat. Open the + menu in the message input, select Tools and switch Mnemoverse on (up to v0.13.0, Integrations is a button of its own next to +: click it, then Tools). A tool server added by an admin stays off in a chat until it is switched on this way. The model sees each tool as <Connection ID>_<tool name>, for example mnemoverse_memory_read. Then run the check in Verify on any host.

The key belongs to one Mnemoverse account, so everyone you grant access to this connection reads and writes that account's memory (what one key shares). To keep one group's memory apart, give that group its own connection with a key from a different Mnemoverse account. Open WebUI's server, not the browser, calls https://mcp.mnemoverse.com/mcp, so that server needs outbound HTTPS to the host. If the key leaks, revoke it under API Keys, create a new one and paste it into the connection (key handling). This entry has not been run from Open WebUI.

If Verify Connection fails, check that Auth is Bearer and that the whole key is in the field. From v0.12.1, Open WebUI writes the reason a connection fails during a chat, such as a 401 from the server, to its logs. If External Tool Servers is greyed out, ENABLE_TOOL_SERVERS is set to False. An instance you reach at localhost can use OAuth 2.1 instead, with each user signing in to their own account, as long as WebUI URL in the admin General settings is empty or a localhost address: Open WebUI builds the sign-in callback from that setting, and from the address in your browser only when it is empty. See Remote MCP Server.

Alternative: mcpo as an OpenAPI tool server

Open WebUI's docs call OpenAPI the preferred integration path for most deployments. mcpo, Open WebUI's MCP-to-OpenAPI proxy, puts the hosted server behind an OpenAPI tool server. On a machine with uv, save this as mcpo.json:

json

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

Start mcpo with a secret of its own, which Open WebUI will send to it:

bash

uvx mcpo --port 8000 --api-key "choose-a-proxy-secret" --config mcpo.json

Then add the connection as above, with three differences: leave Type at OpenAPI; set the URL to http://<mcpo-host>:8000/mnemoverse, where <mcpo-host> is the address at which Open WebUI's server reaches mcpo (for Open WebUI in Docker and mcpo on the same machine, host.docker.internal, which Docker Desktop resolves by itself; with Docker Engine alone, start the Open WebUI container with --add-host host.docker.internal=host-gateway); and put the proxy secret, not the Mnemoverse key, in the API Key field. With a config file, mcpo serves each server under its own path, so the URL ends in /mnemoverse. The Mnemoverse key sits in mcpo.json; keep that file readable only by the account that runs mcpo.

Source: Model Context Protocol (MCP), read 2026-11-08: "Open WebUI natively supports MCP (Model Context Protocol) starting in v0.6.31.", "MCP servers can only be added by administrators, under Settings > Admin > Integrations.", "Under External Tool Servers, click + Add Connection.", "Set Type to MCP (Streamable HTTP).", "Bearer: Use this only if your MCP server requires a specific API token. You must populate the "Key" field.", "an admin adds the server once and scopes it with Access Control to the right users or groups", "Open WebUI offers each MCP tool to the model as <server ID>_<tool name>", "Native MCP support in Open WebUI is Streamable HTTP only.", "The External Tool Servers section is greyed out when ENABLE_TOOL_SERVERS is set to False." and "For most deployments, OpenAPI remains the preferred integration path."; Open WebUI Integration, read 2026-11-08: "Requests are sent from the Open WebUI backend/server (not your browser).", "Global tools are hidden by default and must be explicitly activated per user.", "open the + menu in the message input area, select Tools, and manually toggle on the specific global tool(s) you want to use", and, for an mcpo config file, "you must enter the full route to that specific tool"; release notes of v0.12.0: "the ID field is now labeled Connection ID and filled in from the server name", and v0.12.1: "the reason, such as a refused connection or a 401 from the server, is now logged as an error", and of v0.13.1, published 2026-11-08: "The Integrations button is now part of the + menu in the message input". The header, the default type, the field and button labels, the registration message, the sign-in callback and the default access are from the Open WebUI source at v0.13.0, read 2026-11-08, when v0.13.1 and v0.13.2 had just been released the same day (backend/open_webui/utils/tools.py: headers.update(bearer_auth_header(connection.get('key', ''))); backend/open_webui/utils/headers.py: {'Authorization': f'Bearer {token}'}; src/lib/components/AddToolServerModal.svelte: let type = 'openapi', Verify Connection, "Connection successful", API Key, Register Client, "Registration failed"; backend/open_webui/utils/oauth.py: redirect_base_url = (str(webui_url or request.base_url)).rstrip('/') and redirect_uris=[f'{redirect_base_url}/oauth/clients/{client_id}/callback']; src/lib/i18n/locales/en-US/translation.json: "WebUI URL", on the admin General settings page; backend/open_webui/utils/access_control/__init__.py: "Missing, None, or empty access_grants → private, admin-only"). mcpo: MCP Support and the mcpo README, read 2026-11-08 (--api-key, --config, a "type": "streamable-http" server); that a streamable-http server in the config file takes headers is from the mcpo source at main 788ff92 (src/mcpo/main.py: sub_app.state.headers = server_cfg.get("headers")). host.docker.internal: Docker's docker container run reference, read 2026-11-08: "The --add-host flag supports a special host-gateway value that resolves to the internal IP address of the host.", "It's conventional to use host.docker.internal as the hostname referring to host-gateway." and "Docker Desktop automatically resolves this hostname". From host documentation, not verified live.

Visual Studio

Visual Studio on Windows connects MCP servers to GitHub Copilot in agent mode, in Visual Studio 2026 and in Visual Studio 2022 from version 17.14. Visual Studio signs in to remote servers with OAuth, but its documentation does not name the callback of that sign-in, and the Mnemoverse sign-in accepts callbacks only on listed hosts. A remote server added in Copilot Chat can carry headers, so Mnemoverse connects with an API key as a bearer token (with an API key), or through the local npx package. This section is for Visual Studio; VS Code has its own section.

Create a key for Visual Studio alone on console.mnemoverse.com and copy it: it is shown only once.
Open the GitHub Copilot Chat pane (View → GitHub Copilot Chat in GitHub's steps), and at the bottom of the chat panel choose Agent from the mode dropdown.
Click the tools icon (Tools), then the plus (+) button in the tool picker. In Visual Studio 2026, choose Add custom MCP server from the menu that appears; in Visual Studio 2022 the dialog opens directly.
In the dialog (Add MCP server on Microsoft's page, Configure MCP server in GitHub's steps), enter mnemoverse as Server ID, choose HTTP/SSE as Type and enter https://mcp.mnemoverse.com/mcp as URL. These field names are from GitHub's steps; Microsoft's page names no fields, so the Visual Studio 2026 dialog may label them differently.
Under Headers, add a header named Authorization with the value Bearer mk_live_YOUR_KEY: the word Bearer, a space, then the whole key. Click Save. If your dialog has no Headers field, use the local package below. Microsoft recommends the latest 17.14 servicing release for the most up-to-date MCP features.
Open the tool picker again and turn on the Mnemoverse tools: Visual Studio adds a new server's tools turned off.

From Visual Studio 2026 version 18.7, Visual Studio asks you to trust a server again when it has changed since you last used it, not on first use: choose Accept to run the updated server, or Always Trust to stop the prompts for it.

With the local package instead: on a computer with Node.js 18 or later, open %USERPROFILE%\.mcp.json in Visual Studio, so that its JSON schema applies, add the entry under servers and save. Saving the file reloads the servers; then turn on the tools as in step 6.

json

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

Whether Visual Studio uses the header rather than starting its own sign-in for this server has not been checked. If it asks you to sign in to Mnemoverse, use the local package.

In an organization on Copilot Business or Copilot Enterprise, the MCP servers in Copilot policy must be on; GitHub says Copilot Free, Copilot Pro, Copilot Pro+ and Copilot Max are not governed by that policy. The GitHub policy settings on the Copilot dashboard also govern agent mode in Visual Studio, and from Visual Studio 2022 17.14.16 an administrator can turn agent mode off through Visual Studio's administrative templates. In Visual Studio 2026 (from 18.4.0, per GitHub), an organization can also allow only the servers in its own MCP registry, set under AI Controls → MCP in GitHub with Registry only, and Visual Studio then blocks any other server with an error saying the organization's policy does not permit it. To allow Mnemoverse there, an admin adds it to that registry; Mnemoverse is listed in the GitHub MCP Registry as io.github.mnemoverse/mcp-memory-server. GitHub matches servers to the registry by name or ID only, so a server added with the steps above under the ID mnemoverse does not match that entry: under Registry only, install Mnemoverse from your organization's registry instead. This combination has not been checked in Visual Studio.

A key reads and writes the whole memory of its Mnemoverse account; give Visual Studio its own key, and revoking it in the console stops only this connection. Visual Studio also reads <SOLUTIONDIR>\.mcp.json, which Microsoft describes as the configuration to track in source control: a key written there reaches everyone who clones the repository, and all of them work in that key's one memory (what one key shares). Keep the key in %USERPROFILE%\.mcp.json or <SOLUTIONDIR>\.vs\mcp.json, which load only for you. Microsoft's and GitHub's pages do not say which file the dialog saves the server to, so before you commit, check that no .mcp.json in the solution holds the key. The tools that change memory are memory_write, memory_feedback, memory_create_room, memory_invite_to_room and memory_join_room. This entry has not been run from Visual Studio.

To check the connection, ask Copilot in Agent mode to call the Mnemoverse tool memory_stats. Copilot asks before it runs a tool: choose Allow (Confirm in Visual Studio 2026) for this call, or for the session, the solution or always. A successful result confirms that Visual Studio reaches your memory; Verify on any host covers a save and a recall.

Source: Use MCP Servers to Extend GitHub Copilot, updated 2026-10-14 (commit 593518a7), read 2026-11-08: "Visual Studio 2026 Or Visual Studio 2022 version 17.14 (with the latest servicing release recommended for the most up-to-date MCP features)", "MCP support enhances GitHub Copilot agent mode by allowing you to connect any MCP-compatible server to your agentic coding workflow.", "In the chat pane, switch to Agent mode from the mode selector at the bottom of the pane.", "In the tool picker, select the plus (+) button.", "On the menu that appears, select Add custom MCP server." (Visual Studio 2026), "The Add MCP server dialog opens." (Visual Studio 2022), "In the Add MCP server dialog, enter the server name and connection details, such as the URL for HTTP servers or the command and arguments for stdio servers.", "Create a new file: <SOLUTIONDIR>\.mcp.json or %USERPROFILE%\.mcp.json. Use Visual Studio to edit this file so that its JSON schema is automatically applied.", "%USERPROFILE%\.mcp.json Serves as a global MCP server configuration for a specific user.", "<SOLUTIONDIR>\.vs\mcp.json Specific to Visual Studio and loads the specified MCP servers only for a specific user, for the specified solution.", "<SOLUTIONDIR>\.mcp.json Works well if you're looking for an MCP configuration that you can track in source control for a repository.", "Visual Studio respects whatever command you specify, so you can pin versions or pass flags as needed.", "When you save the file with valid syntax, the GitHub Copilot agent restarts and reloads the configured servers.", "The tools are disabled by default and you must manually enable them.", "When you invoke a tool, Copilot requests confirmation to run the tool.", "use the Confirm dropdown options" (Visual Studio 2026) and "use the Allow dropdown options" (Visual Studio 2022), "You can automatically confirm the specific tool for the current session, the current solution, or all future invocations.", "Visual Studio now supports authentication for remote servers by using any OAuth provider, in accordance with the MCP authorization specification.", "MCP server usage in Visual Studio respects allow list policies set by organization administrators through GitHub.", "The GitHub policy settings on the GitHub Copilot dashboard for administrators govern agent mode and MCP usage in Visual Studio. If the administrator turns off this setting, users under that subscription can't use agent mode or connect to MCP servers in Visual Studio.", "Visual Studio asks you to trust an MCP server again when the server changes since the last time you used it.", "MCP server trust is available in Visual Studio 2026 version 18.7 and later.", "It's the first time the server is seen. Visual Studio saves an initial trust baseline automatically.", "Accept to run this updated version now." and "Always Trust to stop future trust prompts for this server."; Admin controls for GitHub Copilot in Visual Studio, updated 2026-10-08, read 2026-11-08: "With Visual Studio 2022 version 17.14.16 or later, project administrators can fully disable Agent Mode using Visual Studio Administrative Templates (ADMX/ADML).", "With Visual Studio 2026, administrators can configure an allowlist of approved MCP servers through the GitHub Copilot administration dashboard.", "In the enterprise or organization settings, navigate to AI Controls and select MCP in the sidebar to configure MCP server policies." and "If the server isn't on the allowlist, Visual Studio blocks the connection and displays an error message indicating that the server isn't permitted by the organization's policy."; Setting up the GitHub MCP server, Visual Studio tab, read 2026-11-08: "Visual Studio version 17.14 or later", "In the Visual Studio menu bar, click View, then click GitHub Copilot Chat.", "At the bottom of the chat panel, select Agent from the mode dropdown.", "In the Copilot Chat window, click the tools icon, then click the plus icon in the tool picker window.", "In the "Configure MCP server" pop-up window, fill out the fields.", "For "Type", select "HTTP/SSE" from the dropdown.", "Add a new header under "Headers", called "Authorization" and set to the value Bearer YOUR_GITHUB_PAT, replacing "YOUR_GITHUB_PAT" with your PAT." and "Click Save."; Extending GitHub Copilot Chat with MCP, read 2026-11-08: "If you are a member of an organization or enterprise with a Copilot Business or Copilot Enterprise plan, the "MCP servers in Copilot" policy must be enabled in order to use MCP with Copilot.", "Copilot Free, Copilot Pro, Copilot Pro+, or Copilot Max do not have their MCP access governed by this policy." and a local example with "type": "stdio", "command", "args" and "env"; MCP private registry enforcement, read 2026-11-08: "✓ v18.4.0+" for Visual Studio in the "Allowlist enforcement" column and "Enforcement is based only on server name/ID matching, which can be bypassed by editing configuration files."; Restrict MCP server access to a custom registry, read 2026-11-08: "In the MCP Registry URL section, enter the URL of your registry" and "Registry only: Only servers from the registry may run, so users can't use Copilot connectors."; the Mnemoverse entry io.github.mnemoverse/mcp-memory-server in the GitHub MCP Registry (name as returned by https://api.mcp.github.com/v0.1/servers?search=mnemoverse), read 2026-11-08. Neither Microsoft's nor GitHub's pages name the callback of Visual Studio's OAuth sign-in, the file the add dialog saves to, or whether a header stops that sign-in. From host documentation, not verified live.

JetBrains IDEs

JetBrains IDEs, such as IntelliJ IDEA, PyCharm and WebStorm, have two JetBrains AI tools, each with its own MCP server list: Junie, as an IDE plugin and as Junie CLI, and AI Assistant. GitHub Copilot for JetBrains keeps a third list in its own mcp.json. Junie and Copilot take a remote server with a fixed header, so they connect with an API key as a bearer token (with an API key). AI Assistant's documentation shows a remote server as a URL alone, with no header and no sign-in, so AI Assistant runs Mnemoverse as a local server through the mcp-remote bridge. The bridge signs in in the browser and returns to a loopback address on your computer (localhost, or 127.0.0.1 on Windows), which the Mnemoverse sign-in accepts on any port (which clients can sign in), so it needs no key.

Junie (IDE plugin and Junie CLI):

Create a key for Junie alone on console.mnemoverse.com and copy it: it is shown only once.
In the IDE, open Settings (Ctrl+Alt+S) → Tools → Junie → MCP Settings and click the add button on the toolbar: mcp.json opens. Servers added there are saved to ~/.junie/mcp/mcp.json in your home directory, the user-level file Junie CLI also reads, so for Junie CLI open that file in an editor.

Add the entry under mcpServers and save:

json

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

In the IDE, check that mnemoverse is on the MCP Servers list in MCP Settings with its connection status and the memory tools. In Junie CLI, run /mcp: the server's status should be Active. If it shows Failed or Authorization required, check that the header value is the word Bearer, a space and the whole key.

Junie's CLI page shows this url and headers form for mcp.json; its IDE plugin pages save servers to the same file and leave the format to the server's documentation. Junie also offers Authorize for remote servers that need a sign-in. In a report on JetBrains' issue tracker that sign-in returns to http://localhost:62345/callback, a loopback address the Mnemoverse sign-in accepts (which clients can sign in), and fails at another vendor's server with invalid_scope (JUNIE-5068, in the Backlog). It has not been run with Mnemoverse, so these steps use a key.

GitHub Copilot for JetBrains:

Create a key for Copilot alone on console.mnemoverse.com and copy it: it is shown only once.
In the lower right corner of the IDE, click the GitHub Copilot icon, select Open Chat and make sure the chat is in Agent mode.
Click the tools icon, Configure your MCP server, at the bottom of the chat window, then click Add MCP Tools: mcp.json opens.

Add the entry under servers and save:

json

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

Click the tools icon again: the memory tools should be listed.

On Copilot Business or Copilot Enterprise, the MCP servers in Copilot policy of your organization or enterprise must be enabled before Copilot uses MCP. GitHub's JetBrains steps show a remote server with a bearer header under requestInit and describe no browser sign-in, so this entry uses a key.

AI Assistant:

Go to Settings → Tools → AI Assistant → Model Context Protocol (MCP), or type / in the chat and choose Add Command.

Click Add. In the New MCP Server dialog, choose STDIO and enter this JSON configuration. The bridge runs through npx and needs Node.js 20.18.1 or later, the version its dependency undici declares:

json

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

Choose whether the server is available globally or only in the current project, click OK, then Apply, which starts the server.
On first start the bridge opens the Mnemoverse sign-in in your browser: sign in and approve. 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.
Check the connection in the Status column of the MCP settings page. Once it is connected, click the icon in the Status column to see the memory tools.

Do not add https://mcp.mnemoverse.com/mcp to AI Assistant as a URL alone. An open report on JetBrains' tracker (LLM-24541) describes AI Assistant showing only the error "Expected status code 200 but was 401" for a server that needs authentication, and gives this bridge as the workaround. OAuth for MCP servers in JetBrains IDEs is an open request on the same tracker (LLM-25012).

For an organization: if your organization manages AI centrally through JetBrains IDE Services or JetBrains Central, an administrator can preconfigure your MCP servers and decides whether you can add your own. In JetBrains IDE Services an administrator adds the server once under Configuration → License & Activation → AI Enterprise → Settings → Model Context Protocol → Add MCP Server → Remote, with https://mcp.mnemoverse.com/mcp as the URL, Authorization as the header name and Bearer mk_live_YOUR_KEY as its value, and then selects the server for each profile. Turning off Allow users to add MCP in their IDE, which is on by default, stops users adding servers themselves. JetBrains Central CLI adds the servers a JetBrains Central administrator configures, with their URL and headers, to each member's agents.

A key reads and writes the whole memory of the Mnemoverse account it was created in. In ~/.junie/mcp/mcp.json it serves Junie in every JetBrains IDE on that computer and in Junie CLI, and Junie describes that file as private to your user account. Do not put the key in a project's .junie/mcp/mcp.json: Junie says that file can be checked into version control and shared with the whole team, so a key in it serves everyone who gets the repository, all in that key's one memory (what one key shares). The same holds for a key an administrator enters in a server preconfigured through JetBrains IDE Services or JetBrains Central: it serves every user the server reaches. The tools that change memory are memory_write, memory_feedback, memory_create_room, memory_invite_to_room and memory_join_room. Give Junie and Copilot each their own key, so revoking one in the console stops only that connection. AI Assistant, through the bridge, works in the memory of the account you signed in with. None of these entries has been run from a JetBrains IDE.

To check that the memory works, ask Junie, Copilot in Agent mode or AI Assistant to call memory_stats; AI Assistant also lets you call a tool by typing its / command in the chat. A result with your memory's counts confirms the connection, and Verify on any host has the full check.

Source: Junie Add and configure MCP servers, dated 06 November 2026, read 2026-11-08: "Use the /mcp command to open the MCP server configuration screen.", "This file can be checked into version control and shared across all team members.", "For project-scope installations, avoid sharing secrets or sensitive environment variables if the .junie/mcp/mcp.json file is committed to version control.", "user-scope MCP configs are stored in ~/.junie/mcp/mcp.json and available across all projects on your machine while remaining private to your user account.", an example "RemoteServer" entry with "url" and "headers": { "Authorization": "Bearer token" }, "Manually added configurations are imported to the list of MCP servers and enabled by default.", "Verify that the server's status has changed to Active.", "The Failed status indicates that an error occurred while attempting to connect to the server, the server cannot be started or crashes while running.", "Remote MCP servers that require OAuth authorization are added to the list of configured servers with an Authorization required status." and "Select → Authorize and then follow the steps to login in the respective server's browser page that opens."; Junie IDE plugin, dated 06 November 2026, read 2026-11-08: "The MCP servers added via the Tools | Junie | MCP Settings page in your Jetbrains IDE settings are saved to the ~/.junie/mcp/mcp.json file in the home directory.", "To configure an MCP server at the project level, add an mcp.json file manually to the .junie/mcp/ folder in the project root." and "The MCP servers configured at both global and project levels are displayed on the MCP Servers list in Settings (Ctrl+Alt+S) | Tools | Junie | MCP Settings."; Junie MCP Settings, dated 06 November 2026, read 2026-11-08: "on the toolbar and edit the mcp.json file that opens.", "For the JSON schema, refer to the documentation of the MCP server you are adding." and "Each added server is displayed on the MCP Servers list with its connection status, the list of available tools, and indication where the configuration is stored (globally or at the project level)."; JetBrains issue JUNIE-5068, state Backlog, read 2026-11-08: "Callback URL containing the error:" with http://localhost:62345/callback?error=invalid_scope, created from JetBrains/junie#84, read 2026-11-08; Extending GitHub Copilot Chat with MCP, JetBrains IDEs, read 2026-11-08: "In the lower right corner, click", "From the menu, select "Open Chat", make sure you are in Agent mode, then click the tools icon (called "Configure your MCP server") at the bottom of the chat window.", "Click Add MCP Tools.", "In the mcp.json file, define your MCP servers. JetBrains IDEs support both remote and local servers.", an example "github" entry with "url" and "requestInit": { "headers": { "Authorization": "Bearer YOUR_PAT_HERE" } }, "In the Copilot Chat window, click the tools icon. You should now see additional tools from the MCP server(s) that you installed." and "If you are a member of an organization or enterprise with a Copilot Business or Copilot Enterprise plan, the "MCP servers in Copilot" policy must be enabled in order to use MCP with Copilot."; Model Context Protocol (MCP), AI Assistant 2026.2 Help, read 2026-11-08: "Go to Settings | Tools | AI Assistant | Model Context Protocol (MCP).", "typing / in the chat and selecting the Add Command option", "click Add to add a new MCP server configuration.", "In the New MCP Server dialog, select how you want to connect to the MCP server and provide a JSON configuration:", "AI Assistant launches the MCP server as a subprocess and exchanges data through standard input and output.", "If the MCP server is hosted remotely and accessible over HTTP, you can connect to it by specifying its URL in the configuration.", "specify whether the configured server should be available globally or only in the current project.", "Click OK. The MCP server will appear in the list.", "Click Apply. This will start the configured server and establish a connection to it.", "You can monitor the status of your connection in the Status column.", "Once the connection to the MCP server is successfully established, you can review the list of available tools by clicking the icon in the Status column.", "It can trigger them automatically when processing your request, or you can invoke them manually by typing the appropriate / command in the chat" and "If your organization manages AI centrally through JetBrains IDE Services or JetBrains Central, an administrator can preconfigure the MCP servers available to you and control whether you can add your own."; JetBrains issue LLM-24541, Open, read 2026-11-08: "Expected status code 200 but was 401" and "Change the mode of AI Assistant MCP to STDIO and use npx mcp-remote:"; JetBrains issue LLM-25012, "OAuth2 Authentication for MCP Server Connections", Open, read 2026-11-08; Manage AI Enterprise, IDE Services Cloud, read 2026-11-08 (also IDE Services 2026.1): "Navigate to Configuration | License & Activation.", "Scroll down to the AI Enterprise section and click Settings.", "Open the Model Context Protocol tab.", "Click Add MCP Server and select Remote from the menu.", "specify authentication information (API keys or access tokens) that the server uses to validate and authorize the request.", "To propagate these settings to users, select the MCP servers for each profile in the Profiles Settings." and "Disable the Allow users to add MCP in their IDE option, then click Confirm. This option is enabled by default."; Review MCP servers, JetBrains Central CLI, read 2026-11-08: "Administrators configure these servers in JetBrains Central Console, and JetBrains Central CLI delivers them to your machine and adds them to your agents." and "If an administrator changes the command, arguments, or environment variables of a command server, or the URL or headers of a remote server, the server becomes pending again until you allow it."; the mcp-remote README, read 2026-11-08: "To change which host mcp-remote registers as the OAuth callback URL (by default localhost), add the --host flag.", "mcp-remote stores all the credential information inside ~/.mcp-auth (or wherever your MCP_REMOTE_CONFIG_DIR points to)", "If you're having persistent issues, try running:" rm -rf ~/.mcp-auth and "Then restarting your MCP client", and on Windows the source of mcp-remote 0.16.5 (src/lib/utils.ts at commit 533159a, read 2026-11-08): let host = process.platform === 'win32' ? '127.0.0.1' : 'localhost' // Default; mcp-remote 0.16.5 on npm, read 2026-11-08: "undici": "^7.12.0", and undici 7.12.0, read 2026-11-08: "engines":{"node":">=20.18.1"}. The AI Assistant page shows neither a header nor a sign-in for a remote server, and GitHub's JetBrains steps describe no browser sign-in. From host documentation, not verified live.

Zed

Zed is a code editor. Its own agent, the Zed Agent in the Agent Panel, uses the MCP servers configured in Zed, and when a remote server has no Authorization header, Zed runs the standard MCP sign-in in the browser. That sign-in returns to a 127.0.0.1 loopback address on your computer, which the Mnemoverse sign-in accepts on any port (which clients can sign in), so Zed connects with no key. Zed added this sign-in in v0.230.0. These steps follow v1.18.0 and later, from which Zed registers with the same scopes it then asks for; on an earlier version, connect with a key.

In Zed, open Settings → AI → MCP Servers, or run the agent::OpenSettings action and select MCP Servers.
Click Add Server in the page header and choose Add Remote Server. In the editor that opens, replace some-remote-server with mnemoverse and the url value with https://mcp.mnemoverse.com/mcp, leave the oauth and Authorization lines commented out and click Configure Server. Zed writes the entry to your user settings file (its path is below), and you can add it there yourself instead:
json
```
{
  "context_servers": {
    "mnemoverse": {
      "url": "https://mcp.mnemoverse.com/mcp"
    }
  }
}
```
Click Authenticate next to mnemoverse. Zed opens the Mnemoverse sign-in in your browser: sign in to your Mnemoverse account and approve the request.
Check that the indicator dot next to mnemoverse is green and its tooltip says "Server is active".
In the Agent Panel, with the Write profile, ask Using mnemoverse, call memory_stats. and approve the tool call when Zed asks. A result with your memory's counts shows that Zed reaches your memory; Verify on any host checks a save and a recall.

The memory tools are on in Write, Zed's default profile. The built-in Ask and Minimal profiles do not turn on MCP tools, and the Zed Agent cannot use a tool that the active profile leaves out: to use the memory in another profile, open the profile selector in the Agent Panel, click Configure and turn on the mnemoverse tools. By default Zed asks before every tool call, MCP tools included (agent.tool_permissions.default is "confirm", from Zed v0.224.0); a rule for one tool uses the key mcp:mnemoverse:<tool_name>, for example mcp:mnemoverse:memory_write. In remote development, over SSH for example, Zed connects a url entry from your own computer, not from the remote host, so the sign-in runs in your local browser.

With an API key: when the browser sign-in does not complete, or on a Zed version before v1.18.0, create a key for Zed alone on console.mnemoverse.com and copy it: it is shown only once. Give the same entry a header; Zed prompts for the sign-in only when the entry has no Authorization header (with an API key):

json

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

The sign-in connects Zed to the memory of the Mnemoverse account you signed in with; to sign out, click Log Out next to mnemoverse. An open issue on Zed's tracker reports that Zed keeps the sign-in by the server's URL, so two entries with the same URL share one sign-in (#63564); to reach a second account, give the second entry a key of that account. A key reads and writes the whole memory of the account it was created in. Keep it in your user settings file (~/.config/zed/settings.json on macOS and Linux, %APPDATA%\Zed\settings.json on Windows), not in a project's .zed/settings.json: Zed reads MCP servers from project settings too, once the project is trusted, so a key committed there reaches everyone who gets the repository and trusts it, all in that key's one memory (what one key shares). Zed forwards its MCP servers to External Agents over the Agent Client Protocol and copies an entry's headers into what it forwards, so a key also reaches every external agent you run in Zed that takes remote servers. A server signed in through the browser is forwarded without its token, and an open issue reports that the external agent then gets 401 (#66640), so these steps cover the Zed Agent. Devin's configuration import, documented for Devin CLI and the Devin Local harness, also reads MCP servers from Zed's settings (Devin Desktop), so a key kept there may be loaded by Devin too. Give Zed its own key, so revoking it in the console stops Zed and any tool that imported this entry, and nothing else. This entry has not been run from Zed.

Source: Model Context Protocol (MCP) in Zed, read 2026-11-08: "Uses Zed-configured MCP servers directly" (for the Zed Agent), "You can connect both local and remote MCP servers from Settings → AI → MCP Servers", "also accessible via the" agent::OpenSettings "action, then selecting MCP Servers", "Click Add Server in the page header, then choose Add Local Server or Add Remote Server.", "Your specified configuration will create entries in your settings file", example entries under "context_servers" with "url" and "headers": { "Authorization": "Bearer <token>" } and with a "url" alone, "When a remote MCP server has no configured "Authorization" header, Zed will prompt you to authenticate yourself against the MCP server using the standard MCP OAuth flow.", "watch the indicator dot next to its name.", "If it's running correctly, the indicator will be green and its tooltip will say "Server is active".", "Mentioning the MCP server by name can help the model pick tools from that server.", "In Zed v0.224.0 and above, tool approval is controlled by agent.tool_permissions.default.", "Prompts for approval before running any tool action, including MCP tool calls", "MCP tools use the key format mcp:<server>:<tool_name>" and "MCP servers configured in Zed are forwarded to External Agents via the Agent Client Protocol."; Agent Profiles, read 2026-11-08: "A profile can set a default model and choose which built-in tools and MCP tools are available.", "Open the profile selector in the Agent Panel, then click Configure.", "configure MCP tools" and "If a tool is not available in the active profile, the Zed Agent cannot use it."; Zed and trusted worktrees, read 2026-11-08: "Every worktree opened may contain a .zed/settings.json file with extra configuration options that may require installing and spawning language servers or MCP servers." and "Restricted Mode prevents downloading and running related items from .zed/settings.json."; Configuring Zed (docs source), read 2026-11-08: "macOS: ~/.config/zed/settings.json", "Linux: ~/.config/zed/settings.json", "Windows: %APPDATA%\Zed\settings.json" and "Override user settings for a specific project by creating a .zed/settings.json file in your project root."; release notes of Zed v0.230.0, published 2026-04-01, read 2026-11-08: "Added OAuth authentication support for remote MCP servers. Servers requiring OAuth now show an "Authenticate" button when they need you to log in. You will be redirected in your browser to the authorization server of the MCP server to go through the authorization flow.", and of Zed v1.18.0, published 2026-09-02, read 2026-11-08: "Fixed OAuth authentication failing with MCP servers that require non-default scopes."; Zed pull request #63370, merged 2026-08-29, read 2026-11-08: "The OAuth DCR request now registers with the same set of scope selected for the entire flow, matching the authorization prompt used later."; Zed's source at v1.27.0 (commit c84af5b9), read 2026-11-08: in crates/context_server/src/oauth.rs, "Binds to an ephemeral loopback port for each flow.", "The redirect_uri should be the actual loopback URI with the ephemeral port (e.g. http://127.0.0.1:12345/callback)." and "Use the scopes the server requests or advertises for this registration."; in crates/oauth_callback_server/src/oauth_callback_server.rs, "the default ephemeral-port http://127.0.0.1:<port>/callback"; in crates/settings_ui/src/pages/mcp_servers_page.rs, the buttons "Authenticate" and "Log Out"; in crates/agent_ui/src/agent_configuration/configure_context_server_modal.rs, the template name "some-remote-server", "Uncomment to use a pre-registered OAuth client.", "The URL of the remote MCP server" and the button "Configure Server"; in assets/settings/default.json, "default_profile": "write", "enable_all_context_servers": true in the Write profile, "We don't know which of the context server tools are safe for the "Ask" profile, so we don't enable them by default." and "enable_all_context_servers": false in the Minimal profile; in crates/settings_content/src/project.rs, pub context_servers: HashMap<Arc<str>, ContextServerSettingsContent>, among the project settings; in crates/project/src/context_server_store.rs, ContextServerConfiguration::Http { .. } => false, where Zed decides whether a server runs on the remote host; and in crates/agent_servers/src/acp/v2.rs, acp::McpServerHttp::new(name, url.to_string()).headers( for the servers forwarded to an external agent; Zed issues #63564, open, read 2026-11-08: "OAuth sessions for remote MCP servers are persisted using only the canonical MCP server URL." and "Two context server configurations with different IDs but the same canonical URL therefore load the same OAuth session.", and #66640, open, opened 2026-11-07 on Zed v1.27.0, read 2026-11-08: "If an HTTP MCP server uses OAuth and has no static headers in settings.json, Zed forwards only url with empty headers." and "The external agent then calls initialize without an Authorization header, receives 401 Unauthorized, and aborts the session." From host documentation, not verified live.

Raycast

Raycast is a launcher with Raycast AI, on macOS, Windows and iOS. Its MCP servers are a Pro feature and give their tools to AI Chat, Quick AI and AI Commands; on a Raycast Teams plan, Raycast's pricing includes Raycast AI in Teams Pro, which has everything in Pro, and not in Teams Free. Mnemoverse is listed in Raycast's own Model Context Protocol Registry extension, which installs it as a local server that runs the mcp-remote bridge through npx. The bridge forwards to https://mcp.mnemoverse.com/mcp and signs in in your browser, returning to a localhost address, which the Mnemoverse sign-in accepts (which clients can sign in), so it needs no key. The registry extension is for macOS only; on Windows and iOS, or without Node.js, connect with an API key as described below.

From the registry (macOS):

Install Node.js 20.18.1 or later, which provides npx; the bridge needs it.
In Raycast, install the Model Context Protocol Registry extension from the Raycast Store and open its Search Servers command.
In the Select Registry dropdown, choose Official, then search for Mnemoverse.
Open the Action Panel on the Mnemoverse entry and choose Install Server → Raycast. Raycast opens its MCP installation form filled in from the entry: check that Transport is Standard Input/Output, Command is npx and Arguments are -y mcp-remote https://mcp.mnemoverse.com/mcp, then press Install MCP Server (⌘↵).
Raycast starts the server right away, and on first start the bridge opens the Mnemoverse sign-in in your browser: sign in to your Mnemoverse account and approve the request.
Search Manage MCP Servers in Raycast and check that Mnemoverse is Running, with the memory tools in its tool list.
In AI Chat or Quick AI, type @ and the server's name, then ask it to call memory_stats. A result with your memory's counts shows that Raycast reaches your memory; Verify on any host checks a save and a recall.

If the server shows Error and its output in the details pane mentions spawn npx ENOENT, check that node --version and npx --version work in Terminal, then restart Raycast; Raycast picks up a changed PATH only after a restart. 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, here Raycast.

With an API key (macOS, Windows and iOS): Raycast also connects to https://mcp.mnemoverse.com/mcp directly as an HTTP server, which in Raycast includes Streamable HTTP (on macOS from v1.100.0), and sends its HTTP Headers on every request, so a key works without Node.js (with an API key).

Create a key for Raycast alone on console.mnemoverse.com and copy it: it is shown only once.
On macOS or Windows, search for the Install MCP Server command, or use the Install New Server action in Manage MCP Servers. On iOS, tap Account Avatar → AI → MCP Servers, then the plus icon in the top right.
Enter Mnemoverse as Name & Icon (on iOS, Name), choose HTTP as Transport (iOS is always HTTP) and enter https://mcp.mnemoverse.com/mcp as URL.
Under HTTP Headers, add the key Authorization with the value Bearer mk_live_YOUR_KEY: the word Bearer, a space, then the whole key.
Press Install MCP Server (⌘↵, or Ctrl↵ on Windows), or on iOS tap Save. Check the server and call memory_stats as in steps 6 and 7 above; on iOS, the server's row under MCP Servers shows its tool count, or an error message if the connection failed.

Raycast's manual does not say whether OAuth Type can stay unset when the header carries the key, and this route has not been run from Raycast.

With the local package instead (macOS and Windows): on a computer with Node.js 18 or later, choose Standard Input/Output as Transport, enter npx as Command and -y @mnemoverse/mcp-memory-server@latest as Arguments, and add MNEMOVERSE_API_KEY with your key under Environment.

The registry entry connects Raycast to the memory of the Mnemoverse account you signed in with. A key reads and writes the whole memory of the account it was created in; give Raycast its own key, so revoking it in the console stops only this connection. Raycast runs MCP tools under the same Permissions setting as AI Extensions: by default it approves read-only tools on its own and asks you about the rest. Optionally, paste the memory rules from Make Your Agent Use Memory into the server's Custom Instructions, which Raycast AI reads whenever it considers using the server's tools. In Raycast for Enterprise, Managers can set up MCP servers for the whole organization under Manage MCP Servers in Organization Settings, and every enabled server is available to all members, so a key a Manager puts in a server's Environment Variables serves every member, all in that key's one memory (what one key shares). Raycast's Enterprise features are not yet in Raycast for Windows. Raycast can also sign in to an HTTP server itself (OAuth Type Dynamic), and Raycast 2.0 added loopback OAuth redirects, but Raycast's manual does not name the callback of that sign-in and it has not been run with Mnemoverse, so these steps use the bridge or a key. This entry has not been run from Raycast.

Sources: Model Context Protocol, Raycast Manual, read 2026-11-08: "Pro Exclusive", "Once a server is connected, its tools become available to AI Chat, Quick AI, and AI Commands", "To add a new MCP server, search for the Install MCP Server command or use the Install New Server action in the Manage MCP Servers command then fill out the form.", "Name & Icon: How the server appears in lists, mentions, and the Action Panel.", "Transport: Standard Input/Output or HTTP. iOS is always HTTP.", "HTTP: A remote endpoint that speaks MCP over HTTP (including the Streamable HTTP variant).", "HTTP Headers (HTTP): Key/value pairs sent on every request.", "Command (stdio): The executable to run, e.g. npx or a path to a binary.", "Environment (stdio): Key/value pairs injected into the server's environment, e.g. API tokens.", "Raycast saves the config, starts the connection, and pulls in the tool list automatically.", "Stdio servers run as soon as they're installed; HTTP servers with OAuth will prompt you to Sign In before any tools become available.", "If a stdio command relies on something on your PATH, restart Raycast after updating your environment variables so the new values are picked up.", on iOS "Tap Account Avatar → AI → MCP Servers.", "Choose the OAuth Type and add any HTTP Headers the server needs." and "Tap Save. Raycast connects, prompts you to sign in if the server uses OAuth, and pulls in its tool list automatically.", "Dynamic OAuth uses Dynamic Client Registration with PKCE: select Sign In and Raycast registers itself as a client.", "Search Manage MCP Servers in Raycast to see every installed server with its status, tool list, and details in one place.", "Each server is either Running (connected and serving tools), Stopped (installed but not connected), or in an Error state.", "In AI Chat or Quick AI, type @ and enter the server's name to scope a question to it", "The AI reads these instructions whenever it considers using the server's tools.", "MCP tools follow the same Permissions setting as AI Extensions." and "By default, Raycast approves read-only tools on its own and asks you about the rest."; MCP Servers Configuration, Raycast Manual, read 2026-11-08: "Support for Enterprise features in Raycast for Windows has not yet been added.", "Environment Variables: Key-value pairs for any environment variables the server requires." and "All enabled servers are automatically available to organization members"; Raycast pricing, read 2026-11-08: the Raycast AI row, "Not included" for Teams Free and "Included" for Teams Pro, with no mention of MCP; Raycast for Teams, read 2026-11-08: Teams Pro, "Everything in Pro"; Raycast v1.100.0, read 2026-11-08: "Support for HTTP MCP servers using the SSE (Server Sent Events) and Streamable protocols."; Raycast for Windows changelog, version 2.0, read 2026-11-08: "Added loopback OAuth redirects so MCP providers that reject custom URL schemes, such as Atlassian, can now be connected"; Raycast's Model Context Protocol Registry extension, read 2026-11-08, and its source in raycast/extensions on main, read 2026-11-08: in package.json, "platforms" listing only "macOS" and the command "title": "Search Servers"; in src/registries/builtin/entries.ts, the Mnemoverse entry with command: "npx", and args: ["-y", "mcp-remote", "https://mcp.mnemoverse.com/mcp"],; in src/registries/builtin/configuration.ts, const server = { name: entry.title, description: entry.description };, return { ...server, transport: "stdio", ...entry.configuration }; and "If installation fails with spawn npx ENOENT, check that node --version and npx --version work in Terminal, then restart the client application."; in src/registries/builtin/index.tsx, title="Install Server" and title="Raycast"; in src/registries/index.ts, title: "Official", first in the list; in src/search-servers.tsx, tooltip="Select Registry"; pull requests #31606, "[Model Context Protocol Registry] Add Mnemoverse MCP server", merged 2026-09-26, and #32698, "[Model Context Protocol Registry] Update Mnemoverse: sign in without an API key", merged 2026-10-26, read 2026-11-08; Raycast API changelog, 1.98.0, read 2026-11-08: "New Action.InstallMCPServer to push a MCP installation form"; the mcp-remote README, read 2026-11-08: "To change which host mcp-remote registers as the OAuth callback URL (by default localhost), add the --host flag.", "The default flow needs a browser on this machine and a loopback port to redirect back to", "stores all the credential information inside ~/.mcp-auth", rm -rf ~/.mcp-auth and "Then restarting your MCP client"; mcp-remote 0.16.5 on npm, read 2026-11-08: "undici": "^7.12.0", and undici 7.12.0, read 2026-11-08: "engines":{"node":">=20.18.1"}. Raycast's manual does not name the callback of its Dynamic OAuth. From host documentation, not verified live.

AnythingLLM

AnythingLLM is an AI app that runs on your computer as AnythingLLM Desktop or self-hosted in Docker, and as the hosted AnythingLLM Cloud. Desktop and self-hosted Docker load MCP servers from one file, anythingllm_mcp_servers.json, in the plugins folder of the storage directory; AnythingLLM Cloud does not support MCP. A server entry with a url can send fixed HTTP headers, and AnythingLLM's MCP client runs no sign-in for a server that offers one, so Mnemoverse connects with an API key as a bearer token (with an API key). Remote entries with "type": "streamable" and headers arrived in AnythingLLM v1.8.1; these steps follow v1.19.0.

Create a key for AnythingLLM alone on console.mnemoverse.com and copy it: it is shown only once.
In AnythingLLM, open Settings → Agent Skills once. AnythingLLM creates anythingllm_mcp_servers.json if it does not exist. In multi-user mode only an Admin can open this page.
Open plugins/anythingllm_mcp_servers.json in the storage directory. On AnythingLLM Desktop that directory is C:\Users\<usr>\AppData\Roaming\anythingllm-desktop\storage on Windows, /Users/<usr>/Library/Application Support/anythingllm-desktop/storage on macOS and ~/.config/anythingllm-desktop/storage/ on Linux. In Docker it is the folder set by STORAGE_LOCATION when you start the container.

Add the entry inside the mcpServers object and save:

json

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

Click Refresh on the Agent Skills page: AnythingLLM reloads the servers from the file. Click mnemoverse in the MCP Servers list to see its status; if the connection fails, the error shows in its card.
In a workspace chat, send @agent Using mnemoverse, call memory_stats. If the prompt input shows no @ symbol, every chat is already an agent chat and you can leave out @agent. A result with your memory's counts shows that AnythingLLM reaches your memory; after @agent, send /exit to end the agent session. Verify on any host checks a save and a recall.

Keep "type": "streamable": without a type, AnythingLLM connects a url entry over SSE, and the hosted server is a Streamable HTTP endpoint. Use the header name Authorization with the value Bearer, a space and the whole key, not the X-API-KEY header of AnythingLLM's own example. AnythingLLM sends only the fixed headers in the file; a sign-in for MCP servers is an open feature request on its tracker (#6396).

Who can change the servers: AnythingLLM Desktop has no users, so whoever uses the app can edit its MCP servers. In Docker without multi-user mode, anyone with the instance password can change any setting. In multi-user mode, which only Docker has, AnythingLLM's v1.19.0 source opens the Agent Skills page and every MCP server action (list, reload, start and stop, delete, turning a tool off) to the Admin role alone, although AnythingLLM's role list lets a Manager manage most other settings. The file itself is on the Docker host, so anyone who can write to the STORAGE_LOCATION folder can change it as well.

A key reads and writes the whole memory of the account it was created in, and the file holds it in plain text. MCP servers are shared across all workspaces, and every user and every workspace calls a server with the same static headers, so every workspace, and in multi-user mode every user who runs the agent in one, works in that key's one memory (what one key shares). AnythingLLM's developer API can also use MCP tools in its /chat calls (from v1.8.1), so calls through it reach the same memory. Give AnythingLLM its own key, so revoking it in the console stops only this connection. This entry has not been run from AnythingLLM.

With the local package instead: the npx package runs as a stdio entry under mcpServers. On AnythingLLM Desktop, install Node.js 18 or later and make sure npx is on your PATH, since AnythingLLM does not install commands for MCP servers. The Docker image has npx and node pre-installed, with Node.js 18 in the v1.19.0 image.

json

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

Sources: MCP Compatibility, shown for AnythingLLM v1.19.0, read 2026-11-08: "MCP Servers can be added to AnythingLLM by editing the anythingllm_mcp_servers.json configuration file in your AnythingLLM storage plugins directory.", "Reload/Restart all MCP Servers from the configuration file (if changes are made)", an example "postgres-http" entry with "type": "streamable", "url" and "headers": { "X-API-KEY": "api-key" }, "both sse and streamable require the url field to be set.", "In your configuration file, you can use the type field to specify the transport (sse or streamable). If not provided, sse is assumed." and "The optional headers field can be used to send custom HTTP headers with requests to the MCP server."; MCP on AnythingLLM Desktop, read 2026-11-08: "The configuration file is automatically created if you open the "Agent Skills" page in the AnythingLLM UI and it does not exist.", "by clicking the "Refresh" button in the "Agent Skills" page.", "if there is an error, it will be displayed in the card." and "you must install them manually and also ensure the command is available in your PATH"; MCP on AnythingLLM Docker, read 2026-11-08: "The use of MCP for AnythingLLM Docker is self-hosting only and is not available in the AnythingLLM Cloud service.", "The storage directory is defined by the STORAGE_LOCATION environment variable when you start the AnythingLLM Docker container" and "we have pre-installed the following commands", listing npx and node; Forwarding identity, read 2026-11-08: "MCP servers are shared across all workspaces.", "Every user and every workspace calls your MCP server with the same static headers" and "Desktop has no users."; Storage, read 2026-11-08: "All data pertaining to AnythingLLM Desktop will be in the following locations.", with the Windows, Mac and Linux paths above (the Mac path written there as Application\ Support); AI Agent Setup, read 2026-11-08: "On the Agent Skills page via Settings > Agent Skills"; AI Agent usage, read 2026-11-08: "check to see if the @ symbol is present in the prompt input", "you must mention the agent by @agent", "If this symbol is not present, you are automatically in agentic chat mode with every chat." and "Simply use the slash command /exit to end a agent session"; Security & Access, read 2026-11-08: "These settings are only available in the Docker version of AnythingLLM", "Anyone with the password to the instance, if set, will be able to use the instance, change any configuration or settings, and view all chats." and, for the Manager role, "Can view all workspaces and manage all properties except for settings for LLM, Embedder, and Vector database"; AnythingLLM Cloud Limitations, read 2026-11-08: "in the hosted cloud due to security concerns as well other general limitations to running arbitrary code in a hosted environment."; changelog v1.8.1, read 2026-11-08: "MCP SSE/Streamable support" and "Extended MCP tool use to be included in backend API /chat endpoint calls", and release AnythingLLM v1.8.1, published 2025-05-06, read 2026-11-08: "added sse and streamable stransport support for mcp servers"; AnythingLLM's source at v1.19.0 (published 2026-10-26, commit 9b1fcab141), read 2026-11-08: in server/utils/MCP/hypervisor/index.js, case "streamable": and headers: server.headers,, with default: returning new SSEClientTransport(url, {, and no authProvider; in server/endpoints/mcpServers.js, [validatedRequest, flexUserRoleValid([ROLES.admin])] on each of the five MCP server routes; in server/utils/middleware/multiUserProtected.js, "Apply role permission checks IF the current system is in multi-user mode."; in frontend/src/main.jsx, path: "/settings/agents", with <AdminRoute Component={AdminAgents} />; in frontend/src/components/PrivateRoute/index.jsx, user?.role === "admin" || !multiUserMode; and in docker/Dockerfile, https://deb.nodesource.com/node_18.x nodistro main; AnythingLLM issue #6396, "[FEAT]: Support MCP OAuth2.1 Authorization", open, read 2026-11-08. From host documentation, not verified live.

Cherry Studio

Cherry Studio is an AI workstation for Windows, macOS and Linux. Its Agents use the MCP servers you add under Settings → MCP and then enable for each Agent. Cherry Studio's own example of a remote server sends its key as one Authorization=Bearer line under Advanced Settings → Headers, which is the form the hosted server reads (with an API key), so Cherry Studio connects with a Mnemoverse API key. These steps follow Cherry Studio's documentation at cherryai.com/docs/en as read on 2026-11-08, when the newest release was v2.1.10.

Create a key for Cherry Studio alone on console.mnemoverse.com and copy it: it is shown only once.
Open Settings → MCP → MCP Servers → Add → Quick Create. Enter mnemoverse as the name, select Streamable HTTP (streamableHttp) and enter https://mcp.mnemoverse.com/mcp as the URL.
Under Advanced Settings → Headers, enter one line: Authorization=Bearer mk_live_YOUR_KEY. Use an equals sign between the name and the value, and one space after Bearer, followed by the whole key.
Save the server. A new server starts disabled: switch it on, wait for Connected, then open Tools in the server details. The Mnemoverse memory tools should be listed.
Open Work → the Agent's menu → Edit → MCP, and enable the server for the Agent that should use the memory. Cherry Studio does not bind servers to Agents automatically.
Send a new message, so that the Agent loads the new tools, and ask it to call the Mnemoverse tool memory_stats. A result with your memory's counts shows that Cherry Studio reaches your memory; Verify on any host checks a save and a recall.

From JSON instead of Quick Create: choose Add → Import from JSON, paste this entry and confirm, then continue from step 4. Cherry Studio's documentation names Import from JSON without showing its format; this entry follows the streamableHttp example in Cherry Studio's import dialog (from its source at v2.1.10):

json

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

If it does not connect: Cherry Studio's MCP troubleshooting page puts "401 or 403 errors" down to a "Missing or expired key". Check that the header line reads Authorization=Bearer, a space and the whole key. To replace the key, switch the server off first, change the header, save, switch it on and check the tools again. If the server shows Connected but the Agent cannot find the tools, check under Edit → MCP that the server is enabled for that Agent, then send a new message.

The key reads and writes the whole memory of the Mnemoverse account it was created in, and every Agent you enable the server for works in that one memory. Tool approval follows the Agent's permission mode; check the Auto Approve settings in the server's tool list, and Cherry Studio recommends keeping confirmation on for tools that write. The header field is plain text, and Export as JSON writes headers to mcp-servers.json unchanged, without masking: a key in an exported file reaches whoever imports it, and all of them then work in that key's one memory (what one key shares), so remove the key before you share the file. Give Cherry Studio its own key, so revoking it in the console stops only this connection. This entry has not been run from Cherry Studio.

With the local package instead: Cherry Studio also runs local servers, which take a command, arguments and environment variables. On a computer with Node.js 18 or later, add one with the command npx, the arguments -y and @mnemoverse/mcp-memory-server@latest, and the environment variable MNEMOVERSE_API_KEY set to the key. If Cherry Studio reports command not found for npx, its troubleshooting page puts that down to a runtime that is not installed and says to install it in Settings → Dependencies.

Cherry Studio's documentation does not describe a browser sign-in for MCP servers. Its source at v2.1.10 sets the default sign-in callback to http://127.0.0.1:12346/oauth/callback, a loopback address that the Mnemoverse sign-in accepts on any port (which clients can sign in). That sign-in has not been run from Cherry Studio, so these steps use a key.

Cherry Studio also has an Enterprise Edition, which its README describes with "employee access controls". Its administrator documentation could not be read on 2026-11-08, so this section does not cover how an Enterprise administrator adds MCP servers. If an administrator gives a whole team one Mnemoverse server with one key, everyone it reaches works in that key's one memory (what one key shares).

Sources: MCP and External Tools, read 2026-11-08: "Path: Settings → MCP → MCP Servers → Add.", "The Add menu provides Quick Create, Import from JSON, Import DXT Package, Import MCPB Bundle and Export as JSON.", "To import on the destination, open Import from JSON, paste the file contents and confirm", "Export preserves stored credentials in environment variables, headers, URLs, commands and arguments unchanged, without automatic masking.", "Review the file and remove sensitive information before sharing.", "Local servers need a command, arguments and environment variables; remote servers need a URL, and some also need authorization.", "Open Work → the Agent's menu → Edit → MCP, and enable the server.", for agent binding "Servers aren't bound automatically", for tool approval "Decided by the Agent's permission mode" and "Keep confirmation on for tools that write or cost money"; Connect Baizhi Cloud Browser, read 2026-11-08: "Open Settings → MCP → MCP Servers → Add → Quick Create.", "select Streamable HTTP (streamableHttp)", "Under Advanced Settings → Headers, enter one line.", the line Authorization=Bearer <your-browser-key>, "Do not enter only Authorization=Bearer: add one space after Bearer, followed by the complete key.", "Use an equals sign between the name and value.", "This is a plain text area; do not share the key, screenshots containing it or exported configuration.", "A newly added server starts disabled.", "Wait for Connected, then open Tools in the server details.", "Inspect the tool list and Auto Approve settings." and "Switch the server off before replacing its header."; MCP Troubleshooting, read 2026-11-08: for "401 or 403 errors", "Missing or expired key" and "Environment variables and the provider's account"; for "command not found (uv, bun, npx)", "Runtime not installed" and "Install it in Settings → Dependencies"; and "After changing the Agent configuration, send a new message so it loads the new tools."; the Cherry Studio README, read 2026-11-08: "Cherry Studio is an AI workstation for Windows, macOS, and Linux." and "Cherry Studio Enterprise Edition brings centralized model management, shared knowledge bases, employee access controls, and private deployment options to teams and organizations."; the Cherry Studio releases, read 2026-11-08, with v2.1.10 (2026-10-31) as the latest; Cherry Studio's source at v2.1.10, read 2026-11-08: in src/renderer/pages/settings/McpSettings/AddMcpServerModal.tsx, the import example // Example JSON (streamableHttp): with "type": "streamableHttp", and "Authorization": "Bearer your-token" under "mcpServers"; in src/main/ai/mcp/oauth/provider.ts, return `http://127.0.0.1:${this.config.callbackPort}${this.config.callbackPath}` with the default port 12346 and path '/oauth/callback'. Cherry Studio's English documentation at cherryai.com/docs/en describes neither a browser sign-in for MCP servers nor the steps to bind a server to an assistant. From host documentation, not verified live.

Jan

Jan connects MCP servers from its desktop app, Jan Desktop, over STDIO, HTTP (Streamable HTTP) or SSE. A remote server can carry an Authorization header that you set yourself; Jan then uses that header as-is and does not start its own sign-in, so Mnemoverse connects with an API key as a bearer token (with an API key). Jan Desktop has the Headers field for HTTP and SSE servers from v0.6.9; these steps follow v0.8.8.

Create a key for Jan alone on console.mnemoverse.com and copy it: it is shown only once.
In Jan, go to Settings → MCP Servers and click + Add MCP Server in the top right corner.
Enter mnemoverse as Server Name, choose HTTP as the transport and enter https://mcp.mnemoverse.com/mcp as URL.
Under Headers, enter Authorization as the header name and Bearer mk_live_YOUR_KEY as the header value: the word Bearer, a space, then the whole key. Click Save.
Toggle the server on. Jan lists it with a green indicator when it is active.
Start a chat with a model that has tools enabled (for a local model, turn on tool calling in its model parameters) and ask Using mnemoverse, call memory_stats. Jan asks you to approve each tool call in the chat unless Allow All MCP Tool Permissions is on; approve this one. A result with your memory's counts shows that Jan reaches your memory; Verify on any host checks a save and a recall.

Jan also offers Sign in on a remote server's Auth line. It has not been run with Mnemoverse, so these steps use a key; with the header set, Jan does not start it.

Jan keeps its MCP servers in mcp_config.json in the Jan data folder: %APPDATA%/Jan/data on Windows, ~/Library/Application Support/Jan/data on macOS and ~/.local/share/Jan/data on Linux, unless it was moved under Settings > General > Jan Data Folder. Jan Agent, Jan's terminal agent, reads the same file, so the server and its key work there too. A key reads and writes the whole memory of the Mnemoverse account it was created in. Jan's Local API Server can also run MCP tools for other apps: with Execute Tools on Server on under Settings > Local API Server (it is off by default), Jan itself runs the MCP tool calls of requests to its chat completions endpoint, the Mnemoverse tools included, so every app that calls that server works in this key's one memory, and with Server Host set to 0.0.0.0 so do other devices on your local network (what one key shares). Leave that setting off unless you mean to share the memory this way. Give Jan its own key, so revoking it in the console stops only this connection. This entry has not been run from Jan.

With the local package instead: on a computer with Node.js 18 or later, add the server with STDIO as the transport, npx as the command, -y and @mnemoverse/mcp-memory-server@latest as Args, and under Env the variable MNEMOVERSE_API_KEY with the key as its value. Jan saves Env only for STDIO servers, so the remote entry above takes the key in Headers.

Sources: MCP Servers, read 2026-11-08: "Go to Settings → MCP Servers.", "Click + Add MCP Server in the top right corner.", "Transport: STDIO (local process), HTTP (Streamable HTTP), or SSE (Server-Sent Events)", "Command / URL: the command to run or the server endpoint", "Env: environment variables (e.g. API keys)", "Toggle the server on. It will appear in the list with a green indicator when active.", "Each remote (HTTP / SSE) server shows an Auth line with its current state and the actions that state allows.", "If you set an Authorization header on a server yourself, that credential is used as-is: OAuth is never attempted and never reported as missing, because wrapping it would put two credentials on one request.", "Tokens are stored in mcp_oauth.json in the Jan data folder, next to mcp_config.json and never inside it" and, for Allow All MCP Tool Permissions, "When enabled, all MCP tool calls are automatically approved without showing permission dialogs."; MCP in Jan, read 2026-11-08: "you must approve each tool call individually", "For local models: Enable tool calling in the model parameters" and "Make sure the model you are using has tools enabled"; MCP for Jan Agent, read 2026-11-08: "Jan Agent reads the same mcp_config.json as Jan Desktop, so servers you configured in the app are available in the terminal with nothing further to do." and "If you set an Authorization header by hand, that wins: OAuth is never attempted"; Jan Data Folder, read 2026-11-08: %APPDATA%/Jan/data, ~/Library/Application\ Support/Jan/data, ~/.local/share/Jan/data and "The data folder location can be customised from Settings > General > Jan Data Folder."; Local API Server, read 2026-11-08: "Navigate to Settings > Local API Server", for Execute Tools on Server "(Disabled by default)" and "When enabled, MCP tool calls triggered through the chat completions endpoint (/v1/chat/completions with the default API prefix) are executed server-side rather than being returned to the client to dispatch.", and for 0.0.0.0 "The server is accessible from other devices on your local network (e.g., your phone or another computer)."; release notes of Jan v0.8.8, published 2026-10-28, read 2026-11-08: "Requests to the local API run MCP tools only when Settings > Local API Server allows server-side tool execution."; Jan's source at v0.8.8, read 2026-11-08: in web-app/src/containers/dialogs/AddEditMCPServer.tsx, the labels Headers (for http and sse), URL, STDIO, HTTP and SSE, the placeholders "Header name" and "Header value", and env: transportType === 'stdio' ? envObj : {},; in web-app/src/locales/en/mcp-servers.json, "serverName": "Server Name", "save": "Save", "label": "Auth:" and "authenticate": "Sign in"; in src-tauri/src/core/server/proxy.rs, pub enable_server_tool_execution: bool, and collect_mcp_openai_tools(&mcp_servers, &mcp_settings); the same dialog at v0.6.8 has no Headers label and at v0.6.9 has it, added by Jan pull request #6188, merged 2025-08-18, read 2026-11-08: "Added support for streamable_http_client transport with configurable headers and connection timeout settings". From host documentation, not verified live.

Msty Studio

Msty Studio is a desktop app for local and online AI models. Its Toolbox connects MCP servers, remote ones over Streamable HTTP, and a remote server can use a bearer token or OAuth. Msty's documentation does not name the address its OAuth sign-in returns to, and the Mnemoverse sign-in accepts callbacks only on listed hosts, so Msty connects with an API key as a bearer token (with an API key). These steps follow Msty's documentation for Msty Studio Desktop 3.x.

Create a key for Msty alone on console.mnemoverse.com and copy it: it is shown only once.
In Msty Studio, open Toolbox and select Tools. Choose Add New Tool and enter Mnemoverse as the name.
Select HTTP, enter https://mcp.mnemoverse.com/mcp as the MCP Server URL, choose the bearer token under Authentication and enter mk_live_YOUR_KEY.
Use Test tool to check the connection, then Save.
Put the tool in a toolset: in Toolbox, select Toolsets, then Add New Toolset, select the Mnemoverse tool and save the toolset. In a conversation, select that toolset from the conversation's toolsets control and use a model that supports tool calling.
Check the connection with Verify on any host.

The hosted server accepts a key only in the header Authorization: Bearer mk_live_YOUR_KEY (with an API key). Msty's pages show no header line: they name a bearer token as an option but do not say whether its field takes the key alone or the word Bearer and the key, so step 3 enters the key alone. If Test tool fails, read the error in the tool's console, enter Bearer mk_live_YOUR_KEY in the same field and test again. Desktop users stay on 2.x until they choose the 3.x track, and the 2.x form has a separate Headers field: there, add the header Authorization with the value Bearer mk_live_YOUR_KEY.

Msty's pricing page lists Toolbox - MCP Tools as "Limited" on the Free plan and as included on Aurum and Enterprise & Teams, and does not say what the limit is. The 3.x install page names builds for macOS and Windows; the download links on Msty's Studio page also include Linux builds, an AppImage and a .deb. Msty Studio Web, the browser app at msty.studio, stays on 2.x and uses the Toolbox only when it is connected to Studio Desktop through Remote Connections or Sidecar.

On the Enterprise & Teams plan, an admin chooses which features each team can use, and Toolbox is one of them, so the Toolbox may be off for your team. Msty's changelog lists toolbox sharing, for tools, toolboxes and live contexts, among the Enterprise features of 2.5.0, and its pages do not say whether a shared tool keeps its key. A Mnemoverse tool shared with a key in it would put everyone who imports it in that key's one memory (what one key shares); share it only for a memory the team means to share.

A key reads and writes the whole memory of the Mnemoverse account it was created in. If you turn on Msty's Remote Tools, which makes desktop tools available to a remote Msty connection, that connection uses the Mnemoverse tool in the same memory; Msty's page says the copied connection URL includes the connection token and should be treated like a credential. This entry has not been run from Msty.

The npx package also runs as a STDIO / JSON tool when Node.js is installed on the desktop: Msty's page says the command and its dependencies must be available there. In step 3, select STDIO / JSON instead and paste this configuration. Msty's 2.x page shows one JSON object with command, args and env, the form below; the 3.x page does not show a format.

json

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

Sources: Connect MCP tools, read 2026-11-08: "Open Toolbox and select Tools.", "Choose Add New Tool and give it a name.", "Select HTTP for a server URL, or STDIO / JSON for a command-based server configuration.", "For HTTP, enter MCP Server URL and the authentication method required by the server.", "Options include a bearer token and OAuth.", "For STDIO, paste the server's configuration. Its command and dependencies must be available on the desktop.", "Use Test tool to check the connection, then Save.", "Add the server to a toolset, then select that toolset in the conversation.", "Use a model that supports tool calling." and "Use the tool's console to inspect errors."; Build a toolset, read 2026-11-08: "In Toolbox, select Toolsets, then Add New Toolset." and "Select the toolset from a conversation's toolsets control."; Msty Studio 3.x, read 2026-11-08: "Msty Studio brings local and online AI models, conversations, agents, and reusable resources into one desktop app.", "These guides cover Msty Studio Desktop 3.x." and "The browser app at msty.studio remains on 2.x"; Install and upgrade, read 2026-11-08: "On macOS, choose the build for Apple Silicon or Intel.", "Windows also has separate x64 and ARM64 builds." and "2.x users remain on the 2.x update line until they explicitly select the 3.x track."; Remote Tools, read 2026-11-08: "Make desktop tools and local models available to a remote Msty connection.", "This feature requires access to Remote Tools on your plan." and "The copied URL includes the connection token. Treat it like a credential and keep it out of screenshots, shared chats, and public documents."; Tools (2.x documentation), read 2026-11-08: "Msty Studio supports local MCP server that run on your machine as well as remote MCP servers that can be connect to over Streamable HTTP.", "If HTTP is selected, enter the MCP Server URL endpoint. Also, enter any Authentication and Headers needed to connect to the MCP server.", "If STDIO / JSON is selected, enter the Tool Configuration in JSON format.", "The configuration should be a valid JSON object.", an example object with "command", "args" and "env", and "To utilize the Toolbox features with Msty Studio Web, you must have Studio Web connected to Studio Desktop using Remote Connections or Sidecar."; Manage Teams (2.x documentation), read 2026-11-08: "Teams allow you to group users and assign access to features, platforms, models, and storage options." and "select which features the team members can access", with Toolbox in that list; Pricing, read 2026-11-08: "Toolbox - MCP Tools", "Limited" in the Free column, and the plan "Enterprise & Teams", "Team control, access management, and enterprise deployment support."; Msty Studio, read 2026-11-08, for the Linux AppImage and .deb download links; Msty Studio changelog, read 2026-11-08: "Toolbox sharing (tools, toolboxes, and live contexts)" under Enterprise Features in 2.5.0 (2026-02-18) and "Improved packaged Linux app icon support" in 3.0.0 Beta 7 (2026-08-19). The pages name neither the callback of Msty's OAuth nor whether its bearer token field takes the key alone, and none of them says what "Limited" means. From host documentation, not verified live.

Figma

Figma lets the Figma agent and Figma Make use a custom MCP connector: any remote MCP server, added by URL, on the Professional, Education (not K-12), Organization and Enterprise plans, with edit access to the file. Figma signs in to such a server through the server's own OAuth by default, but its sign-in returns to https://www.figma.com/oauth/mcp/callback, which is not on the Mnemoverse sign-in allowlist (which clients can sign in), so connect with an API key in a custom request header.

Create a key for Figma alone on console.mnemoverse.com and copy it: it is shown only once.
In a Figma chat, click Add context, hover over Connectors and select Manage. Open the Created by you tab and click Create.
Enter Mnemoverse as the Name and https://mcp.mnemoverse.com/mcp as the MCP server URL.
Open Advanced settings and choose custom request headers: add the header Authorization with the value Bearer mk_live_YOUR_KEY, the word Bearer, a space, then the whole key. Click Create.
Click Connect on the connector, then review its Read and Write tools. Figma turns off tools that write to an external source by default, so enable the writing tools, such as memory_write, if the agent should save.
In a chat, type @ and pick Mnemoverse, then ask it to call memory_stats. A result with your memory's counts shows that Figma reaches your memory; Verify on any host checks a save and a recall.

Each tool can be set to Ask to run, Always run or Never run. A custom connector is visible only to the person who created it. On the Organization and Enterprise plans an admin can publish it to the whole organization, and Figma publishes its custom request headers with it, so every member then works in that one key's memory (what one key shares). Give Figma its own key, so revoking it in the console stops only this connection. The Figma agent and Figma Make do not support local or stdio MCP servers, so the npx package is not a route here. This entry has not been run from Figma.

Source: Create and use custom MCP connectors in the Figma agent and Figma Make, Figma Learn, read 2026-11-10: "Professional, Education (not K-12), Organization, and Enterprise plans", "Requires edit access to the file", "Custom connectors allow you to connect the Figma agent and Figma Make to any remote Model Context Protocol (MCP) server.", "In the prompt box in a chat, click Add context. Hover over Connectors, then select Manage.", "Navigate to the Created by you tab and click Create.", "Enter the MCP server URL, then click Create.", "If needed, click Advanced settings and enter the relevant details to customize authentication.", "Click Connect on the connector to authenticate.", "Review the available Read and Write tools and enable the ones you want to use.", "A custom connector is visible only to its creator. On Organization and Enterprise plans, admins can publish custom connectors to the organization.", "When registering your OAuth app, enter https://www.figma.com/oauth/mcp/callback as the callback URL.", "Uses static headers sent with every request to authorize.", "When an organization admin publishes a custom connector that uses custom request headers, the headers are published with it.", "Tools that can write to external sources are disabled by default.", "type @ in the chat to see a list of connected connectors" and "The Figma agent and Figma Make don't support local (localhost) or stdio MCP servers." From host documentation, not verified live.

Mistral Vibe Work

Vibe Work, Mistral's assistant at chat.mistral.ai and formerly Le Chat, adds remote MCP servers as custom connectors. Only an administrator can add one; on the Free, Pro and Student plans the account owner is the administrator. Vibe detects OAuth on the Mnemoverse server, and Mistral's callback is on the Mnemoverse sign-in allowlist (which clients can sign in), so the connector signs in with your Mnemoverse account and needs no key. An API key as a bearer token works too (with an API key).

In Vibe, open Context → Connectors, click New connector and choose Add custom connector.
Enter Mnemoverse as the Connector name and https://mcp.mnemoverse.com/mcp as the Server.
Under Authentication, Vibe selects OAuth2.1 for this server. Keep it, click Add connector, then sign in to Mnemoverse and approve the access.
Vibe shows Connection successful and lists the memory tools on the connector page. Click Try now and ask it to call memory_stats: a reply with your memory's counts shows that Vibe reaches your memory; Verify on any host checks a save and a recall.

With an API key instead. Create a key for Vibe alone on console.mnemoverse.com and copy it: it is shown only once. In step 3, change OAuth2.1 to API Token Authentication, keep Bearer next to Authorization header value, paste the key into Token and click Add connector. Vibe stores the key as the connector's default connection, so whoever uses that connection reads and writes the memory of the account the key belongs to (what one key shares). Give Vibe its own key, so revoking it in the console stops only this connection.

On the connector page, the tools that write are under Interactive and set to Ask, so Vibe asks before each call; the read-only tools are under Read-only and set to Allow. Custom connectors do not support resources or automatic prompt templates yet, so the setup_memory prompt does not reach Vibe: paste the rules from Make Your AI Agent Actually Use Persistent Memory into Vibe's custom instructions. Verified live on 2026-11-13: the connector was added with the sign-in, the connection shows Valid, and the connector page lists the memory tools under Interactive and Read-only. Verified live on 2026-11-09 on a Free plan account: the connector was added with an API key, and memory_stats was called from a chat.

Source: MCP Connectors, Mistral Docs, read 2026-11-10: "point Work at your own MCP-compatible server. Both require an administrator.", "On Free, Pro, and Student plans, the account owner is the administrator by default.", "HTTP Bearer Token / Basic Auth: for servers that require credentials in the Authorization header." and, under "Current limitations", "Resources" and "Automatic prompt templates". The labels Context, Connectors, New connector, Add custom connector, Connector name, Server, Authentication, OAuth2.1, API Token Authentication, Authorization header value, Bearer, Token, Add connector, Connection successful, Interactive, Ask, Read-only, Allow and Try now, and the note "The header value you provide will be stored as a default connection for this connector.", are from Vibe's interface on 2026-11-09, and Valid is from it on 2026-11-13.

Any other MCP client

Any client that speaks MCP (Cline, Visual Studio, JetBrains IDEs, Zed, Raycast, AnythingLLM, Cherry Studio, Jan, Msty Studio, Figma and Mistral Vibe Work have their own sections, 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 (for example mcpServers, or servers in a VS Code style mcp.json):

json

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

json

{
  "mcpServers": {
    "mnemoverse": {
      "command": "npx",
      "args": ["-y", "@mnemoverse/mcp-memory-server@latest"],
      "env": {
        "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY",
        "MNEMOVERSE_API_URL": "https://core.mnemoverse.com/api/v1"
      }
    }
  }
}

Verify on any host

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

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

Install by host ​

Choose your app ​

Package and compatibility reference ​

Summary ​

Claude Code ​

Claude Desktop ​

Cursor ​

Cursor on the web and Cloud Agents ​

VS Code and Copilot Chat ​

GitHub Copilot CLI ​

GitHub Copilot cloud agent ​

Gemini CLI ​

Kimi Code ​

ChatGPT and Codex ​

Kiro ​

Hermes Agent ​

OpenClaw ​

Grok ​

NanoClaw ​

OpenHands ​

Dust ​

AWS Quick (formerly Amazon Quick) ​

Langdock ​

Perplexity ​

Mistral Vibe ​

Make ​

UiPath ​

Devin (hosted) ​

Replit connectors ​

Warp ​

Google Antigravity ​

OpenCode ​

Pi ​

Kilo Code ​

Qoder ​

Goose ​

Qwen Code ​

Augment (Auggie CLI) ​

Amp ​

Crush ​

Factory Droid ​

Trae ​

LobeHub ​

Bolt ​

Cline ​

LibreChat ​

LM Studio ​

TypingMind ​

LangSmith Fleet ​

ElevenLabs Agents ​

Dify ​

Relevance AI ​

Lindy ​

Gumloop ​

Vapi ​

Microsoft Copilot Studio ​

Zapier Agents ​

Voiceflow ​

Retell AI ​

Manus ​

Lovable ​

Glean ​

Open WebUI ​

Alternative: mcpo as an OpenAPI tool server ​

Visual Studio ​

JetBrains IDEs ​

Zed ​

Raycast ​

AnythingLLM ​

Cherry Studio ​

Jan ​

Msty Studio ​

Figma ​

Mistral Vibe Work ​

Any other MCP client ​

Verify on any host ​

Related ​

Install by host

Choose your app

Package and compatibility reference

Summary

Claude Code

Claude Desktop

Cursor

Cursor on the web and Cloud Agents

VS Code and Copilot Chat

GitHub Copilot CLI

GitHub Copilot cloud agent

Gemini CLI

Kimi Code

ChatGPT and Codex

Kiro

Hermes Agent

OpenClaw

Grok

NanoClaw

OpenHands

Dust

AWS Quick (formerly Amazon Quick)

Langdock

Perplexity

Mistral Vibe

Make

UiPath

Devin (hosted)

Replit connectors

Warp

Google Antigravity

OpenCode

Pi

Kilo Code

Qoder

Goose

Qwen Code

Augment (Auggie CLI)

Amp

Crush

Factory Droid

Trae

LobeHub

Bolt

Cline

LibreChat

LM Studio

TypingMind

LangSmith Fleet

ElevenLabs Agents

Dify

Relevance AI

Lindy

Gumloop

Vapi

Microsoft Copilot Studio

Zapier Agents

Voiceflow

Retell AI

Manus

Lovable

Glean

Open WebUI

Alternative: mcpo as an OpenAPI tool server

Visual Studio

JetBrains IDEs

Zed

Raycast

AnythingLLM

Cherry Studio

Jan

Msty Studio

Figma

Mistral Vibe Work

Any other MCP client

Verify on any host

Related