ChatGPT Persistent Memory
via MCP — Real Memory

ChatGPT has a built-in "Memory" feature — but it's a black box you can't query, doesn't work in Custom GPTs, and is inaccessible via the API. Kronvex + MCP gives ChatGPT Desktop real, queryable, semantic persistent memory with EU data residency and full programmatic control.

What ChatGPT's native memory actually does

OpenAI introduced "Memory" for ChatGPT in 2024. When enabled, ChatGPT occasionally saves snippets from your conversations — things like your name, preferred programming language, or city — and retrieves them in future conversations. The system is designed to be invisible and automatic.

This works reasonably well for casual personal preferences. But it has hard architectural constraints that make it unsuitable for any professional or technical use case where you need real control over memory.

Why native memory fails for power users

You can't query it

There is no API, no search, and no way to ask "what does ChatGPT remember about project X?" You can view a flat list of memories in the settings panel, but there's no semantic search, no filtering, and no way to recall specific memories on demand during a conversation.

It doesn't work via the API

If you use the OpenAI API to build applications with GPT-4o or o1, native ChatGPT memory is completely unavailable. API calls are stateless — there is no memory injection, no stored context, nothing. Every API call starts from scratch.

Custom GPTs cannot access it

When you build a Custom GPT, native memory is not accessible to the GPT's instructions or actions. The Custom GPT cannot read what ChatGPT has remembered about the user, and cannot write new memories.

It's not GDPR-friendly

Native ChatGPT memory is stored by OpenAI on US servers. For European users and companies, this creates data residency concerns. You have limited control over what's stored, and deletion requires navigating the settings manually.

It's not deterministic

ChatGPT decides on its own when to save and retrieve memories. There is no way to force it to remember something specific, or guarantee that a specific memory will be retrieved in a future conversation. For workflows that depend on reliable context injection, this is a critical limitation.

Kronvex vs ChatGPT native memory — comparison

How MCP works in ChatGPT Desktop

OpenAI added native MCP support to ChatGPT Desktop (macOS and Windows) in early 2026. When you configure an MCP server, ChatGPT Desktop launches it as a local subprocess and exposes its tools to the AI model as native function calls — similar to how Custom GPT Actions work, but running locally without any external HTTP server.

This means the Kronvex MCP server runs on your machine, ChatGPT calls it when it needs to access memory, and all communication happens locally. The only external call is from the MCP server to api.kronvex.io to store and retrieve memories.

Prerequisites

• ChatGPT Desktop app (macOS or Windows) — download from openai.com/chatgpt/desktop
• ChatGPT Plus, Team, or Enterprise subscription (MCP requires a paid plan)
• Node.js 18+ installed on your machine
• A Kronvex account — free at kronvex.io/dashboard, no credit card required
• Your Kronvex API key (kv-...) and Agent ID (UUID from the Kronvex dashboard)

Configure the Kronvex MCP server in ChatGPT Desktop

ChatGPT Desktop reads MCP server configuration from a JSON file in your home directory. Create or edit ~/Library/Application Support/Claude/claude_desktop_config.json on macOS, or the equivalent path on Windows. The format is identical to Claude Desktop's MCP configuration:

{
  "mcpServers": {
    "kronvex": {
      "command": "npx",
      "args": [
        "-y",
        "@kronvex/mcp-server"
      ],
      "env": {
        "KRONVEX_API_KEY": "kv-your-api-key-here",
        "KRONVEX_AGENT_ID": "your-agent-uuid-here"
      }
    }
  }
}

After saving the file, restart ChatGPT Desktop completely (quit and relaunch, not just reload). The MCP server will start as a background process when ChatGPT Desktop launches.

Verify and test the connection

Start a new conversation in ChatGPT Desktop and type:

Use your Kronvex memory tools to recall anything you know about
my projects. If nothing is stored yet, confirm that the Kronvex
MCP server is connected and working.

ChatGPT should respond by calling the kronvex_recall or kronvex_inject_context tool. You'll see a tool call notification in the ChatGPT interface. If no memories exist yet, the tool returns an empty result and ChatGPT confirms the connection is working.

To store your first memory:

Remember the following using Kronvex:
I'm working on a SaaS product built with Next.js and Supabase.
The main challenge right now is optimising the onboarding funnel.
Use memory_type semantic and session_id "my-saas".

Using Kronvex memory in ChatGPT

Letting ChatGPT manage memory automatically

You can include memory instructions in your ChatGPT Custom Instructions (Settings → Personalization → Custom Instructions). This creates a standing instruction for every conversation:

You have access to persistent memory via Kronvex MCP tools.

When I start a conversation about a project or topic:
1. Call kronvex_inject_context with my message to retrieve relevant past context
2. Use this context to provide more informed, continuous assistance

When I share important information, decisions, or facts:
1. Call kronvex_remember to store them as semantic memories
2. Confirm what you stored so I can verify

Always use session_id matching the project or topic we're discussing.
Never store passwords, API keys, or personal identification numbers.

Manual memory operations

You can also trigger memory operations explicitly in natural language. ChatGPT will translate these to the appropriate MCP tool calls:

• "Remember that my preferred authentication library is Lucia Auth."
• "What do you know about my database architecture?"
• "Search your memory for anything related to my pricing strategy."
• "Forget the memory about using MongoDB — we switched to PostgreSQL."

Kronvex in ChatGPT workflows via the API

If you're building applications with the OpenAI API (not ChatGPT Desktop), you can integrate Kronvex memory directly into your API calls using the Node.js SDK. This gives your GPT-4o or o1 powered applications true persistent memory without any ChatGPT Desktop requirement:

import OpenAI from 'openai';
import Kronvex from '@kronvex/sdk';

const openai = new OpenAI();
const kv = new Kronvex({
  apiKey: process.env.KRONVEX_API_KEY,
  agentId: process.env.KRONVEX_AGENT_ID
});

async function chatWithMemory(userId, userMessage) {
  // 1. Recall relevant memories for this user and message
  const memory = await kv.injectContext({
    message: userMessage,
    sessionId: userId
  });

  // 2. Build system prompt with memory context
  const systemPrompt = `You are a helpful assistant. Here is what you remember about this user:\n\n${memory.context}\n\nUse this context to provide personalised assistance.`;

  // 3. Call OpenAI API with enriched system prompt
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: userMessage }
    ]
  });

  const assistantMessage = response.choices[0].message.content;

  // 4. Store this exchange as a new memory
  await kv.remember({
    content: `User asked: ${userMessage}\nAssistant responded: ${assistantMessage}`,
    memoryType: 'episodic',
    sessionId: userId
  });

  return assistantMessage;
}

This pattern works identically whether you're using GPT-4o, GPT-4o mini, o1, or any other OpenAI model. The memory layer is completely decoupled from the model — you can even use it to bridge memory across model providers.

Use cases

Personal knowledge management

Use ChatGPT as a thinking partner that actually remembers your ongoing projects, research threads, and decisions. Ask it to recall everything it knows about a topic before diving in, and ask it to store key insights at the end of a session. Unlike native memory, you can search, filter, and delete specific memories on demand.

Customer-facing AI assistants

If you're building a ChatGPT-powered customer service bot using the OpenAI API, use Kronvex to give each customer a persistent memory profile. Previous purchases, stated preferences, support ticket history, and communication style preferences can all be stored and retrieved semantically. The bot greets returning customers with context, not with a blank slate.

Research and writing assistant

Working on a long-form report, thesis, or book? Store key arguments, source summaries, and editorial decisions as Kronvex memories. When you return to the project after a break, ask ChatGPT to recall the current state of the argument before continuing. The assistant picks up exactly where you left off, with structured, queryable notes rather than a long scrollable chat history.

Multi-session project management

For ongoing projects with multiple stakeholders, store decisions as memories scoped by project name. Any team member who asks ChatGPT about the project can retrieve the collective memory of past discussions, agreed constraints, and current priorities — building a knowledge base that outlasts any individual conversation.

EU data residency and GDPR

Kronvex stores all memories in a Supabase PostgreSQL database hosted in the EU (Frankfurt, Germany). No memory data is transferred to servers outside the EU. This makes Kronvex suitable for European organisations with data residency requirements, healthcare companies, financial institutions, and any use case subject to GDPR.

Key GDPR provisions supported out of the box:

• Right to erasure (Art. 17): delete all memories for a specific user by calling DELETE /api/v1/agents/{id}/memories with a session filter — all matching memories are permanently deleted
• Data portability (Art. 20): list and export all memories via the /recall endpoint with no query filter
• Purpose limitation: memory types (episodic / semantic / procedural) allow you to store only the data relevant to the stated purpose
• Storage limitation: TTL parameters allow automatic deletion of memories that are no longer needed