Source: https://mnemoverse.com/docs/api/install-by-host Content revision: 9f8c15bd8f7b67e799088260407024a266e2ac02e3214aa16471fc8ecbb3f801 Updated: 2026-11-05T22:49:12Z # 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](https://mnemoverse.com/docs/api/chatgpt) | Install the published Mnemoverse Memory plugin, then sign in in your browser. | | [Claude Desktop, web or mobile](https://mnemoverse.com/docs/api/claude-apps#connect-in-one-click) | Open Connect to Claude, confirm the connector, then sign in in your browser. | | [Claude Code](https://mnemoverse.com/docs/api/claude) | Add the hosted server with one command and authenticate in the browser. | | [Cursor](https://mnemoverse.com/docs/api/cursor#add-to-cursor-no-api-key) | Use Add to Cursor, then Connect and browser sign-in. | | [VS Code](https://mnemoverse.com/docs/api/vs-code#keyless-extension-recommended) | Install the Mnemoverse Agent Memory extension and follow its sign-in steps. | | [Codex CLI or IDE](https://mnemoverse.com/docs/api/install-by-host#chatgpt-and-codex) | Add the hosted MCP server and sign in in your browser. | | [Devin Desktop](https://mnemoverse.com/docs/api/windsurf) | Follow the local MCP setup with an API key stored in private client configuration. | | [Your own app, script or backend](https://mnemoverse.com/docs/api/getting-started) | Use the REST API or SDK with a private API key. | Connect only one route per app, then [verify access and any requested save](https://mnemoverse.com/docs/api/install-by-host#verify-on-any-host). If your app is not here, find it in the [full host table](https://mnemoverse.com/docs/api/install-by-host#summary). Installation, sign-in and a successful memory call are separate steps. ## Package and compatibility reference The sections below describe optional packages, host-specific support and manual alternatives. You do not need to compare them before following your app's guide. There are three ways a host gets the memory: 1. **A plugin repository.** [`mnemoverse/claude-plugin`](https://github.com/mnemoverse/claude-plugin) carries an [Agent Plugins 1.0.0](https://agent-plugins.org) manifest (`plugin.json` and `mcp.json` at the repository root), a Claude Code manifest (`.claude-plugin/plugin.json` and `.claude-plugin/marketplace.json`, with the server in `.mcp.json`), and a Kimi Code manifest (`kimi.plugin.json`). Most hosts that read one of these formats install it straight from GitHub; NanoClaw takes it from a local clone. The plugin points at the hosted server `https://mcp.mnemoverse.com/mcp`. On hosts that run a sign-in for a server that comes from a plugin, the sign-in is a browser flow (OAuth 2.1 with PKCE), started on first use or by the host's sign-in command, and there is no API key to paste. Hermes Agent, OpenClaw, NanoClaw and OpenHands load the plugin but run no sign-in for its server; their sections say what to do instead. 2. **A host-native package.** The [Cursor plugin](https://github.com/mnemoverse/cursor-plugin), the [Gemini CLI extension](https://github.com/mnemoverse/gemini-extension), the [VS Code extension](https://marketplace.visualstudio.com/items?itemName=Mnemoverse.mnemoverse-vscode) and the Claude Desktop `.mcpb` bundle from the [mcp-memory-server releases](https://github.com/mnemoverse/mcp-memory-server/releases/latest). 3. **A plain MCP entry.** The remote URL `https://mcp.mnemoverse.com/mcp` in any client that can complete a browser sign-in, or the local package `npx -y @mnemoverse/mcp-memory-server@latest` with an API key from [console.mnemoverse.com](https://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](https://mnemoverse.com/docs/api/agent-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](https://mnemoverse.com/docs/api/mcp-server#tools) page lists every one. ChatGPT is the one declared exception: it does not get `vault_list` ([where each tool works](https://mnemoverse.com/docs/api/tool-availability)). The plugin also carries three commands (`/mnemoverse:remember`, `/mnemoverse:recall`, `/mnemoverse:memory-status`) and seven skills. Commands are a Claude Code feature: most other hosts load only the skills and the MCP server from the plugin, and each section below says what that host loads. The seven skills, from the plugin's `skills/` folder: - `agent-memory-discipline`: the standing rules for when to recall and what is worth saving. It is CC0, names no vendor and works with any memory backend. - `setup`: connecting the server and fixing a sign-in that failed. - `memory-search`: search memory before answering, then rate which recalled memories helped. - `memory-save`: save one decision, preference, correction or lesson as a self-contained fact, never a secret. - `memory-catch-up`: list what was added since a given time, in personal memory or in a shared room (beta). - `memory-onboard`: seed memory with a project's conventions and decisions from its README, CLAUDE.md and AGENTS.md. - `mnemoverse-docs`: for a developer adding Mnemoverse memory to their own app or agent; it picks the form and points to the docs page, and needs no memory tools. The [plugin README](https://github.com/mnemoverse/claude-plugin#what-you-get) 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](https://mnemoverse.com/docs/api/install-by-host#kimi-code). **How to read the Status column** **Shipped** means the package or manifest is published by Mnemoverse and the install path is on its own documentation page. **Verified live** means Mnemoverse ran the sign-in and one memory call (`memory_stats`) through that host's own runtime, on the date the section's Source line gives — not a full model conversation through the host. **From host documentation, not verified live** means the command or steps come from that host's own documentation, or from its source code where the section says so, as read on the date in the section's Source line, and Mnemoverse has not yet run them end to end on that host. **Sign-in verified by replay** means Mnemoverse sent that host's own sign-in requests, taken from its source at the version named, to the production server, completed the sign-in and made memory calls, without running the host application itself. **Needs a live test** means the host's documentation or source shows that the plugin route does not sign in, and this page gives no other route on that host until one has been run. **Not supported by the host** means the host's own documentation rules out the hosted server. If a step does not behave as written, write to [support@mnemoverse.com](mailto:support@mnemoverse.com) with the host name and version. ## Summary | Host | Form | Sign-in | Status | |---|---|---|---| | [Claude Code](https://mnemoverse.com/docs/api/install-by-host#claude-code) | hosted MCP entry (recommended); plugin from `mnemoverse/claude-plugin` for commands and skills | browser, no key | Shipped | | [Claude Desktop](https://mnemoverse.com/docs/api/install-by-host#claude-desktop) | custom connector ([Connect to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Mnemoverse&connectorUrl=https%3A%2F%2Fmcp.mnemoverse.com%2Fmcp), 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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#github-copilot-cli) | `copilot plugin install mnemoverse/claude-plugin` | browser, no key | From host documentation, not verified live | | [GitHub Copilot cloud agent](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#gemini-cli) | `gemini extensions install` from `mnemoverse/gemini-extension` | browser, no key | Shipped | | [Kimi Code](https://mnemoverse.com/docs/api/install-by-host#kimi-code) | `/plugins install` from `mnemoverse/claude-plugin` (`kimi.plugin.json`) | browser, no key | Shipped manifest; install line from host documentation | | [Codex CLI](https://mnemoverse.com/docs/api/install-by-host#chatgpt-and-codex) | 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](https://mnemoverse.com/docs/api/install-by-host#chatgpt-and-codex) | remote MCP server entry only; the extension does not support plugins | browser, no key | From host documentation, not verified live | | [ChatGPT](https://mnemoverse.com/docs/api/install-by-host#chatgpt-and-codex) | published Mnemoverse Memory plugin | browser, no key | Published; fresh Free/mobile installation and runtime not yet verified | | [Kiro](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#dust) | remote MCP server, Spaces → Tools → Add Tool → Add MCP Server | browser, no key | From host documentation, not verified live | | [Amazon Quick](https://mnemoverse.com/docs/api/install-by-host#amazon-quick) | MCP integration, Connectors → Create for your team → Model Context Protocol (MCP) | browser, no key | From host documentation, not verified live | | [Langdock](https://mnemoverse.com/docs/api/install-by-host#langdock) | MCP integration with OAuth 2.0 (Dynamic Client Registration) | browser, no key | From host documentation, not verified live | | [Perplexity](https://mnemoverse.com/docs/api/install-by-host#perplexity) | custom remote connector, Computer → Customize → Connectors | browser, no key | From host documentation, not verified live | | [Mistral Vibe](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#make) | MCP Client app connection, **+ New MCP Server** | browser, no key | From host documentation, not verified live | | [UiPath](https://mnemoverse.com/docs/api/install-by-host#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)](https://mnemoverse.com/docs/api/install-by-host#devin-hosted) | remote MCP server entry, Customize → MCPs → Add custom MCP | browser, no key | From host documentation, not verified live | | [Replit connectors](https://mnemoverse.com/docs/api/install-by-host#replit-connectors) | remote MCP server entry, `+ Add MCP server` | browser, no key | From host documentation, not verified live | | [Warp](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#google-antigravity) | remote MCP server entry in the `mcpServers` config | browser, no key | From host documentation, not verified live | | [OpenCode](https://mnemoverse.com/docs/api/install-by-host#opencode) | remote server entry in `~/.config/opencode/opencode.json` | browser, no key; `opencode mcp auth mnemoverse` starts it by hand | From host documentation, not verified live | | [Pi](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#goose) | `goose://extension` link, or a `streamable_http` extension | browser, no key | From host documentation, not verified live | | [Qwen Code](https://mnemoverse.com/docs/api/install-by-host#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)](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#amp) | `amp mcp add`, local `amp.mcpServers` entry | browser, no key | From host documentation, not verified live | | [Crush](https://mnemoverse.com/docs/api/install-by-host#crush) | `mcp add ... --oauth true` in `crushrc` | browser, no key | From host documentation, not verified live | | [Factory Droid](https://mnemoverse.com/docs/api/install-by-host#factory-droid) | `droid mcp add --type http`, entry in `~/.factory/mcp.json` | browser, no key, through `/mcp` | From host documentation, not verified live | | [Trae](https://mnemoverse.com/docs/api/install-by-host#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)](https://mnemoverse.com/docs/api/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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#lindy) | **Integrations** → **+ Add** → **MCP** | an API key as a bearer token, under **Advanced** in the connect dialog | From host documentation, not verified live | | [Gumloop](https://mnemoverse.com/docs/api/install-by-host#gumloop) | **Customize** → **Connectors** → **Add Custom MCP**, then added to an agent's **Connectors** | an API key as a bearer token: **API Key / Credentials** → **Headers**, `Authorization: Bearer mk_live_...`; Gumloop's sign-in returns to `api.gumloop.com` or `api.gumstack.com`, neither of which is on the allowlist | From host documentation, not verified live | | [Vapi](https://mnemoverse.com/docs/api/install-by-host#vapi) | MCP tool created with `POST https://api.vapi.ai/tool` (`"type": "mcp"`), then added on the assistant's **Tools** tab | an API key as a bearer token in `server.headers`; the Vapi MCP page describes no browser sign-in | From host documentation, not verified live | | [Microsoft Copilot Studio](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/install-by-host#lovable) | chat connector, **Connectors** → **Add custom** → **MCP server** (all plans) | an API key, through **Bearer token or API key**; Lovable's documentation does not name the callback of its default **OAuth** | From host documentation, not verified live | | [Zed and any MCP client](https://mnemoverse.com/docs/api/install-by-host#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](https://mnemoverse.com/docs/api/claude#try-it) explains how to verify a save when you request one. The guide also retains the [local API-key alternative](https://mnemoverse.com/docs/api/claude#local-server-with-an-api-key). **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](https://mnemoverse.com/docs/api/install-by-host#claude-desktop), 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](https://github.com/mnemoverse/claude-plugin#install) and [Claude Code plugin marketplaces](https://code.claude.com/docs/en/plugin-marketplaces), read 2026-09-20; [Install and manage plugins](https://code.claude.com/docs/en/discover-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](https://code.claude.com/docs/en/mcp), read 2026-09-27: plugin servers are registered as "`plugin::`". 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](https://mnemoverse.com/docs/api/claude). [Use MCP servers from claude.ai](https://code.claude.com/docs/en/mcp#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](https://code.claude.com/docs/en/discover-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 @` 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](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Mnemoverse&connectorUrl=https%3A%2F%2Fmcp.mnemoverse.com%2Fmcp)** 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](https://mnemoverse.com/docs/api/remote-mcp-server). **Desktop bundle, API key.** Download `mnemoverse-memory.mcpb` from the [latest release](https://github.com/mnemoverse/mcp-memory-server/releases/latest) 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](https://console.mnemoverse.com). Source: [Getting started with local MCP servers on Claude Desktop](https://support.claude.com/en/articles/10949351-getting-started-with-local-mcp-servers-on-claude-desktop) and the [mcp-memory-server README](https://github.com/mnemoverse/mcp-memory-server#links), read 2026-09-20; [Get started with custom connectors using remote MCP](https://support.claude.com/en/articles/11175166-getting-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](https://claude.com/docs/connectors/building/directory-vs-custom), 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](https://support.claude.com/en/articles/11725091-when-to-use-desktop-and-web-connectors), read 2026-09-29: "Remote connectors work across all Claude surfaces.". The Connect to Claude link has not been run live. ## Cursor MCP needs a paid Cursor plan: Cursor's pricing lists "MCPs, skills, and hooks" from the Individual plan up, and not on Hobby. **Add to Cursor (recommended).** Open [Add to Cursor](https://cursor.com/install-mcp?name=mnemoverse&config=eyJ1cmwiOiJodHRwczovL21jcC5tbmVtb3ZlcnNlLmNvbS9tY3AifQ==) 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](https://mnemoverse.com/docs/api/cursor#add-to-cursor-no-api-key) records the hosted setup check from 2026-09-23 and explains [how to verify a requested save](https://mnemoverse.com/docs/api/cursor#try-it). **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](https://open-vsx.org/extension/mnemoverse/mnemoverse-vscode), 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](https://mnemoverse.com/docs/api/cursor#add-to-cursor-with-an-api-key). On the web and in Cloud Agents, see [Cursor on the web and Cloud Agents](https://mnemoverse.com/docs/api/install-by-host#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](https://cursor.com/docs/plugins) (section on local testing: "put either plugin format in `~/.cursor/plugins/local`"), read 2026-09-20, and [Cursor MCP](https://cursor.com/docs/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](https://cursor.com/docs/mcp) lists only "`http://localhost:8787/callback`" (desktop) and "`https://www.cursor.com/agents/mcp/oauth/callback`" (web and Cursor Agents) and says "Open Customize in the sidebar"; [Pricing](https://cursor.com/pricing): the Individual plan lists "MCPs, skills, and hooks", Hobby does not. Local install steps: from host documentation, not verified live. ## Cursor on the web and Cloud Agents Cursor on the web and Cursor's Cloud Agents take MCP servers from [cursor.com/agents](https://cursor.com/agents), not from the desktop app. Open it, add a server through the **MCP** dropdown with the URL: ``` https://mcp.mnemoverse.com/mcp ``` and sign in in the browser when Cursor asks. The sign-in returns to `https://www.cursor.com/agents/mcp/oauth/callback`, which is on the Mnemoverse sign-in allowlist. Cursor's documentation does not say that `~/.cursor/mcp.json` carries over to the web, so add the server there even if the desktop app already has it. MCP needs a paid Cursor plan, as for the desktop app. Source: [Cloud agents](https://cursor.com/docs/cloud-agent), 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](https://cursor.com/docs/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](https://marketplace.visualstudio.com/items?itemName=Mnemoverse.mnemoverse-vscode) from the Marketplace ([open it in VS Code](https://vscode.dev/redirect?url=vscode%3Aextension%2FMnemoverse.mnemoverse-vscode)), 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](https://mnemoverse.com/docs/api/vs-code). **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](https://code.visualstudio.com/docs/agent-customization/agent-plugins) (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](https://github.com/microsoft/vscode) on 2026-09-22; [VS Code 1.110 release notes](https://code.visualstudio.com/updates/v1_110), 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](https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-plugin-reference) (table "Plugin specification for install command"; which files an Agent Plugins package loads) and [Finding and installing plugins](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/plugins-finding-installing), read 2026-09-20 and again 2026-09-22, and the [CLI command reference](https://docs.github.com/en/copilot/reference/copilot-cli-reference/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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). 1. Create a key for this repository alone on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. Add a repository-level **Agents** secret named `COPILOT_MCP_MNEMOVERSE_AUTH` with the value `Bearer mk_live_YOUR_KEY` ([Configure secrets and variables for Copilot cloud agent](https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/configure-secrets-and-variables)). Only secrets whose names start with `COPILOT_MCP_` reach the MCP configuration. 3. In the repository's **Settings**, click **Copilot** and then **MCP servers** in the sidebar, and enter this in the **MCP configuration** section: ```json { "mcpServers": { "mnemoverse": { "type": "http", "url": "https://mcp.mnemoverse.com/mcp", "headers": { "Authorization": "$COPILOT_MCP_MNEMOVERSE_AUTH" }, "tools": ["memory_read", "memory_list_recent"] } } } ``` 4. Click **Save MCP configuration**. The secret holds the whole header value, `Bearer` and the key, because GitHub's page maps a header either to a secret reference or to a literal string and shows no example that combines the two. The cloud agent calls the tools it is given without asking for approval, and GitHub recommends allowing specific read-only tools. On the hosted server's [server card](https://mcp.mnemoverse.com/.well-known/mcp/server-card.json), 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](https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/configure-mcp-servers), 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](https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/configure-secrets-and-variables), 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](https://docs.github.com/en/copilot/concepts/agents/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](https://mnemoverse.com/docs/api/install-by-host#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](https://github.com/mnemoverse/gemini-extension#install), [Gemini CLI extensions](https://geminicli.com/docs/extensions/) and the [extensions command reference](https://geminicli.com/docs/extensions/reference/) for `update`, read 2026-09-20; [MCP servers](https://geminicli.com/docs/tools/mcp-server/) (the `/mcp auth` command), read 2026-09-27; the [Gemini CLI source](https://github.com/google-gemini/gemini-cli/blob/2fe7c2d3f065dc40ad573d50b2091116f8a4aa18/packages/core/src/tools/mcp-client.ts) 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](https://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](https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/customization/plugins.md) (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](https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/customization/mcp.md), read 2026-09-27: "When OAuth is needed, run `/mcp-config login ` to complete browser-based authorization." [Kimi Code plugins](https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/customization/plugins.md), read again 2026-10-30, section "Installing from GitHub": "`https://github.com//`: Install the latest release; falls back to the default branch if no release exists" and "`https://github.com///tree/`: 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](https://chatgpt.com/plugins/plugin_asdk_app_6ada598cec7c81918b22105edfafcb33) 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](https://mnemoverse.com/docs/api/chatgpt) 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](https://developers.openai.com/plugins/build/plugins) (sections "Add a marketplace from the CLI", "How local marketplaces work", "Plugin structure"), [Plugins](https://learn.chatgpt.com/docs/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](https://developers.openai.com/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](https://github.com/openai/codex) 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](https://help.openai.com/en/articles/12584461-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: 1. Open the **Powers** panel and choose **Add Custom Power**. 2. Select **Import power from GitHub**. 3. Enter `https://github.com/mnemoverse/claude-plugin` and click **Install**. Kiro reads `plugin.json`, the `skills/` folder and `mcp.json`. **Import power from a folder** does the same from a local clone. A power activates when a conversation matches its keywords (for this plugin: `memory`, `agent-memory`, `persistent-memory`, `mcp`, `context`), and only then does Kiro load its MCP tools and skills. The power cannot carry the memory scopes: its `mcp.json` has no field for them, and Kiro manages a power's server itself, so it does not appear in `~/.kiro/settings/mcp.json` and the `oauthScopes` entry above does not change it. The power's server therefore signs in with Kiro's default scopes and cannot use memory. Install the power only if you want its skills; its server is then listed next to the `mcp.json` entry. Source: [Install powers](https://kiro.dev/docs/powers/installation/), [Powers](https://kiro.dev/docs/powers/) (keyword activation) and [MCP configuration](https://kiro.dev/docs/mcp/configuration/) (default scopes and `oauthScopes`), read 2026-09-22; [Install powers](https://kiro.dev/docs/powers/installation/), 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](https://kiro.dev/docs/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 ``` 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:/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"](https://hermes-agent.nousresearch.com/docs/developer-guide/plugins#portable-agent-plugins-v1-packages) and [MCP](https://hermes-agent.nousresearch.com/docs/user-guide/features/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](https://github.com/NousResearch/hermes-agent) (`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](https://docs.openclaw.ai/plugins/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](https://github.com/openclaw/openclaw) (`src/agents/mcp-transport.ts:196-205`, `src/plugins/bundle-mcp.ts:70-74,314-331`, `src/cli/mcp-cli.ts:1029-1039`, `src/agents/mcp-oauth-store.mutations.ts:4`), read 2026-09-23; `mcp add` saving with no network call, `mcp login` printing the authorization URL instead of opening a browser, and the `status` check were confirmed in a local run on Windows, 2026-09-23, up to the sign-in URL; sign-in not completed there. Sign-in and `memory_stats` verified live 2026-09-25 through OpenClaw's own runtime, on macOS, against a test account; the same session confirmed that `openclaw mcp probe` is the command that lists a server's tools. A full model chat through OpenClaw was not run. ## Grok **Grok Build** (the `grok` terminal agent) installs a plugin straight from a GitHub repository: ``` grok plugin install mnemoverse/claude-plugin --trust ``` Without `--trust`, Grok shows the source, warns that installing activates the plugin's hooks, MCP servers and skills, and stops. To pick up the plugin, start a new session or press `r` in the Plugins tab. The first memory call opens the browser sign-in; to start it by hand, open `/mcps`, select the server and press `i`. `grok plugin list` shows what is installed, and `grok plugin update mnemoverse` updates it. Grok reads `plugin.json` at the repository root, loads the `skills/` and `commands/` folders, and takes the server from `.mcp.json`, because the root manifest names no MCP servers. The sign-in runs on a loopback callback, which the Mnemoverse sign-in accepts. Checked live on 2026-10-27 with Grok Build 1.0.70 on Windows: after the install, `/mcps` listed the server under **Plugin: mnemoverse** as needing sign-in; pressing `i` on it opened the browser sign-in, which completed by itself, and a `memory_stats` call through the server succeeded. Grok names the tools with the server in front, so the call shows as `mnemoverse__memory_stats`. A non-interactive run (`grok -p`) does not start the sign-in, so sign in from `/mcps` first. What you get: the hosted server, the three commands and the seven skills. **Grok Bot** documents installing packaged skills and connectors from its **Marketplace** (sidebar, then **Your plugins**, then **Manage plugins and skills**); it does not document installing a plugin from a Git repository. For MCP servers it has no connector list of its own: it runs on a hosted computer and uses the connectors your Cursor team permits, which a team admin manages on the Plugins page of the Cursor dashboard. OAuth tokens stay on Cursor's connector backend. Neither Grok's nor Cursor's documentation gives steps for adding a custom server by URL for Grok Bot, so this page has none. Source: [Plugins](https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/09-plugins.md) (sections "Install and use a plugin", "Manage plugins") in the Grok Build repository, [MCP servers](https://docs.x.ai/build/features/mcp-servers) and [Skills and routines](https://docs.x.ai/grok-bot/skills-routines-and-automations), read 2026-09-22; [Grok Bot for teams and enterprises](https://docs.x.ai/grok-bot/teams-and-enterprises), read 2026-09-27: "There is no separate Grok Bot connector list, and connectors appear as plugins in the app" and "OAuth tokens stay on Cursor's connector backend, and Bots invoke tools without receiving them"; which files Grok reads, and its sign-in callback, were checked in the [Grok Build source](https://github.com/xai-org/grok-build). 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). Create a key on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and put it in place of `mk_live_YOUR_KEY`: ``` ncl groups config add-mcp-server --id --name mnemoverse-key --url https://mcp.mnemoverse.com/mcp --headers '{"Authorization":"Bearer mk_live_YOUR_KEY"}' ncl groups restart ``` `` 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](https://github.com/nanocoai/nanoclaw/blob/main/docs/templates.md) (`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](https://github.com/nanocoai/nanoclaw) (`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](https://docs.openhands.dev/overview/agent-plugins), [Plugins](https://docs.openhands.dev/overview/plugins) (section "Using Plugins") and [MCP](https://docs.openhands.dev/sdk/guides/mcp) (section "MCP with OAuth"), read 2026-09-22; the `auth.strategy="oauth2"` requirement is from the [software-agent-sdk source](https://github.com/OpenHands/software-agent-sdk) (`openhands-sdk/openhands/sdk/mcp/utils.py:182-188`); the MCP page route and the form's fields are from the [OpenHands source](https://github.com/OpenHands/OpenHands) 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](https://docs.openhands.dev/openhands/usage/settings/mcp-settings), read 2026-09-27: "Customize > MCP Servers"; the duplicate-URL check is in the [OpenHands source](https://github.com/OpenHands/OpenHands/blob/47a10808d78561546a02555d0d2c7fa96fa96300/src/components/features/settings/mcp-settings/mcp-server-form.tsx) at `main` 47a1080 (`validateUrlUniqueness`: "ensure URL is unique across both types"), read 2026-09-27; [Plugins](https://docs.openhands.dev/overview/plugins), read again 2026-09-27, documents no way to disable a plugin's MCP server while keeping its skills. OpenHands Cloud: [MCP settings](https://docs.openhands.dev/openhands/usage/settings/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](https://github.com/OpenHands/enterprise/tree/0ff9566f81f83ac9dd472c91aaa09a980ad20e93) 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](https://dust.tt) 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](https://docs.dust.tt/docs/user-documentation/admins/tools-management/adding-an-mcp-server), read 2026-10-06: "navigate to Spaces > Tools … an Add Tool button … an Add MCP Server button", and the callback table under "OAuth (with Dynamic Client Registration)". From host documentation, not verified live. ## Amazon Quick In the [Amazon Quick](https://aws.amazon.com/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://.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](https://docs.aws.amazon.com/quick/latest/userguide/mcp-integration.html), read 2026-10-06 ("choose Connectors. Choose the Create for your team tab. Find and choose Model Context Protocol (MCP)"; "If the authorization server supports Dynamic Client Registration (DCR), then Amazon Quick automatically registers itself"); the callback per region is from the AWS Machine Learning blog post "Integrate external tools with Amazon Quick Agents using MCP" (2026-02-20) and the [regions table](https://docs.aws.amazon.com/quick/latest/userguide/regions.html). From host documentation, not verified live. ## Langdock In [Langdock](https://langdock.com) 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//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)](https://docs.langdock.com/en/using-langdock/guides/integrations/mcp/mcp) ("Enter the endpoint URL of your MCP server", "OAuth 2.0 (Dynamic Client Registration)") and [Bring your own OAuth](https://docs.langdock.com/en/admin/manage-integrations/bring-your-own-oauth) (the callback format), read 2026-10-06. From host documentation, not verified live. ## Perplexity Perplexity adds remote MCP servers as **custom remote connectors**, on the Pro, Max and Enterprise plans. In an Enterprise organization, members can add their own only if an admin allows it. 1. Open **Computer → Customize → Connectors** ([perplexity.ai/computer/connectors](https://www.perplexity.ai/computer/connectors)). Perplexity's help article calls this page **Account settings → Connectors**; on the Pro account we tested, the connectors page was at the Computer route instead. 2. Click **+ Custom connector**, and in the pop-up select **Remote**. 3. Fill in the MCP Server URL `https://mcp.mnemoverse.com/mcp`, Authentication **OAuth**, Transport **Streamable HTTP**, and leave Client ID and Client Secret empty (Mnemoverse supports dynamic client registration). Click **Add**. 4. Click the connector card to start the sign-in; approve the scopes on `auth.mnemoverse.com`. Perplexity returns to `https://www.perplexity.ai/rest/connections/oauth_callback` (Enterprise subdomain: `https://enterprise.perplexity.ai/rest/connections/oauth_callback`); both are on the Mnemoverse sign-in allowlist. A third-party report says Perplexity may refuse a dynamic registration that returns no `client_secret`; the Mnemoverse sign-in registers public clients without one, so only a live run will show whether Perplexity accepts it. Source: [Adding Custom Remote Connectors](https://www.perplexity.ai/help-center/en/articles/13915507-adding-custom-remote-connectors), 2026-09-27: a direct fetch returned 403, so the article was read through the r.jina.ai reader: "For your account: Account settings → Connectors", "Click + Custom connector in the top-right corner.", "In the modal pop-up, select Remote.", "Transport — Choose between Streamable HTTP or SSE", "Click the connector card to start the authentication flow and enable it.", "Organization members can add custom remote connectors if admins enable them for the organization", and "The redirect URL to register is: `https://www.perplexity.ai/rest/connections/oauth_callback`". The plans are from Perplexity's [changelog of 13 March 2026](https://www.perplexity.ai/changelog/what-we-shipped---march-13-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](https://community.perplexity.ai/t/custom-mcp-connector-fails-with-did-not-return-a-client-secret-for-rfc-7591-compliant-public-client-registrations/5172), posted 2026-05-18, read 2026-09-27: "[API_CLIENTS_ERROR] Dynamic client registration did not return a client_secret" (a later reply says it started working again; no staff answer). A live attempt on 2026-09-27, on a Pro account, reached the connectors page at `/computer/connectors` (Computer → Customize → Connectors), but the **+ Custom connector** form did not open in two attempts, so steps 2–4 and the sign-in have not been run. From host documentation, not verified live. ## Mistral Vibe Mistral Vibe (the `vibe` terminal agent) adds a hosted OAuth server from inside a session. Name the memory scopes, because the Mnemoverse sign-in grants only the scopes a client asks for: ``` /mcp add https://mcp.mnemoverse.com/mcp --name mnemoverse --scope memory:read --scope memory:write --scope offline_access ``` `/mcp add` starts the browser sign-in by default; the callback is a loopback address, which the Mnemoverse sign-in accepts on any port. If the sign-in did not complete, run: ``` /mcp login mnemoverse ``` `/mcp status` shows the result. Source: the [Mistral Vibe README](https://github.com/mistralai/mistral-vibe/blob/7c19608af06f6c61d63f8f7a5c3430da73fba2ab/README.md) 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](https://github.com/mistralai/mistral-vibe/blob/main/CHANGELOG.md), 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](https://docs.mistral.ai/vibe/code/cli/mcp-servers) page, read 2026-09-27, still says "the CLI does not yet support MCP servers that require OAuth authentication"; the README and changelog are newer. From host documentation, not verified live. **With an API key instead.** The hosted server also accepts a Mnemoverse API key as a bearer token in the `Authorization` header, and the CLI can send one as static authentication. Create a key on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) 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 `. 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](https://docs.mistral.ai/vibe/code/cli/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 `."; the defaults `api_key_header` `"Authorization"` and `api_key_format` `"Bearer {token}"` are from the [configuration reference](https://docs.mistral.ai/vibe/code/cli/configuration-reference), read 2026-10-21; the [Mistral Vibe README](https://github.com/mistralai/mistral-vibe/blob/dd2c04ce717c417731ab89c333cd0a72541e33ba/README.md) 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](https://www.make.com) 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](https://apps.make.com/mcp-client), read 2026-09-24: "some mcp servers may require you to set up a redirect uri for oauth connections if requested, add the following redirect uri in your mcp server settings https://www.make.com/oauth/cb/mcp."; read again 2026-09-27: "click create a connection", "select one of the verified remote mcp servers, or click + new mcp server", "click save", "if prompted, authenticate your account and confirm access", and the modules **Call a tool** and **Execute an action with AI**. From host documentation, not verified live. ## UiPath [UiPath](https://www.uipath.com) 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). **Working path (not verified live).** 1. Create a key on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys). 2. In Orchestrator, store the whole header value in an asset, for example an asset named `MnemoverseAuth` with the value `Bearer mk_live_YOUR_KEY`, so the key is never typed into the server form. 3. On the **MCP Servers** page, select **Add MCP Server**, choose the **Remote** type, and enter a name such as `mnemoverse` (3 to 50 characters; it becomes the last part of the server's Preview URL). 4. Set **Remote URL** to: ``` https://mcp.mnemoverse.com/mcp ``` 5. Under **Headers**, add `Authorization` with the value `%ASSETS/MnemoverseAuth%`. 6. Leave **Connection** empty and select **Add**. UiPath does not forward its own bearer token to the remote server, so the hosted server sees only the header configured here. A **Connection** attached to the server would replace that header with an Integration Service sign-in; this page does not cover that route, because that sign-in has not been checked against Mnemoverse. Source: [Creating a remote MCP Server](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/creating-a-remote-mcp-server) and [MCP Server types](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/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 ` 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](https://devin.ai) is Cognition's AI software engineer. "Hosted" means `app.devin.ai`, the shared SaaS deployment — dedicated and custom-domain Devin deployments use a different API origin and are not covered by this recipe. **Working path.** Open [Customize → MCPs](https://app.devin.ai/customize?tab=mcps), choose **Add MCP**, then **Add custom MCP**, and fill in: | Field | Value | |---|---| | Server Name | `mnemoverse` | | Server URL | `https://mcp.mnemoverse.com/mcp` | | Transport Type | HTTP (Mnemoverse's endpoint is Streamable HTTP; Devin's own docs offer SSE or HTTP and recommend HTTP for new integrations) | | Authentication Method | OAuth | | Access | **Personal** (each member signs in with their own account) or **Organization** (all members share one connection; Devin's docs recommend a service account for it) | | OAuth Credentials | leave blank — Mnemoverse supports Dynamic Client Registration, so no pre-registered Client ID/secret is needed | Click **Save**, then use **Connect** next to the server in Customize → MCPs. Sign-in opens the browser consent screen on `console.mnemoverse.com`; approve the scopes and Devin stores the token for the access chosen above. Source: [Model Context Protocol](https://docs.devin.ai/work-with-devin/mcp), read 2026-09-24: "On app.devin.ai it is `https://api.devin.ai/mcp/oauth/callback`; dedicated and custom-domain deployments use a different API origin."; read again 2026-09-27: "Navigate to Customize > MCPs", "Open Add MCP and choose Add custom MCP", "Access (OAuth only): Choose who uses the authenticated connection", and "For OAuth: Save the configuration, then use Connect in Customize → MCPs to complete authorization." From host documentation, not verified live. ## Replit connectors Replit's browser IDE lets Replit Agent call external services through **connectors**; a custom MCP server is one connector type, separate from Replit's custom API connectors. **Working path.** Open [replit.com/integrations](https://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](https://docs.replit.com/build/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](https://www.warp.dev) 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)](https://docs.warp.dev/knowledge-and-collaboration/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](https://docs.warp.dev/platform/mcp/), [MCP Servers reference](https://docs.warp.dev/reference/cli/mcp-servers/)) 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](https://github.com/warpdotdev/warp/issues/8446), read 2026-09-24: "warp://mcp/oauth2callback?server_id=...". From host documentation, not verified live. ## Google Antigravity [Antigravity](https://antigravity.google) 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](https://antigravity.google/oauth/client-metadata.json), read 2026-09-24: `"redirect_uris": ["https://antigravity.google/oauth-callback"]`, and [MCP](https://antigravity.google/docs/mcp), read 2026-09-24: "ensure the following is registered as a redirect URI in your OAuth provider: `https://antigravity.google/oauth-callback`," and "Antigravity can automatically handle OAuth for servers that support dynamic client registration (DCR). For these servers, no additional configuration is needed."; read again 2026-09-27: **Manage MCP Servers**, **View raw config**, and the global file `~/.gemini/config/mcp_config.json`; read again 2026-10-30, now covering Antigravity CLI: "Antigravity CLI supports both local stdio processes and remote host MCP server configurations.", "Antigravity CLI loads MCP server definitions from two configuration files", "Global configuration: `~/.gemini/config/mcp_config.json`", "Remote MCP servers must use the Streamable HTTP transport. Set the server's endpoint in `serverUrl` (`url` also works).", and "Type `/mcp` inside the prompt panel and press Enter to open the interactive MCP Manager Overlay." From host documentation, not verified live. ## OpenCode [OpenCode](https://opencode.ai) is an open-source coding agent. **Working path.** Add the hosted server to your global OpenCode config, `~/.config/opencode/opencode.json`, as a remote server under `mcp`: ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "mnemoverse": { "type": "remote", "url": "https://mcp.mnemoverse.com/mcp" } } } ``` OpenCode sees that the server needs a sign-in, registers itself through Dynamic Client Registration and asks you to sign in the first time the server is used. To start the sign-in by hand: ``` opencode mcp auth mnemoverse ``` The browser opens; OpenCode waits on the loopback callback `http://127.0.0.1:19876/mcp/oauth/callback`, which the Mnemoverse sign-in accepts on any port. With no `oauth.scope` in the entry, OpenCode asks for the scopes the server advertises, which include `memory:read` and `memory:write`. `opencode mcp list` shows the server and its sign-in state. Source: [MCP servers](https://opencode.ai/docs/mcp-servers/), read 2026-10-13: "OpenCode automatically handles OAuth authentication for remote MCP servers", "Use Dynamic Client Registration (RFC 7591) if supported by the server", "If the server requires authentication, OpenCode will prompt you to authenticate when you first try to use it" and "you can manually trigger the flow with `opencode mcp auth `"; [Config](https://opencode.ai/docs/config/), read 2026-10-13: "Place your global OpenCode config in ~/.config/opencode/opencode.json". The callback is from the [OpenCode source](https://github.com/anomalyco/opencode) at `dev` ecc4916 (`packages/opencode/src/mcp/oauth-provider.ts`: `OAUTH_CALLBACK_PORT = 19876`, `OAUTH_CALLBACK_PATH = "/mcp/oauth/callback"`), and the scope fallback from the MCP TypeScript SDK 1.29.0 that OpenCode pins (`client/auth.js`: `scope || resourceMetadata?.scopes_supported`), read 2026-10-07. From host documentation, not verified live. ## Pi [Pi](https://pi.dev) 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:/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](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/mcp.md) in the Pi repository at `main` 3daa202 (`@earendil-works/pi-coding-agent` 1.2.0), read 2026-10-13: "When the server rejects an unauthenticated connection, `/mcp` shows that it needs sign-in. Select "Sign in", run `/mcp login sentry`, or run `pi mcp login sentry`.", "Pi registers itself with the authorization server", "Otherwise, Pi requests the advertised scopes.", "`callbackPort` uses `http://127.0.0.1:/callback`", the exposure table row "`codemode` (default)" and, for `direct` exposure, "Small, frequently used tool sets."; [CLI](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/cli.md), section "MCP commands", read 2026-10-13: "`pi mcp add [options] --url `" and "`pi mcp login [--timeout ]`". 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](https://kilo.ai) 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](https://kilo.ai/docs/automate/mcp/using-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](https://github.com/Kilo-Org/kilocode) 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](https://qoder.com) 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:/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](https://docs.qoder.com/qoder/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](https://docs.qoder.com/release-notes/qoder), 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](https://goose-docs.ai) 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](goose://extension?url=https%3A%2F%2Fmcp.mnemoverse.com%2Fmcp&type=streamable_http&id=mnemoverse&name=Mnemoverse&description=Mnemoverse%20memory&timeout=300) **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](https://goose-docs.ai/docs/getting-started/using-extensions/), read 2026-10-13: "`goose://extension?url=&type=streamable_http&id=&name=&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](https://qwenlm.github.io/qwen-code-docs/) 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](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist)). Source: [MCP servers](https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/), 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](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/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](https://github.com/QwenLM/qwen-code) 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](https://docs.augmentcode.com/cli/integrations) 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:/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](https://docs.augmentcode.com/cli/integrations), 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 `" and "`-u, --url `"; [Setup Model Context Protocol servers](https://docs.augmentcode.com/setup-augment/mcp), 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](https://ampcode.com) 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](https://mnemoverse.com/docs/api/remote-mcp-server#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](https://ampcode.com/docs/customize/mcp), read 2026-10-13: "Local MCP configuration is stored in `amp.mcpServers`", "Remote MCP definitions are stored by ampcode.com. You can manage them in MCP server settings or with `amp mcp remote`.", "User config (`amp.mcpServers` in `~/.config/amp/settings.json`)", "Some MCP servers like Linear support automatic OAuth client registration.", "When you start the Amp TUI after adding a URL entry to `amp.mcpServers`, Amp will automatically start the OAuth flow in your browser.", "From any other device, the browser ends on a localhost page that fails to load.", under "Manual OAuth Client Registration", "Redirect URI: `http://localhost:8976/oauth/callback`", and, for orbs, "Browser-based OAuth flows are unavailable in orbs.", "use remote MCP definitions, which handle OAuth through ampcode.com" and "Run `amp mcp remote login` to print the ampcode.com OAuth URL." That ampcode.com is on the sign-in allowlist is on the [Remote MCP page](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist). From host documentation, not verified live. ## Crush [Crush](https://github.com/charmbracelet/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:/callback` on the first free port from 40704 to 40713, a loopback address the Mnemoverse sign-in accepts on any port. Source: [README](https://github.com/charmbracelet/crush/blob/main/README.md), 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](https://github.com/charmbracelet/crush/blob/main/docs/config/README.md), 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](https://docs.factory.com/harness/mcp) 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)](https://docs.factory.com/harness/mcp), read 2026-10-13: "`droid mcp add --type `", "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](https://www.trae.ai) 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](https://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](https://docs.trae.ai/ide/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](https://docs.trae.ai/ide/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](https://docs.trae.ai/ide/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](https://lobehub.com) 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](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist), so connect with an API key: 1. Create a key on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. In LobeHub, open **Settings → Connectors**, add an MCP server manually and choose **HTTP Server**. 3. Enter `https://mcp.mnemoverse.com/mcp` as the URL and add the header `Authorization: Bearer mk_live_YOUR_KEY`, or the key as a bearer token if the authentication setting offers it. 4. Turn the connector on for an agent: **Agent Settings → Connectors**, select the server, set the tool permissions and save. Give LobeHub its own key: a key reads and writes the whole memory of its account, and revoking it in the console stops only this connection ([with an API key](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). Source: [MCP Marketplace](https://lobehub.com/docs/usage/community/mcp-market) (`docs/usage/community/mcp-market.mdx` in the [LobeHub repository](https://github.com/lobehub/lobe-chat) 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](https://bolt.new) is an AI app builder in the browser. Its agent uses remote MCP servers through **connectors**, which Bolt includes on its Pro, Teams and Enterprise plans, not on Free. In a shared project, only the project owner can connect MCP servers and prompt Bolt to use them. Connect with an API key: 1. Create a key on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. On the Bolt homepage, click the plus icon in the chatbox, then **Connectors** and **Manage connectors**. On the **Connectors (MCP)** page, click **Custom MCP server**. 3. Enter `mnemoverse` as the name and `https://mcp.mnemoverse.com/mcp` as the URL, choose the `HTTP` transport and the `API key` authentication with `mk_live_YOUR_KEY`, and click **Connect**. Bolt checks the key and shows `Connected` in the upper-right corner. 4. In a project, click the plus icon in the chatbox, click **Connectors** and turn on the toggle next to `mnemoverse`. Bolt's connector page does not name the header that carries the key, and the hosted server accepts a key only as a bearer token ([with an API key](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)), 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](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist). 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](https://support.bolt.new/integrations/mcp), 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](https://support.bolt.new/collaboration/collaborate), read 2026-11-02: "only the project owner can connect MCP servers and prompt Bolt to use those connectors"; [Pricing](https://bolt.new/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](https://console.mnemoverse.com/dashboard/keys); the hosted server accepts it in place of the sign-in ([with an API key](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). This entry has not been run from Cline. Source: [MCP overview](https://docs.cline.bot/mcp/mcp-overview) (`docs/mcp/mcp-overview.mdx` in the [Cline repository](https://github.com/cline/cline) 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](https://www.librechat.ai) 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). A user whose role may create MCP servers adds one in the app, with no restart; an operator adds one for everyone in `librechat.yaml`. These steps follow LibreChat v0.8.8 and later. The API key options arrived in v0.8.2, and from v0.8.2 to v0.8.7 LibreChat sends a server whose users each provide their own key to a sign-in instead of using the key, so on those versions use one shared key. **In the app:** 1. Create a key on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. In the side panel, open **MCP Settings** and click **Add MCP** (the **+** button). If **MCP Settings** or the button is missing, your role may not create MCP servers: an admin turns that on with **Allow users to create MCP servers** under **Admin Settings** in the MCP panel. 3. Enter `Mnemoverse` as **Name**, `https://mcp.mnemoverse.com/mcp` as **MCP Server URL** and choose **Streamable HTTPS** as **Transport**. 4. Under **Authentication**, choose **API Key** in place of the default **None (Auto-detect)**, which finds the hosted server's sign-in and switches the server to it; that sign-in completes only when LibreChat is reached at `localhost` ([which clients can sign in](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist)). Paste the key alone, `mk_live_...` without `Bearer `, which LibreChat adds; or check **Each user provides their own key** so that every user enters theirs through **Configure**. Choose **Bearer** as **Header Format**. 5. Check **I trust this application** and click **Create**. A server created in the app belongs to whoever created it. Other users see it only after the owner shares it from the server's **Edit** dialog, which needs **Allow users to share MCP servers**, off by default for the USER role. **In `librechat.yaml`:** put the key in `.env` as `MNEMOVERSE_API_KEY`, add the entry under `mcpServers` and restart LibreChat: ```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](https://www.librechat.ai/docs/features/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](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/mcp_servers), 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 `", "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](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/mcp_settings), read 2026-11-04: "When configured, only listed domains are allowed."; [LibreChat v0.8.2](https://www.librechat.ai/changelog/v0.8.2): "Includes API key authentication support", and [LibreChat v0.8.8](https://www.librechat.ai/changelog/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](https://github.com/LibreChat-AI/LibreChat) at `main` (v0.8.9-rc1), read 2026-11-04. From host documentation, not verified live. ## LM Studio [LM Studio](https://lmstudio.ai) 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). **With the browser sign-in (LM Studio 0.4.10 and later):** 1. In LM Studio, open **Integrations** (the hammer icon at the top of the right-hand sidebar, or next to the message box) and click **+ Install** → **Edit mcp.json**. LM Studio's own page, written for 0.3.17, calls this the **Program** tab in the right-hand sidebar → **Install** → **Edit mcp.json**. The 0.4 names come from screenshots on LM Studio's bug tracker, not from its documentation. 2. Add the entry, inside the existing `mcpServers` object if the file has one, and save: ```json { "mcpServers": { "mnemoverse": { "url": "https://mcp.mnemoverse.com/mcp" } } } ``` 3. In **Integrations**, turn on `mcp/mnemoverse` for the chat and sign in to Mnemoverse in the browser when LM Studio asks. LM Studio's MCP Integrations page says integrations that require authentication connect without copying tokens or configuring headers. The callback it documents, `http://127.0.0.1:33389/mcp-oauth-callback`, is a loopback address, which the Mnemoverse sign-in [accepts on any port](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist). 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](https://console.mnemoverse.com/dashboard/keys) (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](https://lmstudio.ai/docs/app/mcp), 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 `; [MCP in LM Studio](https://lmstudio.ai/blog/lmstudio-v0.3.17), 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](https://lmstudio.ai/changelog/lmstudio-v0.4.0), read 2026-11-04: "A completely revamped UI experience" and "Updated style for Integrations panel and select"; [Server Settings](https://lmstudio.ai/docs/developer/core/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](https://lmstudio.ai/download), read 2026-11-04: "Experiment with LLMs on your computer."; [MCP Integrations](https://lmstudio.ai/docs/integrations/mcp-remote), 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](https://lmstudio.ai/changelog/lmstudio-v0.4.10), read 2026-11-05: "Add OAuth support for MCP servers"; the empty editor from issue [1699](https://github.com/lmstudio-ai/lmstudio-bug-tracker/issues/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/` toggles from screenshots on that bug tracker, issues 1699 and [2365](https://github.com/lmstudio-ai/lmstudio-bug-tracker/issues/2365) ("In the chat Integrations panel (hammer icon)", LM Studio 0.4.23), and the `~/.cache/lm-studio` location from issue [1371](https://github.com/lmstudio-ai/lmstudio-bug-tracker/issues/1371). From host documentation, not verified live. ## TypingMind [TypingMind](https://www.typingmind.com) 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](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). These steps are for the personal version. 1. Create a key for TypingMind alone on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. In TypingMind, click **Plugins** in the left sidebar. Under **Store**, click **MCPs**, then **+ Add MCP**. The **Add Custom MCP Server URL** page opens. 3. Enter `https://mcp.mnemoverse.com/mcp` as **Server URL** and `Mnemoverse Memory` as **Connection name**. 4. Open **Advanced options**, turn on **Custom HTTP headers** and add a header with the **Header name** `Authorization` and the **Header value** `Bearer mk_live_YOUR_KEY`: the word `Bearer`, a space, then the whole key. Leave the OAuth client settings empty. 5. Click **Create connection**. The new entry shows **Connection Required via Select Connector**: click **Connect**, choose **TypingMind Cloud** in the **Select MCP Connector** dialog and click **Select Connector**. TypingMind Cloud needs a free TypingMind Cloud account; a **Private MCP Connector** that you run yourself works too. 6. When the entry shows **Connected via TypingMind Cloud**, open its **Tools** tab: each tool has its own toggle. 7. In a chat, click the plugin selector next to the model name and turn on **Mnemoverse Memory** under **MCP**. The connector is a server between the TypingMind app and Mnemoverse: with TypingMind Cloud, TypingMind's server relays the requests, the `Authorization` header with them; with a Private MCP Connector, the connector you run on your own computer or server does. A `401` when connecting means the server did not accept the header: check that the name is `Authorization` and the value is `Bearer`, a space and the whole key. The server reads only that form, so a key sent without `Bearer`, or in another header such as `X-Api-Key`, also gets `401`. TypingMind's guides name the entry point in three ways: **Plugins** → **Store** → **MCPs** → **+ Add MCP** in its newest guide, tested on 2026-11-04 and 2026-11-05; **Plugin** → **MCP Connectors** → **Add Connector** in its older integration guides; and **Add custom connector** under the **MCP Store** on its MCP overview page. Its pricing page lists "Unlimited plugins & MCPs" only under the Premium personal license, and its Plans & Pricing page checks "Use unlimited plugins" only for Premium; neither says whether the Standard or Extended license can add an MCP server. The key reads and writes the whole memory of its Mnemoverse account; give TypingMind its own key. The tools that change memory are `memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room` and `memory_join_room`; turn off in the **Tools** tab any that TypingMind should not call. This entry has not been run from TypingMind. In TypingMind Teams, MCP servers are plugins that an admin creates under **Admin Panel** → **Plugins** → **Create New Plugin**, with **Model Context Protocol** as the implementation and the server configuration in JSON. TypingMind's Teams pages show a remote server in that JSON with a URL and no header, so this page has no Teams steps. A key written into a Teams plugin would serve every member the plugin is visible to, all in that key's one memory. On a computer with Node.js 18 or later, the `npx` package also runs through a Private MCP Connector on that computer. In **Settings** → **Advanced Settings** → **Model Context Protocol**, click **Setup Connector**, choose **This Device**, run the command it shows in a terminal and keep the terminal open. Then click **Edit Servers**, add the entry under `mcpServers`, save, and turn the server on under **Plugins**: ```json { "mcpServers": { "mnemoverse": { "command": "npx", "args": ["-y", "@mnemoverse/mcp-memory-server@latest"], "env": { "MNEMOVERSE_API_KEY": "mk_live_YOUR_KEY" } } } } ``` Source: [TypingMind MCP + n8n](https://docs.typingmind.com/model-context-protocol-(mcp)-in-typingmind/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](https://docs.typingmind.com/model-context-protocol-(mcp)-in-typingmind) 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](https://docs.typingmind.com/model-context-protocol-(mcp)-in-typingmind/typingmind-mcp-github), read 2026-11-05: "Go to Plugin → MCP Connectors → Add Connector"; [Use MCP with Private MCP Connector](https://docs.typingmind.com/model-context-protocol-(mcp)-in-typingmind/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](https://docs.typingmind.com/model-context-protocol-(mcp)-in-typingmind/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](https://docs.typingmind.com/quickstart/typingmind-license-plans), read 2026-11-05: "Use unlimited plugins", checked only in the Premium column; [Pricing](https://www.typingmind.com/buy), read 2026-11-05: "Unlimited plugins & MCPs"; [TypingMind Teams - Model Context Protocol (MCP)](https://custom.typingmind.com/features/model-context-protocol), 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](https://docs.typingmind.com/typingmind-team/branding-and-customizations/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](https://docs.langchain.com/langsmith/fleet/index.md) (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](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. Then, for one agent: 1. Open the agent and expand the **Connections** drawer in the sidebar. 2. Click **Add connection**, then **+ Add custom MCP**. 3. Enter `mnemoverse` as the name and `https://mcp.mnemoverse.com/mcp` as the URL. 4. Choose **Static Headers** as the authentication type and add one header: **Key** `Authorization`, **Value** `Bearer mk_live_YOUR_KEY`. Fleet then discovers the memory tools and sends the header both when it lists them and when the agent calls them. To offer the server to every agent in the workspace, add the same entry under **Fleet > Integrations** with **+ Custom MCP**, or under **Settings > MCP servers** with **Add server**, and click **Save server**. The key reads and writes the whole memory of the Mnemoverse account it was created in ([with an API key](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)), so every agent that uses this entry shares that memory; keep the key like a password. Each tool has an approval mode in the **Connections** drawer, **Auto** or **Ask**. The tools that change memory are `memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room` and `memory_join_room`; the rest only read. Fleet stores tool references by server URL, so if you later change the URL of the entry, remove and re-add the Mnemoverse tools in each agent that uses them. Fleet's **OAuth 2.1 (Auto)** option has not been run against Mnemoverse; use the API key. Source: [Remote MCP servers](https://docs.langchain.com/langsmith/fleet/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](https://docs.langchain.com/langsmith/fleet/essentials.md), 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](https://docs.langchain.com/langsmith/fleet/index.md), 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](https://console.mnemoverse.com/dashboard/keys) 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](https://elevenlabs.io/app/agents/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. 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](https://elevenlabs.io/docs/eleven-agents/customization/tools/mcp) 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](https://elevenlabs.io/docs/eleven-agents/api-reference/mcp/create) 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](https://elevenlabs.io/docs/eleven-agents/api-reference/workspace/secrets/create) 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](https://elevenlabs.io/docs/api-reference/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](https://elevenlabs.io/docs/eleven-agents/customization/tools/mcp/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](https://dify.ai) 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). The steps follow Dify Cloud and self-hosted Dify 1.15.0 or later, where MCP servers are under **Integrations**. In earlier versions, such as 1.14.0, they are on the **Tools** page in the top bar. Versions before 1.9.0 have no **Headers** field and cannot send the key. In Dify 1.19.0 the **Add MCP Server (HTTP)** button shows only to members allowed to manage MCP servers, which by default are the workspace owner and admins. 1. Create a key for Dify alone on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. In Dify, open **Integrations**, choose **MCP** in the sidebar and click **Add MCP Server (HTTP)**. 3. Enter `https://mcp.mnemoverse.com/mcp` as **Server URL**, `Mnemoverse` under **Name & Icon** and `mnemoverse` as **Server Identifier** (apps refer to the server by this identifier, so keep it). 4. The dialog opens on the **Authentication** tab. Switch to the **Headers** tab, click **Add Header** and enter `Authorization` as **Header Name** and `Bearer mk_live_YOUR_KEY` as **Header Value**. 5. Click **Add & Authorize**. Dify connects with the header and imports the memory tools. 6. Use the tools in an app: as Tool nodes or inside an Agent node of a workflow or chatflow, or in an Agent app. A legacy Agent app on Dify Cloud stops offering new tools once it has 10, and the memory server has 11, so add the ones the agent needs. Set the header before you click **Add & Authorize**, because Dify connects as soon as the server is added. In Dify 1.19.0 the connection uses the headers when they are present. Dify starts its own sign-in only when the server answers that the request is not authorized. That sign-in returns to the console address of the Dify installation (`cloud.dify.ai` on Dify Cloud), and the Mnemoverse sign-in accepts callbacks only on [listed hosts](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist) and on loopback addresses. So if **Add & Authorize** opens a sign-in page, or ends in an error about registering an OAuth client, instead of listing the tools, Mnemoverse did not accept the key. Check that **Header Value** is `Bearer`, one space, then the key. Dify's documentation names no plan for MCP servers. The key reads and writes the whole memory of the Mnemoverse account it was created in, and every app in the workspace that uses the server uses that one key, whoever is talking to the app. For an app that members of the public use, do not add the tools that change data (`memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room`, `memory_join_room`). The tools that read can still return anything stored in that account to whoever is talking, so attach the memory only to apps whose users may see it. This entry has not been run from Dify. Source: [Dify Tools](https://docs.dify.ai/en/cloud/use-dify/workspace/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 `) 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](https://docs.dify.ai/en/self-host/use-dify/workspace/tools), read 2026-11-04; the interface labels from the Dify repository at release 1.19.0, read 2026-11-04: [tools.json](https://github.com/langgenius/dify/blob/1.19.0/web/i18n/locales/en-US/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](https://github.com/langgenius/dify/blob/1.19.0/web/i18n/locales/en-US/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](https://github.com/langgenius/dify/tree/1.19.0) 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](https://relevanceai.com) 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). 1. Create a key for Relevance AI alone on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. Open the agent and go to the **Tools** tab in the agent builder. Click **Add MCP**, then **Connect my own**. 3. Enter `https://mcp.mnemoverse.com/mcp` as the URL and `Mnemoverse` as the label; tool descriptions show it as `(MCP: Mnemoverse)`. 4. In **Authentication**, choose **Custom headers** and add one header: `Authorization` with the value `Bearer mk_live_YOUR_KEY`, typed in directly rather than through the secrets template the dialog suggests; once saved, the dialog shows it only as "Encrypted for protection - cannot be viewed." The authentication type cannot be changed after the connection is created. 5. Choose the connection mode. The dialog starts on **Per-user connection**, which asks each person who runs the agent to connect their own credentials first, so each of them needs their own Mnemoverse key; **Shared connection** uses this one key for everyone who runs the agent. 6. Click **Connect**. The Mnemoverse card on the **Tools** tab lists the memory tools under **Available tools**. If it shows **No tools available**, check the header first: the name is `Authorization` and the value is `Bearer `, a space and the whole key. To correct it, remove the server with **Remove from Agent** and connect it again. Choose **Custom headers** rather than **Access token / API key**, whose header the dialog does not name, and rather than **OAuth**: Relevance AI completes that sign-in on its own hosts (the app's return address is `https://app.relevanceai.com/oauth-complete/...`), and no Relevance AI host is on the Mnemoverse sign-in's [listed hosts](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist). Do not put the key under **Advanced Options** → **Custom Configuration Headers**: the dialog says those are configuration headers, not authentication headers. Relevance AI's pricing and plan pages do not mention MCP. On Enterprise organizations with role-based access, the **Viewer** and **Chat** project roles cannot create or edit agents, so they cannot add the server. With a shared connection, every run of the agent uses one key, whoever is talking to it, and that key reads and writes the whole memory of its Mnemoverse account. The tools that change data are `memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room` and `memory_join_room`; the rest only read, and they can return anything stored in that account to whoever is talking. If the Mnemoverse card offers **Don't allow** next to each tool under **Available tools**, choose it for those five; if it does not, the agent gets every tool the server lists, so use a shared connection only in agents whose users may read and change that memory. This entry has not been run from Relevance AI. Source: [MCP client](https://relevanceai.com/docs/integrations/mcp/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](https://relevanceai.com/docs/get-started/pricing) and [Plans and credits](https://relevanceai.com/docs/admin/subscriptions/plans), read 2026-11-04, which do not mention MCP; [Role-based access controls (RBAC)](https://relevanceai.com/docs/enterprise/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](https://www.lindy.ai) 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). Lindy's pricing page lists MCP support under "Everything included right out of the box", and MCP is not among the things Lindy's billing page says depend on the plan. 1. Create a key for Lindy alone on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. In Lindy, open **Integrations** in the left sidebar, click **+ Add** and choose **MCP**. 3. In **Connect MCP server**, enter `https://mcp.mnemoverse.com/mcp` as **Server URL** and `Mnemoverse Memory` as **Display name**. 4. Open **Advanced**, leave **Send as** on **Authorization header (Bearer)** and paste `mk_live_YOUR_KEY` into **Bearer token**. 5. Click **Connect**. The server appears with its host and two tool counts; the count of tools available in Lindy should not be zero. The field label suggests that Lindy adds the `Bearer` prefix itself, so paste the key alone; Lindy's page does not write out the header it sends. The Mnemoverse server checks the key before it answers, so if **Connect** fails or starts a sign-in instead of listing the server, the key did not arrive in a form Mnemoverse accepts: copy the whole key again, and if that does not help, enter `Bearer mk_live_YOUR_KEY` in **Bearer token**. Lindy's page does not name the callback of its own sign-in, and the Mnemoverse sign-in accepts callbacks only on [listed hosts](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist), so use the key. Every new connection starts as **Only you**; setting **Availability** to **Your workspace** shares it with everyone in the workspace and with Lindy Teammate, **Guardrails** decide whether Lindy asks before it uses the server, and **Actions** lists every tool with a toggle, all on at first. The key reads and writes the whole memory of its Mnemoverse account, and Lindy's Integrations page says a shared connection acts as the account that connected it, so everyone the connection is shared with uses that one key. Lindy's MCP page says workspace admins "cannot grant it or reconnect the credential on your behalf", so the person who connected the server is the one who shares it. Before you share it, turn off under **Actions** the tools that change data (`memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room`, `memory_join_room`) unless every member should change the memory; the tools that read can still return anything stored in that account to whoever asks Lindy. Do not count on **Guardrails** for this: Lindy's Integrations page says reads are never guarded and guardrails apply in shared Slack threads only. Give Lindy its own key, so revoking it in the console stops only this connection. This entry has not been run from Lindy. Source: [MCP servers](https://docs.lindy.ai/integrations/mcp), 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](https://github.com/lindy-ai/docs/commits/main/integrations/mcp.mdx)); [Integrations](https://docs.lindy.ai/integrations/overview), 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](https://docs.lindy.ai/teammate/setup), read 2026-11-04: "open Integrations in the left sidebar"; [What is Lindy?](https://docs.lindy.ai), read 2026-11-04: "It acts as a personal executive assistant for you and a shared teammate for your team."; [Pricing](https://www.lindy.ai/pricing), read 2026-11-04: "Everything included right out of the box." and "MCP support, connect any tool"; [Billing](https://docs.lindy.ai/teammate/lindy-teammate-billing), read 2026-11-04: "A few things depend on your plan". From host documentation, not verified live. ## Gumloop [Gumloop](https://www.gumloop.com) 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). Gumloop's help lists custom MCP servers on any plan. 1. Create a key for Gumloop alone on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. In Gumloop, select **Customize** in the left sidebar, open the **Connectors** tab and click **Add Custom MCP**. For a connection your team shares, open the team from **Teams** in the left sidebar and choose **Customize** in the team's menu instead: the dialog has no separate choice between personal and team. Gumloop's help says team connectors are added by team owners and members with permission to manage them. 3. In **Connect MCP Server**, enter `https://mcp.mnemoverse.com/mcp` as **MCP Server URL** and click **Connect**. 4. On **Configure**, keep the **Server Name** or enter `Mnemoverse`. **Detected Auth** should read **OAuth 2.0**, because this server publishes its OAuth metadata. Do not click **Authenticate**: open the **Authentication** dropdown and choose **API Key / Credentials**. 5. Under **Headers**, click **Add Header**, enter `Authorization` as the name and `Bearer mk_live_YOUR_KEY` as the value, and click **Connect**. Gumloop connects with the header and discovers the memory tools. 6. Open your agent, click **+ Add** in the **Connectors** section, search for the server, click **+** next to it and click **Save**. Then ask the agent to list its tools. The header value carries the word `Bearer` itself: the **Headers** editor sends a header as you type it. If your dialog shows an **Access Token / API Key** field instead of **Headers**, paste the key there without `Bearer`: Gumloop's Custom MCP servers page says that field is sent as `Authorization: Bearer`. If Gumloop says it could not load the tools, type the header again by hand, because spaces, line breaks or curly quotes from copy and paste break it, and check that the key has not been revoked. Do not send the key as `X-Api-Key` or as a query parameter: the hosted server reads a key only from `Authorization: Bearer`. If Gumloop says the server is already connected in your organization, continue: your connection joins the existing server and keeps its name, so search for that name in step 6. With GPT and Claude models the model provider, not Gumloop, connects to the server with the key. Gumloop's page says Claude models receive the bearer token but do not forward custom headers, and it does not say which of the two a header added under **Headers** counts as; if the tools load but the agent's memory calls fail on a Claude model, switch the agent to a GPT or Gemini model. Gumloop's sign-in returns to `https://api.gumloop.com/auth/callback` or `https://api.gumstack.com/auth/callback`, and neither host is on the Mnemoverse sign-in's [listed hosts](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist), so **Authenticate** would fail. By default a shared Gumloop agent runs the connectors of whoever uses it: a server you add on your own **Connectors** page is yours alone, and a teammate who runs the agent adds the server with a key of their own. One key serves many people in three cases: a team connector, which everyone who runs the team's agents uses; a connector set to **Agent-owned** on the agent, which everyone who can access the agent uses, including people it is shared with; and a Slack channel trigger, which runs the trigger owner's connection for the whole channel. The key reads and writes the whole memory of its Mnemoverse account, and by default Gumloop asks for no approval before a tool runs. For an agent that other people use through one key, open the connector on the agent and turn off the tools that change data (`memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room`, `memory_join_room`); the tools that read can still return anything stored in that account to whoever is talking to the agent. In an organization, an admin's custom roles decide which connectors each group of members can use, and **Agent-owned** stays disabled until an admin grants it. This entry has not been run from Gumloop. Source: [Custom MCP servers](https://docs.gumloop.com/nodes/mcp/custom_mcp_servers), read 2026-11-04: "Select Customize in the left sidebar, then the Connectors tab.", "Click Add Custom MCP in the top-right corner of the page. The Connect MCP Server dialog opens.", "Enter your server's address in MCP Server URL, then click Connect.", "Gumloop probes the server and shows the Detected Auth method. If the server supports OAuth, click Authenticate and sign in to connect your account. Otherwise, open the Authentication dropdown to supply a token, API key, or custom header instead.", "When you provide an Access Token / API Key, Gumloop sends it as an `Authorization: Bearer ` 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?](https://docs.gumloop.com/help/mcp/custom-mcp-wont-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](https://docs.gumloop.com/help/mcp/custom-proxied-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](https://docs.gumloop.com/core-concepts/credentials), 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](https://docs.gumloop.com/help/connectors/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](https://docs.gumloop.com/help/sharing/roll-out-an-agent), read 2026-11-04: "The trigger owner (one shared connection)"; [Give an agent a connector](https://docs.gumloop.com/help/using-agents/give-agent-access-to-a-connector), read 2026-11-04: "Open the connector on the agent and turn off tools you don't want"; the [documentation index](https://docs.gumloop.com/llms.txt), read 2026-11-04, on custom roles: "Control which connectors, tools, and AI models each group of members can access."; the labels **Server Name**, **API Key / Credentials**, **Headers**, **Add Header** and the **Connect** button of the **Configure** step are from the Connect MCP Server dialog of www.gumloop.com as served on 2026-11-04. From host documentation, not verified live. ## Vapi Vapi is a developer platform for voice agents. An assistant gets the tools of a remote MCP server through an MCP tool, and Vapi connects to the server over Streamable HTTP by default. The Vapi MCP page describes a server URL and custom headers for that connection, not a browser sign-in, so this connection uses a Mnemoverse API key as a bearer token. Create a key on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. Create the MCP tool with `POST https://api.vapi.ai/tool`. That request carries your private Vapi API key as `Authorization: Bearer`; the Mnemoverse key goes in the body: ```json { "type": "mcp", "server": { "url": "https://mcp.mnemoverse.com/mcp", "headers": { "Authorization": "Bearer mk_live_YOUR_KEY" } } } ``` Leave `metadata.protocol` unset: its default, `shttp`, is Streamable HTTP. Then open **Dashboard** > **Assistants**, select the assistant, go to the **Tools** tab, select the new MCP tool and click **Publish**. For the MCP tool form in the Dashboard (**Dashboard** > **Tools** > **Create Tool** > **MCP**), the Vapi MCP page names a name, a description and the **Server URL** field, and no header field, so this entry sets the key through the API. The same page also shows the `server` object with `headers` inline in an MCP entry of an assistant's `model.tools`. The key reads and writes the whole memory of the Mnemoverse account it was created in, and every call to every assistant with this tool uses that one key, whoever is on the line. Vapi imports every tool the server exposes and does not filter them per tool, so the tools that change data (`memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room`, `memory_join_room`) come with the rest. Add the tool only to assistants whose callers may read and change that memory. This entry has not been run from Vapi. Source: the Vapi [MCP tools](https://docs.vapi.ai/tools/mcp) page, read 2026-10-26: "Select **MCP** from the available options", "Provide a name and description", "**Server URL**: The URL of your MCP server", "In an API request, configure the same value as `server.url`", "`server.headers`: Custom headers to include in requests to the MCP server", with `"Authorization": "Bearer your-token"` in its example, "`"shttp"` (default): Uses Streamable HTTP protocol", "Go to the **Tools** tab", "Click **Publish** to save your changes" and "Vapi imports the complete tool list exposed by the configured server and does not apply its own per-tool filter"; the [Create Tool](https://docs.vapi.ai/api-reference/tools/create) reference, read 2026-10-26: "POST https://api.vapi.ai/tool", "send it in the `Authorization` header as `Bearer `" and, for the `server` object of a tool, "Configuration for requests Vapi sends to a customer server, including URL, authentication, headers" and "These are the headers to include in the request". From host documentation, not verified live. ## Microsoft Copilot Studio [Microsoft Copilot Studio](https://www.microsoft.com/en-us/microsoft-copilot/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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). MCP needs generative orchestration, which the Teams plan does not have; a trial license can build and test an agent but not publish it. The steps below are for an agent on Copilot Studio's standard harness, which Microsoft's MCP onboarding pages describe. On the Copilot Studio home page, **Other ways to build** creates a standard-harness agent, and **Open classic experience**, under the three dots (…) at the bottom of the side bar, opens existing ones. An agent cannot be moved from one harness to the other. In an agent on the GitHub Copilot harness, MCP servers are added in preview from the **Add a tool** dialog: **Add** next to the search bar, then **Model Context Protocol (MCP)**. Microsoft's page for that path does not list its authentication options, so it is not documented whether it can send the key in an `Authorization` header. 1. Create a key on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. With the default credentials of the person using the agent, each user creates a key of their own (see below); with **Maker-provided credentials**, create a key for this agent alone. 2. In Copilot Studio, open the agent, go to the **Tools** page and select **Add a tool**, then **New tool**. In the **Create new** section, select **Model Context Protocol**. 3. In the wizard, enter `Mnemoverse Memory` as **Server name**, a short description of the memory tools as **Server description** (the orchestrator reads it to decide when to call the server) and `https://mcp.mnemoverse.com/mcp` as **Server URL**. 4. Select **API key** as the authentication type, **Header** as the type of API key and enter `Authorization` as the name of the header. Select **Create**. 5. In the **Add tool** dialog, select **Create a new connection**, enter `Bearer mk_live_YOUR_KEY` as the API key (the word `Bearer`, one space, then the key), create the connection, and then select **Add to agent**. Copilot Studio turns all of the server's tools on. To switch single tools off, select the server on the agent's **Tools** tab and turn off **Allow all**: each tool then gets its own toggle, and tools the server adds later stay off until someone turns them on. The server becomes a Power Platform custom connector in the environment, so a data policy that blocks Power Platform connectors blocks it too. The Copilot Studio MCP page does not say that the key value is sent as typed. The `Bearer` prefix in the value follows the Power Platform custom connector documentation, and the Copilot Studio guides of two other MCP servers, Ahrefs and DataHub, give the same `Authorization` header with `Bearer ` typed before the key. The hosted server accepts a key only as a bearer token, so this route works only if the wizard sends the value in that form. It has not been run from Copilot Studio. Choose **API key** rather than **OAuth 2.0**: Copilot Studio's sign-in returns to a `consent.azure-apim.net` host, and the Mnemoverse sign-in accepts callbacks only on [listed hosts](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist). By default a tool runs with the credentials of the person using the agent. Each user of the agent is asked for a key of their own the first time the agent calls the server, enters it the same way (`Bearer mk_live_…`), and works with the memory of the account that key belongs to. Copilot Studio asks a user for their own credentials only on channels that support user authentication for tools; its list includes Teams, SharePoint and a custom website, and leaves out the demo website and the mobile app, and in Teams it needs single sign-on set up, or authentication fails for every user. If the maker sets **Credentials to use** to **Maker-provided credentials** on the server's page, everyone who uses the agent works with the maker's key, and a key reads and writes the whole memory of the Mnemoverse account it was created in. For an agent shared that way, turn off the tools that change data (`memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room`, `memory_join_room`), or attach the memory only to agents your own team uses. Revoking a key in the console stops only the connections that use it. Source: [Connect your agent to an existing Model Context Protocol (MCP) server](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-add-existing-server-to-agent), 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](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-add-components-to-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](https://learn.microsoft.com/en-us/microsoft-copilot-studio/agent-extend-action-mcp), read 2026-11-04: "You must turn on generative orchestration to use MCP."; [Access standard harness agents and agent flows](https://learn.microsoft.com/en-us/microsoft-copilot-studio/agents-experience/switch-experiences), 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](https://learn.microsoft.com/en-us/microsoft-copilot-studio/agents-experience/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)](https://learn.microsoft.com/en-us/microsoft-copilot-studio/agents-experience/tools-add-mcp-server), 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](https://learn.microsoft.com/en-us/microsoft-copilot-studio/advanced-connectors), 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](https://learn.microsoft.com/en-us/microsoft-copilot-studio/configure-enduser-authentication), 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](https://learn.microsoft.com/en-us/connectors/custom-connectors/define-blank), read 2026-11-04: "For APIs that require bearer authentication, add Bearer and one space before the API key."; [Configure data policies for agents](https://learn.microsoft.com/en-us/microsoft-copilot-studio/admin-data-loss-prevention), 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](https://learn.microsoft.com/en-us/microsoft-copilot-studio/requirements-licensing-subscriptions), 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](https://learn.microsoft.com/en-us/connectors/custom-connectors/azure-active-directory-authentication), 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](https://learn.microsoft.com/en-us/answers/questions/6011085/copilot-studio-mcp-connector-omits-the-rfc-8707-re): "redirect_uri=https://global.consent.azure-apim.net/redirect/" and [2026-10-01](https://learn.microsoft.com/en-us/answers/questions/6023099/copilot-studio-mcp-tool-with-oauth-2-0-dynamic-dis): "Redirect URI: global.consent.azure-apim.net/redirect/", both read 2026-11-04; the Copilot Studio guides of [Ahrefs](https://docs.ahrefs.com/en/mcp/docs/copilot-studio), 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](https://docs.datahub.com/docs/dev-guides/agent-context/copilot-studio), read 2026-11-04: "Include the Bearer prefix in the API key value." From host documentation, not verified live. ## Zapier Agents [Zapier Agents](https://zapier.com/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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). Zapier Agents is an add-on with its own activity limits, and Zapier is moving Agents into the **AI by Zapier** step of the Zap editor, with no date set for turning Agents off; tools in that step need a paid Zapier plan. On a Zapier Enterprise account created on or after 2026-10-05, members can use only apps an admin has allowed, so an admin may first have to allow **MCP Client**. 1. Create a key for Zapier alone on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. In Zapier, open the [Apps](https://zapier.com/app/assets/connections/apps) page, click **+ Add connection**, search for and select **MCP Client**, and click **Add connection**. 3. On the **Connect an Account** page, enter `https://mcp.mnemoverse.com/mcp` as **Server URL**, choose **Streamable HTTP** as **Transport**, set **OAuth** to **No** and enter `mk_live_YOUR_KEY` in **Bearer Token**. Click **Yes, Continue to MCP Client**, then rename the connection so that it includes `Mnemoverse`. 4. In Zapier Agents, open the agent. Under **Tools this agent can use**, click **+ Add Tool**, search for and select **MCP Client**, and select **Run tool**. Then select the added action under **Tools this agent can use**, pick the Mnemoverse connection from the dropdown, choose **Let your agent select a value for this field** for **Tool**, and click **Save**. Zapier's help does not name the header that the **Bearer Token** field fills or say whether Zapier adds the `Bearer` prefix itself, and the hosted server accepts a key only as `Authorization: Bearer`, so enter the key alone first, without `Bearer`. If Zapier asks you to reconnect right after **Yes, Continue to MCP Client**, or the **Tool** field of **Run tool** lists no memory tools, reconnect with the value `Bearer mk_live_YOUR_KEY`. Choose **OAuth: No**: with **Yes**, Zapier ignores the token; the callback host of Zapier's sign-in is not named in its documentation, and no Zapier host is on the Mnemoverse sign-in's [listed hosts](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist). Every run of every agent that uses the connection uses that one key, which reads and writes the whole memory of its Mnemoverse account; give the connection its own key, so revoking it in the console stops only Zapier. The tools that change data are `memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room` and `memory_join_room`; for an agent that should only recall, set **Tool** to a reading tool such as `memory_read` instead of leaving it to the agent. In the **AI by Zapier** step, the same connection is added under **Settings**, **Tools and Knowledge**, with **+ Add tool**: tool type **App action**, app **MCP Client**, action **Run tool** and the Mnemoverse connection as **Account**; tools work only with an **Advanced** or **Premium** model. Zapier's help does not say how a tool's own fields, such as the text to save, reach the server when **Tool** is left to the agent; if the agent cannot fill them, add **Run tool** once for each memory tool it needs, with that tool set as the value of **Tool**. This entry has not been run from Zapier. Source: [Connect remote MCP servers to Zapier using MCP Client](https://help.zapier.com/hc/en-us/articles/38777069364109-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](https://help.zapier.com/hc/en-us/articles/26028298697485-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?](https://help.zapier.com/hc/en-us/articles/26559132765325-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](https://help.zapier.com/hc/en-us/articles/47402591569805-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](https://help.zapier.com/hc/en-us/articles/45863491098893-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](https://help.zapier.com/hc/en-us/articles/8496307974541-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](https://zapier.com/apps/mcp-client-by-zapier/integrations) 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](https://www.voiceflow.com) 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)) kept in a secret. 1. Create a key for Voiceflow alone on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. In the agent, open **Secrets**, click **New secret**, name it `mnemoverse_api_key`, paste the key as its value and choose the **Restricted** visibility. A secret created in one environment has no value in the others until you set it there. 3. Open the **Agent** tab, find **Global tools** in the right editor and click **+**, then choose to add an MCP server. Global tools are used where the agent decides on its own (the agent, its playbooks and crews); a scripted workflow step reaches the memory only through its own MCP step. You can also add the server from a playbook's tools or from a workflow's MCP step; Voiceflow's documentation says servers can be managed centrally in **Settings → MCP servers**. 4. Enter `Mnemoverse` as **Server name** and `https://mcp.mnemoverse.com/mcp` as **Server URL**. Click **+** next to **Headers** and add one header with the key `Authorization` and the value `Bearer {mnemoverse_api_key}`: after `Bearer `, type `{`, switch to the **Secrets** tab of the dropdown and select `mnemoverse_api_key`. 5. Click **Add MCP server**. Voiceflow fetches the memory tools; select the ones the agent should have, and refresh the server later to pick up new ones. A secret that has no value in the current environment is sent as its placeholder text, which the server refuses with `401` and the agent continues without a warning, so set the value in every environment the agent runs in. Voiceflow's documentation does not name the transport of a custom server (the `specification` field of its MCP server API offers the `2025-03-26` and `2025-06-18` revisions of the protocol) and does not say which plans include MCP tools. Every conversation of every agent with this server uses that one key, which reads and writes the whole memory of its Mnemoverse account; for an agent that members of the public talk to, do not select the tools that change data (`memory_write`, `memory_feedback`, `memory_create_room`, `memory_invite_to_room`, `memory_join_room`), and remember that the tools that read can still return anything stored in that account to whoever is talking; or attach the memory only to agents your own team uses. This entry has not been run from Voiceflow. Source: [MCP tool](https://www.voiceflow.com/docs/documentation/build/tools/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](https://www.voiceflow.com/docs/documentation/build/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](https://www.voiceflow.com/docs/documentation/build/data/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](https://www.voiceflow.com/docs/api-reference/mcp-server/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](https://console.mnemoverse.com/dashboard/keys) 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. 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](https://docs.retellai.com/build/single-multi-prompt/mcp) 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](https://docs.retellai.com/build/conversation-flow/mcp-node) 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](https://docs.retellai.com/api-references/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](https://docs.retellai.com/api-references/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](https://manus.im) is a general AI agent. It connects custom remote MCP servers next to its prebuilt connectors, and its page for them names API keys and bearer tokens as the credentials, so Manus connects with a Mnemoverse API key. 1. Create a key for Manus alone on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. In Manus, go to **Settings → Integrations → Custom MCP Servers** and click **Add Server**. 3. Enter `Mnemoverse` as the server name and `https://mcp.mnemoverse.com/mcp` as the server URL, and give `mk_live_YOUR_KEY` as a bearer token under the authentication. 4. Manus checks that it can reach the server and lists its tools. Then mention the memory in a prompt, for example `Using Mnemoverse, recall what we decided about the pricing page.` The Manus page does not show the authentication form or name the header that carries the credential, and the hosted server accepts a key only as a bearer token ([with an API key](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)), 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](https://manus.im/docs/integrations/custom-mcp), 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](https://lovable.dev) is an AI app builder. A custom MCP server joins it as a chat connector: Lovable reads from it in the project chat and in Chats while it builds, on all plans. A chat connection is personal: only the person who connects it can use it, and it never becomes part of the published app. Connect with an API key: 1. Create a key on [console.mnemoverse.com](https://console.mnemoverse.com/dashboard/keys) and copy it: it is shown only once. 2. Open [Connectors](https://lovable.dev/dashboard?connectors), select **Add custom** in the top right of the catalog and choose **MCP server**. If **MCP server** is greyed out, a workspace admin has turned custom MCP servers off. 3. Enter `Mnemoverse` as the server name and `https://mcp.mnemoverse.com/mcp` as the server URL. If a **Connection** dropdown appears, keep **Direct connection**. 4. Choose **Bearer token or API key** as the authentication, enter `mk_live_YOUR_KEY` and click **Add server**. 5. Ask Lovable something the memory can answer, for example `Using the Mnemoverse connector, recall what we decided about the signup flow.` Choose **Bearer token or API key**, not the default **OAuth**: Lovable's documentation does not name the callback of its sign-in, and the Mnemoverse sign-in accepts callbacks only on [listed hosts](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist). 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](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)), 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](https://docs.lovable.dev/integrations/custom-mcp), read 2026-11-03: "Custom MCP servers are available on **all plans**.", "Like all chat connections, they are personal to you, and they are never part of your published app.", "select **Add custom** in the top right of the catalog, and choose **MCP server**", "If **MCP server** is greyed out, a workspace admin has disabled custom MCP servers for your workspace.", "Keep **Direct connection** unless your server is behind a firewall that only accepts traffic from allowlisted IPs.", "**OAuth (default)**: Lovable uses OAuth by default.", "**Bearer token or API key**: For servers that don't support OAuth, authenticate with a bearer token or API key." and "Click **Add & authorize** (OAuth) or **Add server**."; [Chat connectors](https://docs.lovable.dev/integrations/chat-connectors), read 2026-11-03: "only you can use the connection", "Tools the server marks as read-only run without asking. Before any other tool runs, Lovable shows an approval card." and "Select **Always allow** to skip the approval for that tool from then on". Neither page names the header that carries the key or the callback of the OAuth sign-in. From host documentation, not verified live. ## Any other MCP client Zed, JetBrains and any client that speaks MCP (Cline has [its own section](https://mnemoverse.com/docs/api/install-by-host#cline), and Devin Desktop, formerly Windsurf, has [its own page](https://mnemoverse.com/docs/api/windsurf)): - **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](https://mnemoverse.com/docs/api/remote-mcp-server#which-clients-can-sign-in-registration-allowlist). - **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](https://console.mnemoverse.com/dashboard/keys) ([what the key can do](https://mnemoverse.com/docs/api/remote-mcp-server#with-an-api-key-instead-of-the-sign-in)). - **Runs only local (stdio) servers**: add the [`mcp-remote`](https://www.npmjs.com/package/mcp-remote) bridge, a separate open-source bridge that runs through `npx` (Node.js 20.18.1 or later). It forwards to the same URL and opens the same browser sign-in on first start, so no key is needed. The entry goes under the key the client uses for MCP servers (Zed calls it `context_servers`): ```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](https://mnemoverse.com/docs/api/agent-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 1. Ask the connected app to call `memory_stats`. A successful result confirms that this conversation can reach your memory account. If you only asked to connect, stop here; no test memory needs to be created. 2. When you want to save something, ask it to remember one real, harmless fact or contact you actually want stored. For a photo, use its readable details and the space you requested; ask about unclear text instead of filling it in. Check that the `memory_write` result confirms the record was stored. 3. Start a new conversation in the same app and select the connection if needed. Ask it to retrieve that fact without repeating its contents. Check that the `memory_read` result contains the saved details. To check another app, connect it to the same Mnemoverse account and repeat the retrieval there. A tool list, memory count, or ordinary assistant answer alone does not prove a save or a recall. If a step fails, report that step and its actual error; do not claim it succeeded or substitute the host's built-in memory. Share neither credentials nor unrelated memories when reporting the error. ## Related - [Integrations](https://mnemoverse.com/docs/api/integrations): every published form in one list, with versions - [Quick Setup](https://mnemoverse.com/docs/api/agent-setup): detect your environment, configs, verify step - [Remote MCP Server](https://mnemoverse.com/docs/api/remote-mcp-server): how the sign-in works, which clients can sign in - [MCP Server](https://mnemoverse.com/docs/api/mcp-server): the local npm package and its tools - [Make Your AI Agent Actually Use Persistent Memory](https://mnemoverse.com/docs/api/agent-memory): the memory rules and the `setup_memory` prompt