MnemoverseDocs

Appearance

ChatGPT Integration ​

Give ChatGPT persistent memory powered by Mnemoverse. Same memory as Claude Code, Cursor, and every other tool.

Which path is open to you depends on your ChatGPT account

Creating a Custom GPT is no longer possible on personal accounts. OpenAI's help centre is explicit: new GPT creation and publishing are not available on personal ChatGPT accounts, including Free, Go, Plus, and Pro. Creation lives in Business, Enterprise, and Edu workspaces, subject to workspace permissions. Existing GPTs still run everywhere.

Your planWhat is open to you
Free, GoNeither path. GPT creation is closed, and Developer Mode is not offered on these plans. Use Mnemoverse from Claude, Cursor or VS Code instead, or reach the same memory over the REST API.
Plus, ProPro is documented: the same help article answers it in its FAQ — "Pro users can connect MCPs with read/fetch permissions in developer mode", and "Pro users must continue enabling developer mode to use custom apps". Full MCP with write actions stays Business/Enterprise/Edu-only, so recall works while memory_write does not. Plus is not mentioned in the article at all — if your account shows the toggle, expect the same read/fetch behaviour, and test before relying on it. Either way, writes need Claude, Cursor or VS Code or the REST API.
Business, Enterprise, EduEverything: developer mode with full MCP support, including write actions, which OpenAI describes as rolling out in beta to these plans; or the Custom GPT Actions path below with your mk_live_ key.

That is OpenAI's shape, not ours — the same limits apply to every memory service reached this way.

Checked against OpenAI's own guides on 2026-08-13. These limits move: GPT creation was open to personal plans until it wasn't, and the write restriction on personal-plan connectors arrived later still. If the table disagrees with what you see, OpenAI changed it and we have not caught up yet — tell us at support@mnemoverse.com and check their pages below, which are the authority here.

Sources: Creating and editing GPTs · Submitting apps to the ChatGPT app directory

How It Works ​

You → ChatGPT → GPT Action (HTTP) → core.mnemoverse.com
                     │
              X-Api-Key: mk_live_xxx

ChatGPT calls the Mnemoverse API directly through GPT Actions. No middleware, no proxy. Your GPT stores and recalls memories using the same API key as your other tools.

Setup (5 minutes) ​

Step 1. Get Your API Key ​

Sign up at console.mnemoverse.com and create a free API key. It starts with mk_live_.

If you already have a key from Claude Code or Cursor — use the same one. That's the point.

Step 2. Create a Custom GPT ​

Requires a Business, Enterprise, or Edu workspace

Personal accounts cannot create GPTs any more (see the note at the top). On a personal account, skip to the MCP connector instead — it reaches the same memory.

  1. In chatgpt.com, signed in to a Business, Enterprise or Edu workspace (personal plans cannot create GPTs — see the note at the top), open the side menu → My GPTs → Create a GPT (direct URL: chatgpt.com/gpts/editor, login-required, opens after step 2's "Create a GPT" button)
  2. Click Create a GPT

Step 3. Configure Actions ​

  1. Scroll down to Actions → Create new action
  2. Set Authentication:
    • Type: API Key
    • API Key: paste your mk_live_YOUR_KEY
    • Auth Type: Custom
    • Custom Header Name: X-Api-Key
  3. In the Schema box, click Import from URL and paste:
https://mnemoverse.com/docs/openapi-gpt.yaml

You should see 4 actions appear: writeMemory, readMemory, giveFeedback, getMemoryStats.

Step 4. Set the System Prompt ​

Paste this into the Instructions field (customize to your needs):

You have persistent long-term memory via Mnemoverse.

RULES:
1. BEFORE answering any question about preferences, past decisions, project 
   setup, people, or anything that might have been discussed before — call 
   readMemory first.
2. When the user shares a preference, makes a decision, teaches you something, 
   or tells you something important — call writeMemory immediately. Don't wait 
   to be asked.
3. After using memories to answer a question, call giveFeedback to report 
   whether they were helpful (1.0) or not (-1.0).
4. Your memory persists across sessions and across tools. What you learn here 
   is available in Claude Code, Cursor, and everywhere else.

WHAT TO REMEMBER:
- Preferences ("I prefer Railway over Heroku")
- Decisions ("We chose PostgreSQL for this project")
- Lessons ("Exponential backoff fixed the timeout issue")
- People ("Alice owns the design system")
- Project context ("Deploy target is staging.example.com")

WHAT NOT TO REMEMBER:
- Trivial small talk
- Temporary context ("open this file")
- Information already in the current conversation

Step 5. Test It ​

Say to your GPT:

"Remember that I always deploy to Railway using railway up"

The GPT calls writeMemory. Then start a new conversation and ask:

"How do I deploy?"

The GPT calls readMemory and recalls your preference. Same memory, new session.

MCP connector (Developer Mode) ​

ChatGPT can also connect to Mnemoverse as a remote MCP connector — no Custom GPT, no API key, just a browser sign-in. Where the toggle lives depends on the plan: on Business, admins enable it under Workspace Settings → Permissions & Roles → Connected Data; on Enterprise/Edu, under Settings → Apps → Advanced Settings (per OpenAI's help article, late August 2026); older personal-plan accounts may still show Settings → Connectors → Advanced → Developer mode. Then Create a connector and paste:

text
https://mcp.mnemoverse.com/mcp

In a chat, attach it via + → More → your connector. The sign-in is OAuth; see Remote MCP Server for the flow and the tools it exposes.

Plan limits — verify before relying on writes

OpenAI's help article states, verbatim: "Apps, full MCP support, and developer mode are available for ChatGPT Business and Enterprise/Edu customers on ChatGPT web", with write actions "rolling out in beta" (Developer mode and MCP apps in ChatGPT, read 1 September 2026). The menu labels are mid-migration ("Connectors" vs "Apps"), and plan behaviour changes faster than any docs page, ours included. Check that article before relying on writes. A one-click listing in the ChatGPT app directory is rolling out — until then, use Developer mode here or the Custom GPT path above.

Cross-Tool Proof ​

The real magic: this memory is shared with every other tool.

  1. In Claude Code: "Remember that the staging URL is staging.acme.com"
  2. In ChatGPT: "What's the staging URL?"
  3. ChatGPT recalls it. One memory, everywhere.
                    ┌── Claude Code (MCP)
                    ├── Cursor (MCP)
   Mnemoverse API ──├── VS Code (MCP)
   (one memory)     ├── ChatGPT (Actions) ← you are here
                    ├── Python SDK
                    └── REST API

Available Actions ​

Your GPT gets 4 actions:

ActionWhat it does
writeMemoryStore a preference, decision, or lesson
readMemorySearch memories by natural language query
giveFeedbackReport if a memory was helpful (+1) or wrong (-1)
getMemoryStatsCheck how many memories are stored

These are the same operations available in Claude Code, Cursor, and the Python SDK — just exposed through GPT Actions.

Tips ​

Make it proactive. The system prompt tells the GPT to store memories without being asked. This is key — users won't say "remember this", they'll just state preferences.

Use domains. If your GPT serves a specific project, add "domain": "project:acme" to writes and reads. This keeps memories organized.

Feedback matters. The giveFeedback action trains the memory system. Memories that get positive feedback rank higher in future searches. Over time, the most useful memories surface first.

Limitations ​

  • GPT Actions have a timeout (~30 seconds). Mnemoverse responds in <200ms, so this is never an issue.
  • ChatGPT may not call actions on every turn. The system prompt guides it, but GPT-4 is better at following action instructions than GPT-3.5.
  • Rate limits apply per API key. Free tier: 1,000 queries/day. Upgrade for more.

OpenAPI Spec ​

The full spec is at /openapi-gpt.yaml. It defines 4 endpoints:

  • POST /memory/write — store a memory
  • POST /memory/read — search memories
  • POST /memory/feedback — rate usefulness
  • GET /memory/stats — memory statistics

This is a curated subset of the full API. For batch operations, consolidation, and advanced queries, use the REST API or Python SDK directly.