MnemoverseDocs

Appearance

ChatGPT Integration ​

Manual Setup Required

ChatGPT Custom GPTs cannot self-configure via agent link. Follow the steps below to set up manually.

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

Two ways to connect

Custom GPT Actions (below) — works today, uses your mk_live_ API key. Or the MCP connector in Developer Mode — no key, browser sign-in (availability is plan-dependent; the one-click directory listing is rolling out).

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 ​

  1. In chatgpt.com (logged in, ChatGPT Plus or Team), 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. Turn it on in 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

The MCP-connector path, and especially write access, can depend on your ChatGPT plan and may be limited to certain tiers; the menu labels are also mid-migration ("Connectors" vs "Apps & Connectors"). Check OpenAI's current connector docs before relying on it. 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.