A ChatGPT memory alternative you can read
ChatGPT's memory lives inside one product. vtriv keeps your context in plain markdown; ChatGPT access depends on your plan and MCP permissions.
ChatGPT’s memory is useful, and it now has real controls: an editable memory summary, sources that can show some of the context behind a personalized response, and saved-memory controls that may include version history. Those features still live inside ChatGPT. They don’t create one portable Markdown project or task record that unrelated MCP clients can share.
If you want a ChatGPT memory alternative, keep the durable context in a store you can read and export, then connect compatible assistants over MCP. The same facts can reach ChatGPT, Claude, Cursor, and whatever you switch to next year. You can open the files, edit them, and take them with you.
Custom MCP access has separate limits. Pro users can connect MCPs in developer mode with read and fetch permissions. Full MCP support, including write and modify actions, is rolling out in beta for Business, Enterprise, and Edu. OpenAI’s current guidance has the plan details.
What ChatGPT’s memory does and where it stops
ChatGPT can remember useful context from past chats, saved memories, custom instructions, and, where available, Library files and connected apps. Its Memory controls vary by plan, region, platform, and workspace settings. For preferences, it works. It knows you like short answers or that you’re learning Portuguese, and you stop repeating yourself inside that one product.
The current experience deserves a more precise comparison. Improved Memory maintains a summary that you can correct by editing or highlighting its text. Sources can identify some past chats, saved memories, files, or other context used in a response. Saved-memory controls can let you edit or delete individual memories; depending on your plan and platform, they can also include search, sorting, automatic prioritization, and version history.
Three limits still show up once you rely on it.
ChatGPT still curates the memory. It decides which available information is relevant, and its summary can leave out details or sources. You can correct the summary, but that is different from maintaining the full record yourself.
It isn’t a portable project record. The summary is a view of ChatGPT’s personalization context, not a folder of Markdown documents and task state that you can arrange, hand to a colleague, or connect to another client.
It doesn’t become a shared copy. Open Claude Code, Cursor, or a fresh tool, and ChatGPT’s Memory is not there for that unrelated client to query. You have to supply that client’s context again, which is the cost of starting over you pay every time you switch.
That last one is the real cost for anyone who uses more than one assistant. Most people now do.
Three tests for a replacement
Can you read it? ChatGPT now clears a basic version of this test when its Memory summary is available: you can review and edit it, and Sources can explain part of a personalized response. A summary can omit remembered details and sources, though. For a durable context layer, you should be able to open the actual project and task records, edit a sentence, and know what each connected client can read.
Can you take it? One click, everything out, in a format that’s still useful somewhere else. The useful result is ordinary Markdown records that can become another client’s live context, not merely vendor account data or an internal export format.
Does every tool see the same copy? One store, many clients, no syncing. A client’s permissions still determine whether it can read or write. If you maintain a context file per repo and a memory per vendor, you don’t have a memory layer. You have four of them, drifting.
The honest field guide
Vendor memory (ChatGPT, Claude). Free or included, zero setup, fine for preferences. ChatGPT’s current Memory adds an editable summary, partial source attribution, and saved-memory controls that vary by plan and platform. It still fails the portable-record and shared-copy tests when you use a second tool.
A context doc you paste in. Better than nothing and completely under your control. It also decays: it lives on one laptop, you’re the one copying it into every new chat, and the version in your other project is six weeks behind.
Local memory MCP servers. There are good ones — knowledge-graph servers, file-backed servers — and they run on your machine over MCP so any client can read them. They’re often single-machine, so a phone or second laptop needs its own setup. Their UI depends on the server: some give you a dashboard, while others leave editing to files or the client.
Notion or Obsidian with an MCP server. If your notes already live there, this is a reasonable move and costs you nothing new. What you get is general-purpose notes bolted onto an AI: retrieval built for humans browsing pages, not for an agent that needs one orienting read at the start of a session and structured work records it can search.
Mem0. Its hosted MCP server connects supported AI clients to a Mem0 account. OpenMemory gives you a local MCP server and dashboard. Those routes make Mem0 a real option for sharing memory between existing tools. The record is still memory objects an AI can add, search, update, and delete, rather than authored Markdown and work records you arrange, revise, and carry as files.
Zep and Letta. These remain focused on developers building an application or stateful agent. If that’s what you’re doing, use them. The details differ, especially now that Letta also has a personal agent, but they aren’t the default answer for someone who wants the AI tools they already use to share context.
A hosted context layer. One store, structured, plain markdown, reachable from compatible MCP clients, with a UI when you want to edit by hand. That’s the category vtriv is in, and it’s the version that passes all three tests.
What this looks like in vtriv
Connect once. The endpoint is https://mcp.vtriv.com/mcp, Streamable HTTP with OAuth, so clients discover auth and open a browser sign-in instead of asking for an API key.
- ChatGPT: On the web, Pro users can connect vtriv in developer mode for read and fetch. Full MCP support, including write and modify actions, is rolling out in beta for Business, Enterprise, and Edu; see OpenAI’s plan guidance.
- Claude Desktop or claude.ai: Settings → Connectors → Add custom connector.
- Claude Code:
claude mcp add --transport http vtriv https://mcp.vtriv.com/mcp - Cursor: Settings → MCP → Add server, type
streamableHttp.
One connection per client covers everything you have. There’s no server per project.
Then write the part you’re tired of repeating. Your profile is a single markdown document that stays in scope for every session in every client. In a connected client that permits writes, tell the assistant to save it:
Save a profile for me: I run marketing for a small B2B company. I write in plain language, no exclamation points, and I want drafts short enough to read on a phone. I care about the reasoning behind a recommendation more than the recommendation.
That’s stored as markdown you can open in the app and rewrite whenever you want. Durable material goes in a knowledge tree at paths you choose, like topic/positioning.md. Leave the path off and it lands in an inbox, searchable right away, filed later or never.
The read side is what makes it feel different. A new session calls vtriv_context once and gets who you are, what skills exist, and what you’re working on. Ask about something specific and vtriv_search runs hybrid semantic and keyword search across knowledge, projects, tasks, notes, and skills. When you want working context rather than a list of hits, vtriv_pack assembles the most relevant sections from across everything into one bundle inside a token budget.
Projects carry tasks, too, so the same layer that holds what your assistants know also holds what you’ve asked them to do. Assignment, status, dependencies, comments, and custom fields are stored task state that a client can query. An external runner decides when to select and execute work, then reads and updates vtriv with the result. In our daily use, an external runner read the strategy record for this post and wrote its result to the task thread.
And the exit is real: Settings → Export downloads a zip of everything as markdown. Profile at the top, skills as folders, knowledge at its paths, each project with its README, notes, and tasks as files. If you leave, you leave with a directory of markdown that opens in any editor. A layer you can’t walk away from isn’t yours either.
Start with the boring part
The temptation is to migrate everything at once. Don’t bother. Write the profile, add three or four documents you’d groan about re-explaining, and let write-capable assistants fill in the rest as you work — what’s worth keeping covers how to decide. If you’re coming at this from the Claude side specifically, how to give Claude persistent memory across sessions walks the same setup end to end, and CLAUDE.md at scale covers the Claude Code version of the same problem.
The free tier holds 50 documents, 25 skills, and unlimited projects and tasks, which is plenty to find out whether a memory you can read changes how you work. Get started.