Remote MCP Server (one-click sign-in)

The remote MCP server is a hosted endpoint that gives any MCP client persistent Mnemoverse memory after a one-click OAuth sign-in — no API key to copy or paste. The client connects to https://mcp.mnemoverse.com/mcp, opens a browser consent screen once, and stores the token itself.

TL;DR: in ChatGPT, install the published Mnemoverse Memory plugin. For another compatible MCP client, point it at https://mcp.mnemoverse.com/mcp and follow its browser sign-in steps below. The hosted server exposes 11 tools: the core memory tools (read, write, a newest-first recent feed, stats, and feedback), the Beta shared-room tools (create · invite · join · list) and a vault alias-listing tool, tied to your Mnemoverse account. The ChatGPT plugin exposes 10, without vault_list (where each tool works).

Live service: open the Mnemoverse Memory MCP landing to inspect the endpoint, transport, OAuth discovery metadata, server card, and current tool surface.

New to Mnemoverse? Create a free account at console.mnemoverse.com first — no credit card. The sign-in below grants the token; there's no API key to paste.

Status

The endpoint and its OAuth discovery chain are live and serving — you can add the server manually in any client that can complete sign-in (see which clients can sign in). For ChatGPT, use the published Mnemoverse Memory plugin. Other hosts can use the manual connector steps below.

Remote connector vs. local package

There are two ways to give a tool Mnemoverse memory. They reach the same memory — pick by how you want to authenticate.

	Remote connector (this page)	Local package (@mnemoverse/mcp-memory-server)
Auth	OAuth sign-in — no key to paste; or an API key sent as a bearer token (details)	API key (mk_live_…) in the config
Runs	Hosted by Mnemoverse	Locally via npx
Endpoint	https://mcp.mnemoverse.com/mcp	stdio (spawned process)
Tools	11: core memory tools, Beta room tools and vault_list (list)	11: core memory tools, Beta room tools and vault_list (list)
Survives an account switch	With the sign-in, no — signing out or switching accounts in the host app drops the connection; sign in again (details). With an API key, yes	Yes — the key lives in your config, not in the app's session
Best for	Quick start, no secret management	Scripts, CI, unattended agents, or anyone who switches accounts often

The local and remote servers advertise the same tool set, with a declared host difference: the published ChatGPT plugin uses the hosted server's ChatGPT tool surface, which does not offer vault_list (where each tool works). This describes the server's tools, not verified sign-in or operation in every client; follow the host guide for its verification status and check a tool response in your account. Deleting a memory or wiping a domain is not an MCP tool on either path: it is a REST-administrative operation only, called directly against the API, never through a memory tool.

Connect

Same endpoint everywhere — https://mcp.mnemoverse.com/mcp. In most clients the first tool call (or first connect) opens your browser to sign in. Claude Code and Cursor are the exceptions: adding the server does not open anything, and you start the sign-in yourself (in Claude Code with Authenticate under /mcp, in Cursor with Connect in Customize). Full per-client walkthroughs, including the consent screen and verify steps, are in Agent Setup → One-click OAuth Connect.

• Claude Code — claude mcp add --scope user --transport http mnemoverse https://mcp.mnemoverse.com/mcp, then sign in: run /mcp in a session, select mnemoverse and choose Authenticate (or claude mcp login mnemoverse from your shell, Claude Code 2.1.186 or later).
• Claude Desktop — Customize → Connectors → + → Add custom connector → paste the URL.
• Cursor — one click: Add to Cursor, which writes the entry to ~/.cursor/mcp.json for every Cursor window. By hand, the same entry in ~/.cursor/mcp.json or .cursor/mcp.json (project root): { "mcpServers": { "mnemoverse": { "url": "https://mcp.mnemoverse.com/mcp" } } }. Then click Connect next to mnemoverse in Customize. Cursor guide.
• Devin Desktop (formerly Windsurf): add { "mcpServers": { "mnemoverse": { "url": "https://mcp.mnemoverse.com/mcp" } } } to ~/.config/devin/mcp_config.json (%APPDATA%\devin\mcp_config.json on Windows). Sign-in from its Devin Local agent is not verified yet (status); the API-key route on the Devin Desktop page needs no sign-in.
• VS Code — one click: Install in VS Code. By hand, add to .vscode/mcp.json: { "servers": { "mnemoverse": { "type": "http", "url": "https://mcp.mnemoverse.com/mcp" } } } — the "type": "http" is required, or VS Code falls back to stdio.
• ChatGPT — install Mnemoverse Memory, then complete browser sign-in when prompted and verify memory_stats. The ChatGPT guide covers this default route and alternative custom setups.

How sign-in works

The remote server is an OAuth 2.1 + PKCE resource server; your tool is the OAuth client.

1. The client connects to https://mcp.mnemoverse.com/mcp over streamable HTTP (the MCP HTTP transport — any current MCP client supports it) and gets a 401 pointing at its protected-resource metadata.
2. It follows the discovery chain to the authorization server, https://auth.mnemoverse.com/api/auth, and opens the consent screen on console.mnemoverse.com in your browser.
3. You sign in to your Mnemoverse account. The consent screen lists the scopes the client asked for, normally openid, profile, email, memory:read, memory:write and offline_access, and you approve that set or deny the request; there is no per-scope choice.
4. The client stores the access + refresh tokens and sends the access token on every request. No API key is ever entered.

You manage your account at console.mnemoverse.com. To disconnect the connector, remove it in your client's connector settings. The console cannot revoke one connector today, but when you reset your password there you can choose to disconnect all connected apps at once. Section 11.3 of the Privacy Policy says how long tokens already issued keep working in each case. A connector granted only memory:read can recall but not write.

Which clients can sign in (registration allowlist)

Sign-in starts with Dynamic Client Registration (RFC 7591). As an anti-phishing measure, registration only accepts OAuth callbacks on known connector hosts:

• Cloud connectors — Claude and Claude Desktop (claude.ai / claude.com), ChatGPT (chatgpt.com), Smithery (smithery.ai / smithery.run), Glama (glama.ai), VS Code for the Web (vscode.dev), Cursor on the web and Cursor Agents (www.cursor.com), Make (www.make.com), Devin hosted (api.devin.ai), Replit connectors (replit.com), Google Antigravity (antigravity.google), Perplexity (www.perplexity.ai / enterprise.perplexity.ai), OpenHands Cloud (app.all-hands.dev), Dust (dust.tt / app.dust.tt / eu.dust.tt), Amazon Quick (<region>.quicksight.aws.amazon.com in the regions where Quick runs agents), Langdock cloud (app.langdock.com), Amp on the web (ampcode.com). Recipes: Install by host.
• Native and CLI clients — anything using an RFC 8252 loopback callback (localhost / 127.0.0.1 / [::1], any port): Claude Code, VS Code Desktop, the Cursor desktop app, MCP Inspector — plus Cursor's cursor:// and Warp's warp:// callbacks.

Self-hosted web clients — LibreChat, Open WebUI, custom deployments — depend on where you reach them, not on which app you run. The callback host decides the outcome:

• Reached locally (http://localhost:3080, http://127.0.0.1:8080) the callback is a loopback URI, which the allowlist above accepts on any port, so the sign-in completes.
• Served from your own domain (chat.example.com) registration is refused. That is the anti-phishing control doing its job: it accepts a list of known hosts rather than banning specific ones, so a custom domain does not change it.

If you are on your own domain, you have three ways forward.

1. Move the client to loopback. If you can reach the app at localhost — most self-hosted setups can, at least for yourself — nothing else changes and OAuth works as above.

2. Use an API key. The stdio MCP server authenticates with an mk_live_… key instead of OAuth, so it works from any host, on any domain, with no registration involved. LibreChat, for example, runs stdio MCP servers straight from librechat.yaml. This is the path we recommend for a server-side deployment. A client that can send a fixed Authorization header to a remote MCP server can instead use this URL with the key as a bearer token, also with no registration (with an API key).

3. Ask us to add your host. The allowlist is ours, and we do extend it — Claude, ChatGPT, Smithery and VS Code are on it for exactly this reason. Write to us through the contact form with your callback host, what you are building, and how the deployment can be verified as yours. We are looking for real deployments with a checkable owner — a provider, a product, a team running this for its users — not a one-off tunnel. It is a change on our side, so it takes a conversation rather than a form submission, but the door is open.

With an API key instead of the sign-in

A client that cannot complete the sign-in, but can send a fixed header, can use the same URL with a Mnemoverse API key. The server has accepted a key as a bearer token since 2026-10-19:

Authorization: Bearer mk_live_YOUR_KEY

Create the key on console.mnemoverse.com and copy it: it is shown only once.

• The server checks the key before it answers. The check is the one the REST API makes. A key that was revoked, cut short or never issued gets 401 with "error": "invalid_api_key"; on 2026-10-21 a made-up key in the correct mk_live_ shape got "This API key is not recognized."
• Only the Authorization: Bearer form is read. The X-Api-Key header, which the REST API accepts, gets 401 with "error": "wrong_credential_type" from this server.
• A key has no scopes and no expiry. It reads and writes the whole memory of the account it was created in, and gets every tool under Tools. Give each host its own key, so you can revoke one without the others: revoking a key in the console stops its memory calls at once, and this server stops accepting it within 60 seconds.

What an account switch does to your connection

This one surprises people, so it is worth stating plainly.

The remote connector is an OAuth connection. It belongs to the account that completed sign-in, and the token that keeps it alive is held by the host app — Claude, ChatGPT, your editor. When that app's identity changes, the connection it was holding no longer applies:

• you sign out and back in,
• you switch to a different workspace or account,
• the app re-authenticates you for its own reasons.

In each case the connector is typically dropped and needs a fresh sign-in — exactly what happens depends on the host app, which owns the session. This is how OAuth connectors behave generally, not something specific to Mnemoverse — if you also connect calendars, chat workspaces or drives to the same app, you have probably watched them all disconnect together after a re-login.

The symptom is quiet, which is the awkward part. Nothing announces itself. The Mnemoverse tools simply stop appearing in the tool list, and the assistant carries on as if you had never had memory — answering from the current conversation alone. It reads like memory is down.

It is not. Nothing has happened to your data. Your memories, domains and rooms are exactly where you left them; only the door closed. Sign in again with the same Mnemoverse account and everything is back, unchanged.

The local package does not have this failure mode. It authenticates with an mk_live_… key that lives in your own config file, so it is not tied to the host app's session at all. Switch accounts, sign out, restart the app — the memory server keeps working, because nothing about it depended on who you were signed in as. The same holds for this server used with an API key.

So if you switch accounts routinely, or you are running an agent unattended where nobody is present to notice a silent disconnect and sign in again, prefer the local package. If you want the fastest possible start and you sign in once and stay there, the remote connector is the simpler path.

Tools

The remote connector exposes 11 tools: the core memory tools, the Beta room tools, and a vault listing tool (see the API reference for full parameters):

• memory_read — recall memories by a natural-language query. When the client sends no top_k, the connector asks for five results; the REST API's own default is ten, range 1 to 500. A tool's text reply is cut at 25,000 characters, with a visible truncation note (connector source, read 2026-10-02).
• memory_list_recent — list the newest memories first, no query needed; twenty per page when the client sends no limit.
• memory_stats — report counts, domains, and association stats for your memory.
• memory_graph — read the association links around 1 to 20 concepts, up to 3 hops: which concepts your memory has linked, with each link's weight, valence and count. Read-only, so a read-only sign-in can call it.
• memory_write — store a new memory.
• memory_feedback — rate recalled memories as helpful or misleading, which re-ranks what comes back next.
• memory_create_room — Beta: create a shared cross-account memory room; see Rooms.
• memory_invite_to_room — Beta: mint an invite code (mnvr_...) for a room you own; single-use by default, with a configurable use limit.
• memory_join_room — Beta: join a shared room from an invite code.
• memory_list_rooms — Beta: list the rooms you own or have joined, with each room's domain address — re-find your rooms in a new session without re-joining.
• vault_list — list stored secret aliases; values are never returned.

The published ChatGPT plugin offers every tool above except vault_list; Where each tool works gives the reason. Custom MCP and Custom GPT Actions are separate setup paths; Actions have their own action names.

Deleting a memory or wiping a domain isn't an MCP tool on this server, or on the local package — it's a REST-administrative operation, callable directly against the API.

Troubleshooting

• 401 with invalid_api_key or wrong_credential_type — the request carried an API key. invalid_api_key: the key was revoked, cut short or never issued; copy the whole key again or create a new one. wrong_credential_type: the key went in X-Api-Key; send it as Authorization: Bearer (with an API key).
• 401 / "invalid token" after a while — the access token expired. Ask your tool any question that uses memory and it refreshes automatically. If that fails, remove the server from your client's config, restart the client, and re-add the URL to run sign-in again.
• A GET to the endpoint returns 401 — expected. The endpoint takes POST (streamable HTTP) and asks for sign-in; a browser visit isn't how you connect.
• VS Code ignores the server — make sure the entry has "type": "http"; without it VS Code tries to launch it as a local stdio process.
• Cursor or Devin Desktop ignores the server: check the config file path. For Cursor it is ~/.cursor/mcp.json (global) or .cursor/mcp.json (project root). For Devin Desktop, formerly Windsurf, it is ~/.config/devin/mcp_config.json (global) or .devin/mcp_config.json (project root); an older ~/.codeium/windsurf/mcp_config.json is still imported by default. Restart the app after editing.
• redirect_uri host not permitted for dynamic registration — your client's OAuth callback host isn't on the registration allowlist, which is intentional when the callback sits on your own domain. Three ways forward are laid out above: reach the client at localhost, use an API key (with the local package, or as a bearer token to this server), or ask us to add your host.
• Cannot find Mnemoverse in ChatGPT — open the public plugin card directly. If installation is unavailable, check the account, workspace policy and client; record the actual message. For other hosts without a listing, use their manual connector steps above.
• Writes are rejected — the connector's token has no memory:write. The consent screen grants exactly the scopes the client asked for, so the client asked without it. Remove the connector and add it again, and check that the consent screen lists Store and update your memories. If it does not, the client's own settings decide its scopes; Install by host shows where for the hosts that need it.
• The Mnemoverse tools disappeared, and the assistant answers as if it never had memory — most likely you switched accounts or signed in again in the host app — that usually drops every OAuth connector it was holding (an expired token shows the same symptom). Your memories are untouched; sign in to the connector again, or move to the local package, whose API key survives account changes. See what an account switch does.
• Calls fail with "not connected" while the client still shows the connector as connected: the session itself is stuck. Reconnecting the connector on claude.ai does not revive a session that is already stuck; reconnect from inside the session instead (in Claude Code, /mcp, then sign in again). Meanwhile the local package, set up with an API key from the same account, reaches the same memory and does not depend on that session's sign-in.

Related

• Mnemoverse Memory MCP — live endpoint, discovery metadata, and machine-readable server card.
• Media kit — official logo, promotional images, paired prompts, and listing copy.
• Agent Setup — full per-client walkthroughs (both the key and the OAuth paths).
• MCP Server (local package) — the npx option, the same tool surface.
• Rooms — share a memory pool across accounts (Beta).
• API Reference — tool parameters and the REST API.
• Security — how keys, tokens, and your data are handled.