Claude Desktop File Size Limits: Chat Uploads, Projects, and MCP Buffers

Anthropic caps direct chat attachments in Claude Desktop at 500MB per file across a maximum of 20 files, while Project knowledge files face a 30MB limit per document. The Claude Desktop file size limit is 500MB per file in direct chat uploads and 30MB in Projects, but local filesystem MCP integrations encounter practical JSON-RPC buffer limits between 4MB and 10MB. When you drag and drop a file into a Claude conversation on macOS or Windows, the client hashes the asset and transmits it to Anthropic's ingestion pipeline. The application extracts the underlying text and visual components before sending the formatted prompt to the Claude foundation model.

As verified in the Claude Help Center, Anthropic documents that Claude chat uploads allow up to 20 files per conversation at 500MB each. This allowance provides substantial headroom for large standalone assets such as video transcripts, extensive codebases packaged as plain text, or comprehensive reports. However, specific file formats carry operational constraints beyond raw byte size:

• PDF Documents: Anthropic documents that Claude chat uploads accept PDF documents limited to 1,000 pages per file. Anthropic applies multimodal visual processing to analyze text alongside diagrams, charts, and embedded graphics in PDFs up to 100 pages. For PDFs ranging from 101 to 1,000 pages, the engine switches automatically to text-only extraction and ignores visual elements. Uploading a PDF exceeding 1,000 pages causes an immediate rejection error indicating the file is too large.
• Image Assets: Images support resolutions up to 8000x8000 pixels. Accepted formats include JPEG, PNG, GIF, and WebP. For optimal OCR and visual comprehension, Anthropic recommends resolutions of at least 1000x1000 pixels.
• Structured Data and Office Documents: Supported formats include DOCX, CSV, TXT, HTML, ODT, RTF, EPUB, JSON, and XLSX. Spreadsheets in XLSX format require enabling code execution and file creation within account settings. For non-PDF document formats, Claude extracts text exclusively and drops embedded imagery.

Claude Projects enforces a different architecture. Anthropic documents that Claude Project knowledge files are capped at 30MB per file. While Anthropic documents no fixed cap on the number of files you can add to a Project, the cumulative volume of text across all project documents must fit within Claude's conversational context window. Understanding how these thresholds compare across deployment channels prevents workflow interruptions:

• Windsurf File Size Limits in Devin Desktop: Indexing Caps and RulesCognition renamed Windsurf to Devin Desktop on 2026-06-02, transitioning the Cascade assistant into Devin Local while...
• Claude Code File Size Limits: CLI Truncation and Large File HandlingClaude Code imposes strict operational file size limits in the terminal, truncating file reads and command outputs past...
• How to Handle Claude Code Token Limits in Large ProjectsClaude Code enforces a 200,000-token context window that fills quickly on complex repositories as file reads and bash...
• Managing Claude Code Daily Limits: Spend Caps, Quotas, and Unattended WorkflowsAutonomous coding agents can rapidly exhaust token quotas and project context when executing unbounded multi-turn loops...
• 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...
• Claude Code Rate Limits: 5-Hour Usage Caps, 429 Errors, and WorkaroundsClaude Code rate limits enforce execution thresholds across terminal requests, tokens per minute, and five-hour rolling...

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

Most guides repeat vendor upload figures without addressing the operational bottleneck developers hit when connecting local storage through the Model Context Protocol (MCP). Claude Desktop runs as an Electron application on macOS and Windows, packaging a Chromium frontend with a local Node.js runtime. When you configure a local filesystem MCP server (such as @modelcontextprotocol/server-filesystem) in your desktop configuration, Claude Desktop spawns the server as an independent child process. Communication between the desktop application and the MCP server occurs over standard input and standard output (stdio) using JSON-RPC 2.0 messages.

This architectural pattern works well for inspecting project directories and editing configuration files, but it encounters immediate friction when handling large local files:

1. JSON Serialization and Memory Ceilings: When Claude Desktop invokes a tool like read_file, the local MCP server reads the file from disk, loads the content into memory, and wraps the payload inside a stringified JSON-RPC message. Reading a massive server log file or database export requires allocating a continuous string in V8 memory. The serialized JSON message, escaping quotes and newlines, expands the byte size substantially. In practice, Node.js child process stream buffers and Electron IPC channels degrade or drop messages when single payloads exceed practical buffer thresholds.
2. Hardcoded SDK Request Timeouts: Under the hood, the Model Context Protocol TypeScript SDK enforces a default request timeout of 60 seconds (DEFAULT_REQUEST_TIMEOUT_MSEC = 60000). If a local MCP server takes longer than 60 seconds to scan a massive folder hierarchy, calculate file hashes, or parse a dense archive, Claude Desktop aborts the operation and returns MCP error -32001: Request timed out. Adding custom "timeout" flags inside claude_desktop_config.json fails to resolve the issue because the desktop client ignores dynamic overrides for internal SDK thresholds.
3. Stdio Stream Pollution: Local MCP servers must maintain strict separation between communication channels. The JSON-RPC protocol relies entirely on clean stdout streams. If an underlying library or custom script outputs debug statements, initialization banners, or diagnostic traces to stdout rather than stderr, the JSON parser encounters syntax errors (MCP error -32603). When reading large archives, unhandled buffer warnings written to stdout corrupt the data stream and crash the MCP connection.
4. Context Saturation from Tool Returns: Even if a local server successfully buffers and transmits a multi-megabyte raw text file over stdio, the entire content is injected directly into Claude's prompt context as the tool response. When Claude Project knowledge approaches context window limits, Claude enables RAG mode to expand capacity by up to 10x, but local tool outputs have no such automatic retrieval buffer. Dumping hundreds of thousands of words into a single tool turn instantly exhausts the conversational context window, resulting in session corruption, UI state freezes, or sudden conversation aborts.

The primary reason users encounter failures with the 30MB Project file limit is the fundamental difference between storage bytes on disk and tokens in memory. Anthropic documents that Claude Project files are capped at 30MB, which can suggest that users can upload extensive technical documentation or code repositories. In practice, attempting to upload even a fraction of that volume in plain text will exhaust your context window before you approach the file size ceiling.

In natural English text, one token corresponds to approximately four characters, or roughly 0.75 words. A single megabyte of plain text contains approximately one million characters, translating to hundreds of thousands of tokens. Because standard Claude Pro and Team plans feature a 200,000 token context window, a single large file of uncompressed text can exceed the entire capacity of the model.

Token density varies widely depending on file format and content structure:

• Tabular Datasets (CSV, TSV, JSON): Structured data formats exhibit exceptionally high token density. Repeated column headers, JSON syntax keys, commas, quotes, and numerical values prevent tokenizers from grouping characters into common words. A dense data export from a database can consume hundreds of thousands of tokens, overwhelming a Project context within moments.
• Source Code and Schemas: Programming languages contain dense punctuation, camelCase identifiers, and indentation spaces that inflate token counts. A multi-file repository containing complex source code frequently requires hundreds of thousands of tokens.
• Formatted Prose (PDF and DOCX): While prose maintains predictable token ratios, PDFs often contain boilerplate footers, metadata dictionaries, and repetitive legal disclaimers that compound token consumption across multiple documents.

When your Project knowledge base approaches the context ceiling, several failure modes occur. The desktop interface becomes sluggish as prompt caching recalculates large context trees. In multi-turn conversations, older messages are truncated or dropped to accommodate the massive Project knowledge base. More critically, models experience attention dilution: when searching for specific answers across massive preloaded reference material, retrieval precision drops compared to targeted query lookups.

As documented in the Claude Help Center, when Claude Project knowledge approaches context window limits, Claude enables RAG mode to expand capacity by up to 10x. However, this built-in capability operates exclusively inside the Anthropic hosted environment. It does not solve local desktop file access, cannot be updated programmatically from local pipelines without manual re-uploads, and provides no shared storage layer across different development tools or team members.

Query Gigabyte Archives in Claude Without Context Crashes

Connect Claude Desktop to persistent Fast.io workspaces over remote MCP. Index your largest document collections, search by meaning with citations, and stop fighting attachment caps. Monthly plans start with a 14-day free trial.

Start 14-Day Trial

When working with files that exceed Claude Desktop upload limits or MCP buffer thresholds, developers rely on several architectural patterns to process large archives without crashing local runtimes.

1. Programmatic File Chunking

Rather than attempting to feed a massive log file or dataset into Claude Desktop in one pass, split the source file into deterministic smaller segments. Keeping individual chunk files small ensures they stay within local MCP buffer safe zones and consume manageable token budgets.

The following Python script reads any large text file and divides it into clean, line-bounded segments suitable for Claude Desktop ingestion:

import os
import sys

def split_text_file(input_path, max_bytes=2 * 1024 * 1024):
    """Split large text files into 2MB chunks for reliable processing."""
    if not os.path.exists(input_path):
        print(f"File not found: {input_path}")
        return
    chunk_idx = 1
    current_bytes = 0
    current_lines = []
    base_name, ext = os.path.splitext(input_path)
    with open(input_path, "r", encoding="utf-8", errors="replace") as f:
        for line in f:
            line_bytes = len(line.encode("utf-8"))
            if current_bytes + line_bytes > max_bytes and current_lines:
                output_path = f"{base_name}_part{chunk_idx}{ext}"
                with open(output_path, "w", encoding="utf-8") as out:
                    out.writelines(current_lines)
                print(f"Created {output_path} ({current_bytes} bytes)")
                chunk_idx += 1
                current_lines = []
                current_bytes = 0
            current_lines.append(line)
            current_bytes += line_bytes
        if current_lines:
            output_path = f"{base_name}_part{chunk_idx}{ext}"
            with open(output_path, "w", encoding="utf-8") as out:
                out.writelines(current_lines)
            print(f"Created {output_path} ({current_bytes} bytes)")

if __name__ == "__main__":
    if len(sys.argv) > 1:
        split_text_file(sys.argv[1])

2. Pre-Filtering and Targeted Extraction

Passing an entire raw data dump into an AI model is inefficient. You can drastically reduce payload size by using standard shell utilities to extract relevant subsets before exposing the data to Claude Desktop:

grep -E "ERROR|CRITICAL|FATAL" production-api.log | tail -n 500 > error-window.log
jq '.users[] | {id: .id, role: .role, last_login: .last_login}' full-export.json > user-roles.json

3. Repository Hygiene for Filesystem MCP

If you use @modelcontextprotocol/server-filesystem to grant Claude Desktop access to local directories, restrict the server path to specific subfolders rather than pointing it at root project directories. Ensure build artifacts and dependencies are strictly excluded. Large directories like node_modules, dist, .git, .venv, and generated lockfiles (package-lock.json, pnpm-lock.yaml) contain thousands of files and millions of lines of machine-generated code that can trigger MCP discovery timeouts during startup.

4. Evaluating Local Vector Search vs. Cloud Workspace Storage

Some developers deploy local vector databases (such as Chroma, LanceDB, or SQLite-VSS) through custom local MCP servers to index large archives locally. While this approach keeps data on your local drive, it introduces substantial friction:

• Running local embedding models consumes system RAM and CPU cycles alongside Claude Desktop.
• Managing chunking strategies, vector re-indexing, and local SQLite databases requires continuous maintenance.
• Local vector databases remain locked to a single laptop, preventing teammates or automated agents from sharing the same indexed documents.
• Local MCP tool execution remains bounded by standard stdio buffer caps and 60-second execution timeouts.

The permanent solution for large archives is decoupling storage and retrieval from Claude Desktop's local process memory. Instead of attaching massive files to chats or forcing bloated payloads through local JSON-RPC pipes, files reside in persistent cloud workspaces where they are indexed on arrival. Claude Desktop then queries the workspace remotely, retrieving only the specific excerpts required to answer your prompt.

Fast.io provides an intelligent workspace platform designed for human teams and AI agents. It leaves Claude's native upload limits untouched while providing a dedicated repository for files that do not fit into direct chats or local buffers. You can read more about connecting AI clients in the Fast.io storage for agents guide.

How Remote MCP Workspace Access Operates

When you upload documents to a Fast.io workspace, the platform's Intelligence Mode parses and indexes the contents across three dimensions: full-text lexical search, semantic vector embeddings, and structured metadata properties. Rather than sending entire files across the network, Claude Desktop interacts with the workspace via a remote Model Context Protocol (MCP) server running over Streamable HTTP at https://mcp.fast.io/mcp/tools.

When you submit a prompt regarding a 400-page contract, a massive software manual, or an archive of quarterly reports, Claude invokes the storage tool with the search action. The remote server executes hybrid search across the workspace and returns concise, relevant passages with source document citations. The active context window remains clean, local memory usage never spikes, and operations complete well within MCP timeout limits. Detailed technical setup instructions are available in the Fast.io MCP setup documentation.

Step-by-Step Setup in Claude Desktop

Connecting Claude Desktop to Fast.io requires no command-line scripts or configuration file editing:

1. Open Claude Desktop on your computer.
2. Select Customize from the user menu, then choose Connectors.
3. Select Add custom connector.
4. In the connector URL field, paste https://mcp.fast.io/mcp/tools.
5. Select Connect. A browser window opens prompting you to sign in to your Fast.io account and select which workspaces the connector can reach.
6. Return to Claude Desktop. In any conversation, open the + menu under Connectors and enable Fast.io.

Multi-Cloud Synchronization and Scale

For organizations with data dispersed across legacy platforms, Cloud Sync connects Google Drive, Dropbox, Box and OneDrive folders to a workspace, one-way or two-way, on a schedule or on demand. Files synced from these sources are automatically indexed by Intelligence Mode, making enterprise repositories instantly searchable by Claude Desktop without manual upload steps.

Workspace plans provide scalable capacity for engineering teams, as outlined on the Fast.io pricing page:

Monthly plans start with a 14-day free trial that requires a credit card. Credits meter AI work only. Storage beyond the plan is $0.015 per GB a month and extra bandwidth $0.04 per GB, billed in money. Team members collaborate within org-owned workspaces featuring per-file version history, role-based access permissions at the organization, workspace, and share levels, and a detailed activity log recording uploads, edits, moves, deletions, membership and permission changes, and share creation.