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	12: 7 core (adds delete · delete_domain) + 4 Beta room tools + vault_list
Best for	Quick start, no secret management	Scripts, CI, or when you need the delete tools

If you want destructive operations (memory_delete, memory_delete_domain), use the local package or the REST API — the remote connector deliberately omits them so a one-click sign-in can never wipe memory.

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 --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 → Connectors → Advanced → Developer mode → 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 (a different integration) also works on every plan.

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 — can't complete the OAuth sign-in today. Their callback lives on their own domain, which registration rejects by design (a custom domain doesn't change this — the check is an allowlist of known hosts, not a ban on specific ones). Use the local package with an API key instead — LibreChat, for example, runs stdio MCP servers from librechat.yaml. Opening registration to self-hosted clients is under consideration.

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.

memory_delete and memory_delete_domain are not exposed here by design — use the local package or REST API for those.

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 isn't on the registration allowlist; this is intentional for self-hosted web clients. Use the local package with an API key instead.
• 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.

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 with the full twelve-tool surface, including the two delete tools.
• 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.