Claude Persistent Memory: Documented Limits, Project Files, and Storage Beyond 200k

Anthropic documents that Claude Project files have an unlimited file count up to 30MB each, while chat uploads allow 20 files at 500MB each, but all project content must fit within the active context window. That limitation catches engineering teams by surprise when they attempt to treat a Claude Project as a permanent, searchable database. While an individual conversation on Claude.ai accepts temporary file attachments, Project knowledge behaves according to strict inference constraints.

When you upload a document to an individual chat session, the system extracts text or image tokens for that single interaction. When that conversation concludes or reaches memory limits, those documents do not automatically carry over into subsequent discussions. Claude Projects solve this fragmentation by providing an organizational space where custom instructions and reference documents persist across every chat created inside the project.

The phrase "unlimited files" in Anthropic documentation comes with an architectural ceiling: all project files are prepended to the input context of every query submitted within the project. The entire collection of project files, system directives, conversation turns, and generated code must collectively fit inside Claude's 200,000-token context window.

Document Parsing and Page Ceilings

Document handling varies by file format and page count. For PDF documents, Claude processes visual elements such as charts, diagrams, and illustrations only when the document contains 100 pages or fewer. For PDFs containing between 101 and 1000 pages, Claude extracts plain text and bypasses image processing. Documents exceeding 1000 pages fail immediately with an upload error.

For spreadsheets, documents, and code files, Claude extracts raw text representations. When project files approach capacity, Claude displays a visual context indicator warning that additional files will prevent new messages from processing. Because every prompt submitted inside a project prepends the active project files into the context window, a project loaded with 150,000 tokens of reference material leaves only 50,000 tokens for the user prompt, reasoning scratchpad, and assistant response.

• How to Configure Hermes Agent Database Storage for Persistent MemoryImplementing hermes agent database storage for persistent memory requires a structured approach to local SQLite...
• How to Connect Cline to MCP Storage for Persistent MemoryWhile 90% of developers run Model Context Protocol (MCP) servers locally, this local storage restriction locks AI agent...
• Claude Code Memory Limits: CLAUDE.md Sizing, Auto-Memory, and Context WorkaroundsClaude Code memory limits represent the size thresholds and retention boundaries governing CLAUDE.md files, persistent...
• Cline vs. Claude Code: Comparing Agent Memory ArchitecturesLocal AI agent memory architectures like Cline's Memory Bank and Claude Code's Auto-Memory are designed for isolated,...
• Claude Memory Limit: Working Memory, Context Allocation, and Long-Term StorageUnderstanding the Claude memory limit requires distinguishing between active working context (200,000 to 1,000,000...
• Claude Max Tokens: Output Limits, Thinking Budgets, and API ParametersClaude max tokens refers to the max_tokens parameter in Anthropic's API that governs the upper bound of generated...

More on this subject: Claude and Claude Code (321 guides)

Claude persists memory across conversations through project instructions, uploaded custom project files, and local configuration files. However, Claude does not maintain a cross-chat neural memory by default; all persistent project context must be loaded into the active inference context window.

Unlike consumer AI assistants that store episodic user facts in a hidden vector database, Claude's web interface relies on explicit context injection. Persistent memory in Claude operates across four distinct layers:

1. Custom Instructions: A static system prompt configured at the project level that guides Claude's persona, formatting rules, and domain-specific terminology across all project chats.
2. Project Knowledge Files: Reference documents uploaded to the project that Anthropic converts into plain text and injects into the prompt context prefix.
3. Local Memory Files: Developer tools like Claude Code inspect markdown files (CLAUDE.md and auto-generated memory logs) saved on local disk to recall technical directives.
4. Remote Context Servers: Model Context Protocol (MCP) endpoints that provide dynamic tool-based search across external cloud workspaces without stuffing raw documents into the context window.

Prompt Caching and Context Cost

Loading persistent files into prompt context creates significant computational overhead. To reduce latency and operational expense, Anthropic applies prompt caching. When project context exceeds 1024 tokens and remains identical across subsequent interactions, Claude caches the processed prompt prefix in GPU memory.

Cached prompt tokens reduce response latency and lower per-query processing overhead. However, prompt cache entries expire after 5 minutes of inactivity. When a team member opens a project chat after a brief pause, the entire corpus must be re-read and processed from scratch. Modifying a single file in the project invalidates the entire cache prefix, requiring fresh token ingestion across every active chat.

Claude Code approaches persistence differently than the web interface. Designed for terminal-based development, Claude Code uses two complementary memory systems: developer-maintained instruction files and an autonomous memory manager.

Developer instructions take the form of CLAUDE.md or AGENTS.md files checked into version control. Claude Code loads these instructions at the start of every session based on an explicit scope hierarchy:

• Managed policy: Set organization-wide by engineering administrators at /Library/Application Support/ClaudeCode/CLAUDE.md on macOS, /etc/claude-code/CLAUDE.md on Linux, or C:\Program Files\ClaudeCode\CLAUDE.md on Windows.
• User instructions: Stored at ~/.claude/CLAUDE.md for personal developer shortcuts and formatting preferences across all local codebases.
• Project instructions: Stored at ./CLAUDE.md or ./.claude/CLAUDE.md to document repository build commands, testing patterns, and architectural boundaries.
• Local instructions: Stored at ./CLAUDE.local.md for personal test keys and local sandbox URLs, typically added to .gitignore.

Auto Memory Architecture and Hard Bounds

Alongside static rules, Claude Code features auto memory, an autonomous mechanism where the model writes notes about your preferences and project conventions. Claude Code stores auto memory on your local machine under ~/.claude/projects/<project>/memory/, mapping each repository to a stable directory across Git worktrees.

Claude Code categorizes its observations into four structured note types:

• User notes: Records your technical role, domain expertise, and communication preferences.
• Feedback notes: Captures explicit corrections, verified solutions, and rejected code patterns.
• Project notes: Tracks active milestones, deadlines, and operational decisions that cannot be derived directly from source code.
• Reference notes: Catalogs external pointers, such as links to issue trackers, documentation wikis, or internal dashboards.

The primary constraint of auto memory is index sizing. Claude Code loads the first 200 lines or 25KB of the project memory index at the start of every conversation session. If MEMORY.md exceeds 200 lines or 25KB, content beyond that boundary is discarded during session initialization. Claude Code actively monitors index growth, prompting the model to summarize older notes, merge related lines, and offload detailed explanations into dedicated topic files in the memory directory.

Developers can inspect and modify these notes at any time using the /memory command in Claude Code. To turn off auto memory, set CLAUDE_CODE_DISABLE_AUTO_MEMORY=1 in your environment or configure "autoMemoryEnabled": false in ~/.claude/settings.json.

Scale Claude Persistent Memory Beyond Context Limits

Connect Claude to an intelligent Fast.io workspace using Model Context Protocol. Index large document collections for semantic retrieval without exhausting your 200,000-token inference window. Monthly plans start with a 14-day free trial, which requires a credit card.

Start 14-Day Trial

When a team's reference library spans hundreds of technical specifications, API contracts, customer agreements, and architecture briefs, stuffing raw files into Claude Projects or CLAUDE.md collapses under token limits. Storing thousands of files locally in Git repositories bloats code checkouts and isolates knowledge on individual developer machines. Commodity cloud drives such as Google Drive, Dropbox, Box, or raw S3 buckets provide storage capacity, but they lack native semantic indexing and expose complex API models for conversational assistants.

Fast.io provides an intelligent workspace platform that bridges the gap between massive document archives and Claude's context constraints. Instead of uploading entire documents directly into a project prompt, your corpus resides in a secure, organization-owned workspace where Intelligence Mode indexes files for full-text and semantic search.

Connecting Claude to Fast.io relies on the Model Context Protocol (MCP) using Streamable HTTP. Depending on your Claude interface, the setup connects directly without local middleware:

Setting Up Fast.io MCP in Claude Applications

For Claude web, desktop, and mobile applications:

1. Open Customize in Claude settings, then select Connectors.
2. Add a custom connector and enter the Streamable HTTP endpoint: https://mcp.fast.io/mcp/tools.
3. Select Connect and complete OAuth authorization in the browser window to grant workspace access.
4. In any conversation, enable Fast.io from the Connectors menu to allow Claude to query your indexed files.

Connecting Claude Code to Fast.io MCP

For terminal-based workflows using Claude Code, register the remote HTTP server using the CLI:

claude mcp add --transport http fast-io https://mcp.fast.io/mcp/code

After adding the connector, execute /mcp inside Claude Code to complete browser-based OAuth authentication. Once authenticated, Claude Code gains access to consolidated MCP tools (search, execute, upload) capable of retrieving precise document sections on demand. Technical teams can review setup details in the Fast.io MCP documentation or inspect the agent tooling guide.

On-Demand Retrieval vs. Context Saturation

Using remote MCP storage fundamentally changes token economics:

• Semantic Precision: When you ask Claude a technical question, the assistant calls Fast.io's hybrid search through MCP, pulling only the relevant paragraphs into context rather than an entire 200-page specification.
• Context Preservation: Your 200,000-token context window remains completely open for multi-step reasoning, comprehensive code generation, and long conversation turns.
• Unified Team Knowledge: Cloud Sync connects Google Drive, Dropbox, Box, and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. When documentation updates in Box or Drive, the Fast.io workspace re-indexes the changes, making fresh context immediately queryable by Claude.
• Governance and Traceability: Organizations manage permissions per organization, workspace, and share. Every modification is recorded in a detailed activity log tracking uploads, edits, moves, and deletions, while per-file version history protects against accidental overwrites. Teams building AI integrations can explore dedicated storage for agents to structure their repositories.

Managing Claude persistent memory across complex projects requires deliberate boundaries between static operational rules, local development notes, and organizational knowledge repositories. Implementing structured context practices prevents context pollution and reduces inference costs:

1. Maintain Lean Instruction Files

Keep CLAUDE.md and project instructions concise and focused. Restrict static instructions to non-obvious rules: specific build targets, mandatory linting flags, and architectural boundaries. Avoid placing reference documentation, database schemas, or API payload examples in static instruction files; store those assets in external indexed storage where Claude can retrieve them when relevant.

2. Audit Auto Memory Regularly

Claude Code's auto memory accumulates notes rapidly during active development. Periodically run /memory to review saved entries. Purge obsolete corrections that relate to closed bugs, verify that project notes reflect current milestones, and consolidate overlapping entries to keep MEMORY.md well below the 200-line and 25KB loading limit.

3. Cap In-Project Files for Maximum Reasoning Headroom

When using Claude Projects on Claude.ai, limit uploaded files to foundational documentation that every conversation requires. Keeping project files compact ensures that the majority of your 200,000-token context window remains available for deep reasoning and extensive code generation. If your reference material exceeds this threshold, migrate the files to an external MCP workspace.

4. Structure Document Data with Metadata Views

For contracts, technical sheets, research papers, and invoices, unstructured text extraction can lead to ambiguous retrieval. Fast.io Metadata Views allow teams to convert unstructured files into structured, queryable databases. Users define extraction fields in plain language, and the system generates a typed schema (Text, Integer, Decimal, Boolean, URL, JSON, Date & Time) across workspace documents. Claude can query specific structured fields through MCP without reading entire files, optimizing context usage and response accuracy.

5. Establish Multi-Agent Coordination Boundaries

When pairing Claude Code with other AI agents across the same codebase, coordinate file access through versioned workspaces. Fast.io provides advisory per-file leases via MCP actions (lock-acquire and lock-release on storage_manage) so team members and automated agents can signal active file edits while version history preserves every file revision.