Why does ChatGPT forget my uploaded files?

ChatGPT forgets uploaded files because every file is attached to a single chat session and stored in temporary sandbox storage that expires after roughly 3 hours of inactivity. Files never persist across chats by design, and Memory does not save document contents, only short notes. The fix is to store the files in a project memory layer that ChatGPT re-reads on every turn.

OpenAI separates two things you might lump together: the chat thread and the file sandbox. Three design choices drive the forgetting.

1. Files live in an ephemeral code-interpreter sandbox. When you upload a PDF, CSV, or image, ChatGPT writes it to a temporary container tied to that chat. After about 3 hours of idle time, the container is recycled and your file is purged. The chat text stays. The file behind it does not.

2. Files are scoped to one chat, never to your account. A new chat starts with an empty sandbox. ChatGPT has no API path that says "look in last Tuesday's chat for the spec I uploaded". Even Projects (Pro/Plus) cap shared files per project and still do not expose them to the rest of ChatGPT.

3. Memory stores notes, not documents. ChatGPT's Memory feature can save "the user uploaded a 60-page MSA in November" as a sentence. It cannot save the MSA itself. When you ask for clause 4.2 next month, ChatGPT will paraphrase a memory of having seen it, not read it.

The result is honest but frustrating: the chat remembers you discussed a file. The file is no longer there.

Every disappearing upload costs you time, tokens, and trust:

• Re-uploads burn budget. Reattaching a 50MB PDF on every fresh chat eats your file allowance and your context window. On long projects, you end up paying for the same document four or five times.
• Cross-document reasoning breaks. If you uploaded a contract on Monday and a market report on Tuesday, ChatGPT cannot compare them in Wednesday's chat. Each upload is an island.
• You lose annotation continuity. The notes, highlights, and summaries you and ChatGPT built around a file vanish with the sandbox. The next chat starts from raw text again, if you bother to re-upload.

The cure is not "keep one chat open forever". It is to detach file memory from chat memory.

OpenAI offers three partial answers. None of them solve persistent file memory.

Custom GPTs with knowledge files let you pre-load up to 20 reference files into a tailored GPT. Useful for a stable reference library, awkward when files change weekly, and capped both in file count and total size.

Projects (Pro / Plus / Team) added a shared file slot per project in 2024–2025. Files attached at the project level survive across chats inside that project, but there is still a per-project file cap, no version control, and no way to read those files from Claude or Gemini when you switch tools.

ChatGPT Memory can note that a file existed and what was in it, but the note is a paraphrase. It will never let you ask for a verbatim clause six weeks later.

OpenAI's own write-up on what Memory can and cannot do is in the official Memory FAQ.

For one document in one product, the natives are enough. For a real document set used across sessions and across AIs, they are not.

Files are usually the heaviest piece of your project. They also travel the worst. You upload a spec to ChatGPT, paste excerpts into Claude, drop a fresh copy into Gemini for a second opinion, and now three different AIs each hold a stale slice. None of them know what the others saw.

The gap is a single document store every AI can read, indexed once and updated in place, so a file lives at the project level and not inside a single chat thread.

MemoryLake gives every project a permanent Document Drive that ChatGPT reads from on every turn. Files are stored once, indexed, and surfaced as needed.

• Files persist at the project level, not the chat level. Upload a contract, spec, or transcript into MemoryLake's Document Drive once. Every new ChatGPT chat that connects to that project sees the full file, not a summary, and not a stub from last week.
• The MemoryLake-D1 engine handles real layouts. Complex Excel sheets, multi-column PDFs, and screenshot-quality scans are parsed with visual plus logical verification, so clauses, tables, and figures survive intact.
• 10,000× the working capacity of raw uploads. Retrieval pulls only the relevant passages per question, so a 500-page document set can be live in ChatGPT without blowing the 128K context window or your token budget.

MemoryLake holds the top published LoCoMo long-context score (94.03%), runs with millisecond retrieval, and encrypts every byte with AES-256 end-to-end.

1. Create a project and load your files. Sign in to MemoryLake, open Project Management, click Create Project, name it ("ChatGPT — vendor contracts" works), and drag your files into the Document Drive. PDF, Word, Excel, PowerPoint, Markdown, and images are all parsed by MemoryLake-D1. Add any standing notes in the Memories tab so they ride along with the project.
2. Generate an MCP Server endpoint. Open the MCP Servers tab in your project, click Add MCP Server, name it "ChatGPT integration", and click Generate. MemoryLake returns an API key ID, secret, and endpoint URL. Copy the secret on the spot — it is shown only once.
3. Connect ChatGPT. Browser ChatGPT does not yet speak MCP, so call the REST API with your Bearer token to pull the right passages into each chat, or paste a system prompt that points ChatGPT to your MemoryLake project ID. Developers can wire the Python SDK into a small shim that loads the project on every new conversation.