You spent 45 minutes giving ChatGPT the full context on your project. The company background, the product roadmap, the technical constraints, the stakeholder preferences. By the end of the conversation, the AI understood everything. Its responses were precise, relevant, and genuinely useful.
Then you closed the tab.
The next morning, you opened a new chat. The AI had no idea who you were, what your company does, or what you'd discussed. You started over from scratch.
This happens every single day to millions of people. And the worst part is that every "solution" the AI companies have shipped so far is a band-aid on a structural problem.
The illusion of AI memory
ChatGPT introduced "memory" in early 2024, and it sounds like exactly what you'd want: the AI remembers things about you across conversations. But the reality is far more limited than the marketing suggests.
ChatGPT's memory has a roughly 1,200 word limit. That's about two pages of text. When you've told the AI hundreds of facts about your work, your preferences, your projects, and your team, it has to compress all of that into roughly 1,200 words. The compression is lossy. Nuance disappears. Specific details get replaced with vague summaries. The AI might remember that you "work in healthcare technology" but forget that your company specifically builds EHR integrations for rural clinics, that your main product serves 340 facilities, and that you're in the middle of a HIPAA compliance audit.
It gets worse. In February 2025, OpenAI experienced a bug that wiped memories for a significant number of users. People who had carefully built up their AI's understanding of their work over months lost everything overnight. OpenAI acknowledged the issue, but the memories were gone. There was no backup, no recovery, no export. The "memory" existed entirely within OpenAI's system, and users had no control over it.
This is the fundamental problem with AI-managed memory: you are trusting the AI platform to decide what's worth remembering, how to store it, and whether to keep it. You have almost no visibility into what the AI actually retained, and no way to correct it when the summary misses something important.
Claude's compacting problem
Claude handles long conversations differently, but the result is similar. When a conversation grows beyond what can fit in Claude's context window, the system automatically "compacts" earlier parts of the conversation. This means Claude summarizes what was discussed, discards the original messages, and works from the summary going forward.
The problem is that compacting destroys detail and nuance. You have no control over what gets kept and what gets discarded. Claude might compact away the specific numbers from your Q3 report, the exact wording of the policy change you discussed, or the technical constraint that makes Option B infeasible. The summary says "discussed Q3 performance and upcoming policy changes," but the actual substance is gone.
If you've ever noticed Claude contradicting something you told it earlier in a long conversation, or giving advice that ignores a constraint you already explained, compacting is often the reason. The AI isn't being careless. It literally no longer has access to what you said.
Context windows are temporary by design
Here's the part that most people miss: even if you have a million-token context window, it resets to zero when you start a new conversation.
A context window is RAM, not storage. It holds information for the duration of a single session. When that session ends, everything in the context window disappears. It doesn't matter whether the window is 8,000 tokens or 1,000,000 tokens. The behavior is the same: start a new conversation, start from scratch.
This means that a larger context window lets you have a longer single conversation, but it does nothing for persistence across conversations. Your Monday conversation and your Tuesday conversation are completely isolated from each other. The AI on Tuesday has no knowledge that Monday's conversation ever happened.
People often conflate context window size with memory. They assume that a bigger context window means the AI "knows more." But that's like assuming a bigger whiteboard means your notes are permanent. The whiteboard gets erased every time you leave the room, regardless of its size.
Custom instructions: a 1,500-word ceiling
Both ChatGPT and Claude offer custom instructions or system prompts. You can write a block of text that gets prepended to every conversation, giving the AI baseline context about who you are and how you work.
This is useful, but severely limited. Custom instructions are typically capped at around 1,500 words. That's enough for a brief personal description and some formatting preferences. It is nowhere near enough to hold your product roadmap, your company's style guide, last quarter's metrics, your team structure, your technical architecture, or any of the other context that makes AI responses actually useful for real work.
Custom instructions are also static. You write them once and update them manually. They can't evolve with your projects, capture meeting decisions, or reflect the current state of work-in-progress initiatives. By the time you finish updating your custom instructions for Q1, Q2 is underway and the instructions are already outdated.
Projects: better, but still siloed
Both Claude and ChatGPT have introduced "Projects" (Claude) and "GPTs" or "Projects" (ChatGPT) that let you upload files and create more specialized AI assistants. These are a meaningful step forward. You can upload your product spec, your brand guide, or your technical documentation, and the AI will reference them during conversations.
But there are significant limitations.
First, documents are siloed per project. If you have a product roadmap in your "Product Strategy" project and you want to reference it during a conversation in your "Engineering" project, you can't. You'd have to duplicate the file across projects or switch contexts entirely.
Second, the AI doesn't read your uploaded files verbatim. It processes them to fit within the context window, which means summarizing, truncating, or selectively pulling sections. For short documents this works well. For a 50-page product spec, the AI is making decisions about which parts to focus on, and those decisions might not match what you need for a given question.
Third, you still lose your conversation history when you start a new chat within the same project. The documents persist, but the discussion, decisions, and reasoning from previous conversations do not.
The structural fix: external knowledge bases
Every approach described above shares the same flaw: the knowledge lives inside the AI platform. It's subject to the platform's limits, the platform's summarization choices, and the platform's persistence policies.
The structural fix is to move the knowledge outside the AI entirely.
Instead of hoping the AI remembers what you told it, you maintain your own documents that the AI can access on demand. Your company context, product specs, meeting notes, project status, style guides, and personal preferences all live in documents that you control. When the AI needs information, it reads from your documents. When information changes, you update the documents (or have the AI update them for you).
This inverts the relationship. Instead of feeding context to the AI and hoping it retains enough, you maintain a persistent knowledge base that any AI conversation can draw from. The knowledge doesn't disappear between sessions because it was never stored in the session to begin with.
This approach is called "context engineering," and it's quickly becoming the standard pattern for serious AI workflows. Rather than fighting the inherent limitations of context windows and AI memory, you work around them entirely.
How MCP makes this practical
The concept of an external knowledge base is straightforward. The implementation, until recently, required custom code: API integrations, database setups, retrieval pipelines. Most people who would benefit from this approach don't have the technical background to build it.
That changed with the Model Context Protocol (MCP). MCP is an open standard that lets AI tools connect to external services. Think of it as a USB port for AI: a standardized way for an AI assistant to read from and write to external tools and data sources.
With MCP, you don't need to copy-paste context into every conversation or upload files to every project. The AI connects directly to your knowledge base and can read your documents, search through them, and even update them based on your instructions.
This is not a theoretical future. MCP is live today in Claude (both the web app and desktop app), and the ecosystem of MCP-compatible tools is growing rapidly.
Unmarkdown™ as your AI knowledge base
Unmarkdown™ is a markdown document platform with a built-in MCP server. Here's why that combination matters.
Your documents in Unmarkdown™ are written in markdown, the same format that AI tools natively understand. There's no format conversion, no information loss, and no summarization happening between your documents and the AI. When Claude reads your product roadmap from Unmarkdown™, it gets the full document, exactly as you wrote it.
The MCP integration gives Claude seven tools for working with your documents:
- List documents to see everything in your knowledge base
- Get a document to read the full content of any specific document
- Create a document to add new knowledge (meeting notes, project updates, research)
- Update a document to keep existing knowledge current
- Publish a document to share knowledge publicly or with your team
- Convert a document to format content for Google Docs, Word, Slack, or any other destination
- Check usage to monitor your API consumption
This means you can have conversations like:
"Read my product roadmap and suggest Q2 priorities based on what shipped in Q1."
"Update the meeting notes with today's decisions about the pricing change."
"What did we decide about the API rate limits? Check the technical architecture doc."
The AI reads your actual documents, gives you answers grounded in your real context, and can update the documents so the knowledge stays current for the next conversation.
Setting it up
Connecting Unmarkdown™ to Claude takes about two minutes. For Claude on the web (claude.ai), you can add it as an integration directly from Settings. For Claude Desktop, you add a configuration entry pointing to the MCP server. For Claude Code, it's a single terminal command.
The full setup instructions, including configuration examples for every Claude client, are in the integration docs. The Claude-specific guide walks through each method step by step.
Once connected, every new conversation with Claude has access to your full document library. No copy-pasting, no re-explaining, no context lost between sessions.
The bigger picture
The current moment in AI feels a lot like the early days of cloud storage. People were emailing files to themselves, saving to USB drives, and losing work when a laptop died. The fix wasn't a bigger email inbox or a faster USB drive. It was moving the files to a persistent, accessible location.
AI context is at that same inflection point. The fix for AI forgetting isn't a bigger context window or better summarization. It's moving the knowledge to a persistent, accessible location that any conversation can draw from.
Context windows will keep getting larger. AI memory features will keep improving. But the fundamental architecture of a chat session, where context exists only for the duration of the session, isn't going away. External knowledge bases aren't a workaround for a temporary limitation. They're the correct architecture for how humans and AI should share information.
The people who figure this out now, who build their knowledge base and connect it to their AI tools, will have a compounding advantage. Every document they add makes every future AI conversation more useful. Every update they make is immediately available to every conversation. The knowledge accumulates instead of evaporating.
Your AI doesn't need a better memory. It needs access to yours.
Getting started
If you want to try this approach:
- Start with Unmarkdown™ and create a few documents covering your most frequently re-explained context: company overview, current projects, team structure, technical constraints, personal preferences.
- Connect to Claude via MCP using the integration guide.
- In your next Claude conversation, ask it to read one of your documents and answer a question based on it.
You'll immediately feel the difference between an AI that's starting from zero and one that already understands your world.
For developers who want to build their own integrations, the Unmarkdown™ API provides full programmatic access to the same document operations available through MCP.
Related reading
- How to Build a Persistent Knowledge Base Your AI Can Always Access
- How to Use Claude's MCP Tools to Publish Documents
- What Is Markdown and Why Does Every AI Tool Use It?
- AI Memory Tools Compared: Custom Instructions vs Projects vs Knowledge Bases
- ChatGPT Memory Full? Here's What OpenAI Won't Tell You
