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: point your tool at https://mcp.mnemoverse.com/mcp, sign in when the browser opens, done. You get five core memory tools — read, write, a newest-first recent feed, stats, and feedback — plus the four Beta shared-room tools (create · invite · join · list) and a vault alias-listing tool, tied to your Mnemoverse account.

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 today — you can add the server manually right now in any client that can complete sign-in (see which clients can sign in). One-click listings in client directories (Anthropic Connectors, the ChatGPT connector catalog) are rolling out; until a listing appears, use the manual "add custom 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	API key (mk_live_…) in the config
Runs	Hosted by Mnemoverse	Locally via npx
Endpoint	https://mcp.mnemoverse.com/mcp	stdio (spawned process)
Tools	10: 5 core (read · stats · write · feedback · list_recent) + 4 Beta room tools + vault_list	10: 5 core (read · stats · write · feedback · list_recent) + 4 Beta room tools + vault_list
Survives an account switch	No — signing out or switching accounts in the host app drops the connection; sign in again (details)	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

Both paths expose the identical tool set — there is no local/remote asymmetry. 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. The first tool call (or first connect) opens your browser to sign in. Full per-client walkthroughs, including the consent screen and verify steps, are in Agent Setup → One-click OAuth Connect.

• Claude Code — claude mcp add -s user --transport http mnemoverse https://mcp.mnemoverse.com/mcp
• Claude Desktop — Settings → Connectors → Add custom connector → paste the URL.
• Cursor — add to .cursor/mcp.json (project root): { "mcpServers": { "mnemoverse": { "url": "https://mcp.mnemoverse.com/mcp" } } }
• Windsurf — add to ~/.codeium/windsurf/mcp_config.json (global): { "mcpServers": { "mnemoverse": { "url": "https://mcp.mnemoverse.com/mcp" } } }
• VS Code — 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 — Settings → Apps → Advanced settings → Developer mode (admins: Workspace settings → Apps) → create a connector with the URL; the sign-in is the same browser OAuth (plan-dependent — see the ChatGPT guide). The one-click directory listing is rolling out. The Custom GPT + API-key setup is a different integration and needs a Business, Enterprise or Edu workspace — OpenAI closed GPT creation on personal plans.

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 in your browser.
3. You sign in to your Mnemoverse account and grant the scopes: openid, profile, email, memory:read, memory:write, offline_access.
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 and revoke access at console.mnemoverse.com. 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), VS Code for the Web (vscode.dev).
• Native and CLI clients — anything using an RFC 8252 loopback callback (localhost / 127.0.0.1 / [::1], any port): Claude Code, VS Code Desktop, MCP Inspector — plus Cursor's cursor:// callback.

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 the local package with 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.

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.

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.

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 ten tools — five core memory tools, the four Beta room tools, and a vault listing tool (see the API reference for full parameters):

• memory_read — recall memories by a natural-language query.
• memory_list_recent — list the newest memories first, no query needed.
• memory_stats — report counts, domains, and association stats for your memory.
• memory_write — store a new memory.
• memory_feedback — mark which recalled memories were useful, so ranking improves over time.
• 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.

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 / "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 404 — expected. The endpoint is POST-only (streamable HTTP); 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 Windsurf ignores the server — check the config file path: .cursor/mcp.json (project root) for Cursor, ~/.codeium/windsurf/mcp_config.json (global) for Windsurf. 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 the local package with an API key, or ask us to add your host.
• No "Mnemoverse" in the connector directory yet — listings are rolling out; add it manually with the steps above in the meantime.
• Writes are rejected — the connector was granted read-only (memory:read); reconnect and grant memory:write.
• 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.

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, same ten-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.