Mnemoverse Docs

Appearance

ChatGPT Integration ​

Manual Setup Required

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

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

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.

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.