Topic: Claude Projects memory and Knowledge Base export
Claude Projects Memory and Knowledge Base Export — What Survives, What's Lost, and How to Back Up Before Deleting
A Claude Project bundles three distinct layers: the conversations you've had within it, the Project Instructions (custom system prompt) you wrote, and the Knowledge Base files you uploaded. When you run the standard data export from Claude.ai Settings, you get the conversations — but not the Instructions text and not the Knowledge Base file contents. When you delete a Project, all three layers are deleted from Anthropic's servers. This page covers exactly what each layer contains, what survives the export, what's lost on deletion, and the four-step backup checklist to run before you delete any Claude Project that contains architectural context.
TL;DR
Before deleting a Claude Project: (1) run Settings → Export Data and verify the project_uuid appears in conversations.json, (2) manually copy the Project Instructions text from the Project settings panel, (3) download all uploaded Knowledge Base files from the Project's Knowledge tab, (4) copy any pasted-text Knowledge Base entries — these have no download button and are permanently lost on deletion. The standard export captures conversations; it does not capture Instructions or Knowledge Base contents. If the Project contains architecture deliberation sessions, run the WhyChose extractor on the export first to surface those decisions before they become hard to reconstruct.
The three layers of a Claude Project and their export status
A Claude Project is a named container that groups related conversations and provides shared context through two mechanisms: Project Instructions (what Claude should always know and do in this Project's conversations) and a Knowledge Base (files that Claude can reference when answering questions in this Project). The three layers have different export behaviors:
| Layer | What it contains | In standard export? | Lost on Project deletion? |
|---|---|---|---|
| Conversations | All chat_messages within the Project, with sender, text, and timestamps. Tagged with project_uuid in conversations.json. | Yes — included in conversations.json | Yes — deleted from Anthropic servers. Export before deleting. |
| Project Instructions | The system prompt text you wrote in the Project settings ("Custom instructions for Claude"). Defines Claude's role, persona, and rules for all conversations in the Project. | No — not in conversations.json | Yes — permanently deleted. Copy manually before deleting. |
| Knowledge Base — uploaded files | PDF, .txt, .docx, .csv, and code files you uploaded to the Project's Knowledge tab for Claude to reference. | File names referenced only — no file bytes in export | Partially — file bytes deleted from Anthropic. Your local originals are unaffected. Download from UI if you don't have the local copy. |
| Knowledge Base — pasted text | Text blocks you added using the Knowledge Base "Add text" option (paste directly, no file to upload). | No — not in conversations.json | Yes — permanently lost. No download button. Copy the text manually before deleting. |
The most dangerous combination is pasted-text Knowledge Base entries: engineers often paste architecture context (tech stack decisions, past ADRs, API contracts) directly into the Knowledge Base rather than uploading a file because they don't have a local file to upload. These entries exist only on Anthropic's servers within the Project, have no download path, and are permanently deleted when the Project is deleted. If your Knowledge Base contains pasted text, this is the highest-priority item to copy before deletion.
What the standard Claude data export does and does not include
The standard export (Settings → Privacy → Export your data → Download) produces a ZIP containing conversations.json — a flat array of every conversation in your Claude.ai account. Project conversations are included in this array, each tagged with the project_uuid of the Project they belong to.
What is in conversations.json for Project conversations:
- The
uuid(conversation ID) andnameof each conversation - The
project_uuididentifying which Project the conversation belongs to - All
chat_messages— each withsender(human/assistant),text, andcreated_attimestamp - References to uploaded file names within conversation messages (the file names appear in the message content, but the file bytes are not included)
What is NOT in conversations.json:
- Project Instructions text (the custom system prompt) — not stored as a conversation message, not exported
- Project name — only the UUID is present; the human-readable project name is not in conversations.json as of the current export format
- Knowledge Base file contents — file names may appear in message text when Claude references them, but the actual file bytes are excluded
- Claude's memory entries (see below) — stored separately from conversation history, not included in the conversations.json export
To rebuild the per-Project structure from conversations.json, the 22-line jq script on the Claude Project export page groups conversations by project_uuid and writes each group to a separate directory. This gives you the conversations per Project, but the Instructions and Knowledge Base content must still be copied separately.
The Project deletion cliff — what you can't recover
When you delete a Claude Project from the Claude.ai UI, the deletion is immediate and irreversible. Anthropic does not offer a recovery window or a recycle bin for deleted Projects. The effects:
- All conversations within the Project are deleted from Anthropic's servers. If you have already exported conversations.json, those conversations exist in your local export. If you have not, they are gone.
- Project Instructions are deleted. There is no post-deletion recovery path regardless of whether you've exported.
- Knowledge Base files are deleted from Anthropic's servers. If you uploaded them from local files, your local originals still exist. If you added text directly, it is permanently lost.
The conversations-in-export question is the most time-sensitive: the standard export is not continuous — it captures a point-in-time snapshot. If you ran an export three months ago and have had 40 conversations in the Project since then, those 40 conversations are NOT in your old export. Run a fresh export immediately before deleting any Project.
A GDPR Subject Access Request (Anthropic's privacy portal) returns a more complete data package that may include data not in the standard Settings export. However, GDPR requests take up to 30 days to process — they are not a substitute for a pre-deletion backup checklist.
Four-step backup checklist before deleting a Claude Project
Run these four steps in order before deleting any Claude Project that contains information you want to keep:
-
Export conversations.json from Settings. Settings → Privacy (or Your Data) → Export your data → Download the ZIP. Unzip and verify the project_uuid for your Project appears at least once in conversations.json. This confirms the Project's conversations are in the export. Run
cat conversations.json | jq '[.[] | select(.project_uuid == "YOUR_UUID")] | length'to count how many conversations are included. - Copy the Project Instructions text. Open the Project → Project settings → Custom instructions (or "What Claude should know"). Select all text and copy it to a local file. This is the only way to preserve the Instructions — there is no export path.
- Download all uploaded Knowledge Base files. Open the Project → Knowledge tab. For each uploaded file, click the download icon (or three-dot menu → Download). If you originally uploaded the file from your local machine, your local copy should still exist — but if you're not certain, download from the UI. Create a local directory named after the Project UUID and save the files there.
- Copy all pasted-text Knowledge Base entries. In the Knowledge tab, look for entries that show as text blocks (not file attachments). Open each one and copy the text content to a local file. These have no download button — copy is the only path. This is the step most commonly skipped and the one that causes the most data loss.
After completing these four steps, you have a local backup of everything the Project contained. The Project deletion is then safe.
Claude's autonomous memory vs Project Knowledge Base — two distinct systems
Claude.ai has two separate "memory" systems that are commonly confused. Understanding the distinction matters for export purposes because they have different export behaviors and different deletion consequences.
Autonomous memory (Claude remembers you across all conversations)
Claude's autonomous memory feature learns facts about you from conversations and stores them as discrete memory items that persist across all future conversations. Examples: "User is a senior backend engineer", "User's team uses PostgreSQL", "User prefers TypeScript over JavaScript." These are stored globally — they apply to all your Claude.ai conversations, not just a specific Project.
Memories are created automatically when Claude encounters personally relevant information in a conversation, or when you explicitly say "remember that..." Memories are shown to Claude as a hidden system-context injection before each response. You can view all memory items in Settings → Your Data & Privacy → Memory. You can delete individual memories or clear all at once.
Autonomous memories are NOT in the conversations.json export. They are system-side context, not conversation messages. To preserve your memory list before clearing it, copy it manually from the Settings panel. For a complete portable export including memories, submit an Anthropic GDPR/CCPA Subject Access Request.
Project Knowledge Base (context you deliberately provide for a Project)
The Knowledge Base is a set of files and text blocks you explicitly upload to a specific Project. Unlike autonomous memories (which Claude learns passively), Knowledge Base entries are deliberate additions that you control. The Knowledge Base is Project-scoped — its contents are only visible within that Project's conversations, not in other Projects or non-Project conversations.
The memory toggle in Project settings
Each Claude Project has a Memory toggle in its settings. When enabled (the default), Claude uses your global autonomous memories within that Project's conversations. When disabled, Claude does not inject your global memories as context for that Project — useful when the Project's Knowledge Base provides conflicting or more specific context that should take precedence. The Memory toggle does not affect whether memories are stored — it only controls whether they're used in that Project's conversations.
| Autonomous memory | Project Knowledge Base | |
|---|---|---|
| Scope | Global — applies to all conversations | Project-scoped — only visible within this Project |
| How created | Claude learns automatically, or via explicit instruction | You upload files or paste text explicitly |
| In conversations.json export? | No — not included | No — file names only, no file bytes or pasted text |
| Lost on Project deletion? | No — global memories persist after Project deletion | Yes — Knowledge Base deleted with the Project |
| Manual export path | Copy from Settings → Memory panel | Download files from Knowledge tab; copy pasted text |
| GDPR request includes? | Yes — more complete than Settings export | Likely file metadata only, not bytes |
Why architecture deliberation in Claude Projects needs special handling
Engineers frequently use Claude Projects as a structured workspace for architecture deliberation: the Project Instructions define the system context ("this is a Django monolith, we're migrating to microservices, here are the constraints"), the Knowledge Base contains existing ADRs and API contracts, and the conversations within the Project are the actual architecture discussions. This is an effective pattern — the Project Instructions eliminate repetitive context-setting, and the Knowledge Base means Claude understands the constraints without having to re-explain them each session.
The risk is that this pattern concentrates architectural knowledge in a Claude Project that is not backed up anywhere except Anthropic's servers. When the Project is eventually deleted (cleanup, account change, organizational change), three types of architectural context disappear: the Project Instructions (often the most concise statement of the system's constraints and conventions), the Knowledge Base files (particularly pasted-text entries containing decision rationale), and the conversations themselves if export hasn't been run.
The most valuable recovery path for the conversation layer is the WhyChose extractor: it reads your Claude.ai conversations.json export and surfaces the structured decisions from the architecture deliberation sessions — alternatives considered, trade-offs, constraints identified, decisions made. The extractor works on the conversation transcript, which is the one layer that is included in the standard export. It cannot recover Project Instructions or Knowledge Base contents — those require manual backup before deletion.
The decision-capture workflow for Claude Project users: run regular exports (monthly minimum, before any major conversation batch), keep local copies of Project Instructions and Knowledge Base files, and run the extractor on the conversations after each significant architecture deliberation session. The extractor output feeds the ADR that documents the outcome.
Related questions
Are Claude Project conversations included in the standard data export?
Yes — Project conversations appear in conversations.json tagged with the project_uuid. What is not included: Project Instructions text, Knowledge Base file contents, pasted-text Knowledge Base entries. The standard export captures conversations; it does not capture the context layers (Instructions + Knowledge Base) that shaped those conversations. If you delete a Project without first exporting, all conversations and all context layers are permanently lost from Anthropic's servers.
What happens to Knowledge Base files when you delete a Claude Project?
Files you uploaded from your local machine: file bytes deleted from Anthropic's servers, but your local originals are unaffected. Text you pasted directly into the Knowledge Base using "Add text": permanently deleted — there is no file on your machine and no download path. The standard export does not include either type of Knowledge Base content. To preserve the Knowledge Base, manually download uploaded files from the Knowledge tab and copy pasted-text entries before deleting the Project.
What is Claude's memory feature and how is it different from the Project Knowledge Base?
Autonomous memories are facts Claude learns about you across all conversations (global scope, passive creation). Knowledge Base files are documents you explicitly upload to a specific Project (Project scope, deliberate creation). Neither appears in the conversations.json export — both are system-side context injections, not conversation messages. Global memories persist after Project deletion; Knowledge Base contents are deleted with the Project. The Memory toggle in Project settings controls whether global memories are used within a Project's conversations, but does not affect memory storage.
How do you export or view Claude's autonomous memory entries?
View memory entries in Settings → Your Data & Privacy → Memory. Individual items can be deleted; "Clear all memories" clears the entire list. There is no one-click CSV export — the settings conversations.json export does not include memories. To preserve the list, copy it manually from the Settings panel before clearing. For a more complete data package that includes memory entries, submit a GDPR Subject Access Request via Anthropic's privacy request form — this process takes up to 30 days and returns account data not included in the standard Settings export.
Further reading
- How to export a Claude Project — jq script and format reference — the technical complement to this page. Where this page covers what survives the export and the backup checklist before deletion, that page covers the conversations.json format for Project conversations (the project_uuid field, the flat array structure, and the 22-line jq script that rebuilds per-Project directories from the export). Start with this page for the backup strategy; go to that page for the jq processing recipes.
- How to export Claude conversations — the complete guide — the general export walkthrough for claude.ai conversations including both Project and non-Project conversations. Covers the exact Settings path to trigger the export, the ZIP structure, the conversations.json schema, and what the export includes across all Claude.ai conversation types.
- Claude API conversation export — the statelessness reference — the Anthropic Messages API is stateless: each API call includes the full messages array and nothing is persisted after the response. If your Claude Project was using a Claude.ai interface rather than the API, this page explains why the two are architecturally different and why claude.ai conversations are recoverable through export while API-level conversations require capture at the time they're made.
- How to extract architecture decisions from Claude conversations — once you have the conversations.json export from your Claude Project, this page covers how to identify the decision-containing conversations (by keyword search, by conversation length, by date range) and how to structure the extracted decision as an ADR. The WhyChose extractor automates the structure extraction; this page explains the manual path for engineers who want to understand what the extractor does before running it.
- ChatGPT Projects export — the symmetric reference — ChatGPT Projects have the same flat-export problem as Claude Projects: the standard conversations.json export includes Project conversations but flattens the Project boundary. This page covers the ChatGPT-side equivalent, including a jq script to rebuild per-Project directories from the ChatGPT export format. Read alongside this page if you use both Claude Projects and ChatGPT Projects for architecture deliberation.
- The open-source extractor — reads your claude.ai conversations.json export and surfaces architecture decisions as structured records. For Claude Project users, this is the tool that converts the conversation layer (the one layer the export captures) into actionable ADR inputs. Run it immediately after export on any Project that contained architectural deliberation, before the context fades.