LibreChat File Upload Limits: How to Configure the 25MB Default and Expand Storage

The default LibreChat file upload limit is 25MB per individual file and 10 files per prompt turn, configured through the fileConfig.endpoints.default.fileSizeLimit and fileConfig.endpoints.default.fileLimit parameters in librechat.yaml. When self-hosting LibreChat, administrators often discover that dropping a large reference archive or dataset into the chat interface triggers an immediate rejection or an unexpected network failure. The LibreChat file upload limit is a server configuration setting, defaulting to 25MB per file and 10 files per prompt, that controls the maximum size and number of attachments users can upload to LibreChat.

File handling in LibreChat operates across several architectural layers. Rather than applying a single blanket threshold, the application evaluates uploads through six distinct configuration parameters defined under the fileConfig block in LibreChat file configuration:

• serverFileSizeLimit: The global maximum size for any file uploaded to the host instance, specified in megabytes. In LibreChat's server configuration schema, serverFileSizeLimit defines the global maximum size for any file uploaded to the server, specified in megabytes, establishing an overarching ceiling across all endpoints.
• fileSizeLimit: The maximum size allowed for each individual file attached to a specific endpoint (such as default, assistants, or agents), specified in megabytes.
• totalSizeLimit: The cumulative size limit across all files submitted simultaneously in a single prompt or message turn.
• fileLimit: The maximum count of individual files allowed in a single upload request.
• fileContextSizeLimit: The aggregate size boundary (defaulting to 128 MB) of model-bound attachments admitted into a single turn. This acts as a per-turn prompt safety ceiling, separate from upload storage limits.
• fileContextCharLimit: The maximum number of extracted text characters (defaulting to 1,000,000) admitted into an agent prompt buffer from attachments.

LibreChat calculates one megabyte strictly as binary bytes: 1 x 1024 x 1024 (1,048,576 bytes). If an incoming file exceeds this binary calculation even by a few bytes, the backend rejects it.

For image files, LibreChat provides an automatic client-side resizing mechanism via clientImageResize. When enabled, the browser resizes images before sending them over the network:

• maxWidth: Maximum width in pixels (defaulting to 1900).
• maxHeight: Maximum height in pixels (defaulting to 1900).
• quality: JPEG compression quality from 0 to 1 (defaulting to 0.92).

This client-side transformation prevents oversized mobile photos and high-resolution screenshots from exhausting server memory or tripping network request limits.

Attaching large document libraries directly to conversational interfaces introduces practical capacity boundaries across every modern AI platform. Anthropic documents that Claude web chat accepts up to 20 files at up to 500 MB each, while Claude Projects accepts files up to 30MB each with no fixed file-count cap (checked on 2026-09-14). However, the practical ceiling on a Claude Project remains the context window. When an organization attempts to attach a multi-gigabyte corpus across dozens of contracts or product specifications, prompt tokens saturate and inference degrades. LibreChat administrators encounter an even earlier boundary: local server disk capacity and default container limits.

The following comparison table outlines documented file upload limits across major AI chat interfaces and endpoints as of November 2026:

• Notion File Upload Limits: Size Caps by Plan and Large-File WorkaroundsNotion limits individual file uploads to 5MB on the Free plan and provides unlimited file uploads with a 5GB maximum...
• ChatGPT Plus Upload Limit: File Size, Count, and Rolling CapsThe ChatGPT Plus upload limit caps subscribers at `80` file uploads every 3 hours, a `512 MB` file ceiling, and a...
• Gemini Gems File Limit: 10-File Upload Cap and Knowledge Base SolutionsThe Gemini Gems file limit caps custom knowledge bases at 10 reference files and 100 MB per document. While attached...
• Open Interpreter File Limits: Context Windows, Large Datasets, and MCP IntegrationAn Open Interpreter file limit refers to the token ceiling and local memory constraints that occur when feeding large...
• Google NotebookLM File Limit: 50 Sources, Word Counts, and Large Corpus WorkflowsThe NotebookLM file limit in Gemini Notebook restricts standard accounts to 50 active sources per notebook,...
• Box File Request vs Intelligent Agent Rooms: Inbound File Intake ComparisonInbound file intake requires more than dumping documents into static folders. While Box File Request collects files...

More on this subject: Agent File and Document Workflows (397 guides)

Self-hosted LibreChat instances manage application behavior through the librechat.yaml configuration file placed at the root of the deployment directory. To alter file upload boundaries, administrators define a top-level fileConfig block.

The following configuration example demonstrates how to set global server boundaries while configuring explicit limits for standard chat, autonomous agents, and custom provider endpoints:

version: 1.2.1
fileConfig:
  serverFileSizeLimit: 100
  avatarSizeLimit: 2
  fileTokenLimit: 100000
  fileContextSizeLimit: 128
  fileContextCharLimit: 1000000
  clientImageResize:
    maxWidth: 1900
    maxHeight: 1900
    quality: 0.92
  endpoints:
    default:
      fileLimit: 10
      fileSizeLimit: 25
      totalSizeLimit: 50
      supportedMimeTypes:
        - "image/.*"
        - "application/pdf"
        - "text/.*"
    agents:
      fileLimit: 15
      fileSizeLimit: 50
      totalSizeLimit: 100
      supportedMimeTypes:
        - "image/.*"
        - "application/pdf"
        - "text/.*"
        - "application/json"
    assistants:
      fileLimit: 10
      fileSizeLimit: 50
      totalSizeLimit: 100
    anthropic:
      fileLimit: 20
      fileSizeLimit: 30
      totalSizeLimit: 100

A common trap in LibreChat configuration involves endpoint inheritance. The default key under fileConfig.endpoints serves as a fallback for standard model routes like OpenAI, Anthropic, Google, and Ollama. However, assistants and agents do not automatically inherit values from default. Both assistants and agents maintain their own internal defaults. If an administrator raises fileSizeLimit to 50 MB under default but omits the agents block, users interacting with custom agents will remain restricted by the narrower agent defaults.

Applying configuration updates requires reloading the server runtime. In Docker environments, verify that librechat.yaml is properly mounted in docker-compose.override.yml or docker-compose.yml:

services:
  api:
    volumes:
      - ./librechat.yaml:/app/librechat.yaml

After modifying the file, restart the API container to compile the new schema:

docker compose restart api

If you modify environment variables alongside librechat.yaml, recreate the container stack instead:

docker compose down && docker compose up -d

When a user encounters a librechat upload failed error in the interface, the issue rarely stems from LibreChat configuration alone. Upload workflows pass through reverse proxies, web application firewalls, rate limiters, and document parsing pipelines. A failure at any hop aborts the upload.

Reverse Proxy Request Body Restrictions

The most frequent cause of upload failure in production deployments is the reverse proxy. Nginx enforces a default request body size of 1 MB via its client_max_body_size directive. When a user uploads a 15 MB PDF into LibreChat, Nginx intercepts the HTTP POST request and returns an HTTP 413 Request Entity Too Large error before the payload ever reaches the Node.js backend.

To resolve this bottleneck, update the Nginx configuration file inside your http, server, or location block:

server {
    listen 443 ssl http2;
    server_name chat.example.com;
    client_max_body_size 100M;
    client_body_buffer_size 100M;
    location / {
        proxy_pass http://127.0.0.1:3080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_read_timeout 600s;
        proxy_send_timeout 600s;
    }
}

Verify the syntax and reload Nginx:

sudo nginx -t && sudo systemctl reload nginx

If your deployment runs behind Cloudflare, remember that Cloudflare edge proxies impose a request body limit of 100 MB on free and entry plans. Uploads exceeding 100 MB will fail at the edge before reaching your host server.

Environment Variable Rate Limits

LibreChat includes built-in rate-limiting mechanisms to protect servers against denial-of-service attempts. If users report that single small files upload successfully but multiple sequential uploads fail with generic network errors, check your .env configuration:

• FILE_UPLOAD_IP_MAX: Restricts the maximum number of file upload requests allowed per IP address within a set window.
• FILE_UPLOAD_USER_MAX: Restricts the maximum uploads permitted per authenticated user account.
• FILE_UPLOAD_USER_WINDOW: Defines the rate limit duration window in minutes (defaulting to 15).

When these values are set too aggressively, team members uploading several documents simultaneously will be throttled.

MIME Type Validation and Regex Compatibility

LibreChat evaluates administrator-configured supportedMimeTypes patterns on the server using an RE2-compatible, linear-time regular expression engine. The RE2 engine deliberately rejects complex regex constructs such as backreferences and lookaround assertions. If you introduce unsupported syntax into supportedMimeTypes, configuration validation rejects the setting on startup, causing file handling to fall back to restricted defaults.

Raising serverFileSizeLimit to 100 MB or 500 MB solves the immediate problem of rejected attachments, but it creates a serious infrastructure problem: local server storage bloat. Most competitor guides explain how to increase server-side YAML limits, but they offer no viable solution for teams that need access to multi-gigabyte document corpora without filling local disk volumes.

Every time a user attaches a document to a chat session, LibreChat stores a copy on local disk or inside MongoDB GridFS. Across twenty team members asking questions about product specifications, architectural diagrams, contracts, and financial spreadsheets, the local server quickly accumulates dozens of duplicate copies. In Docker deployments, this unmanaged accumulation fills container volumes, degrades disk I/O performance, and complicates system backups.

Beyond disk consumption, processing massive attachments locally strains host resources:

• CPU and Memory Contention: Parsing an 80-page scanned PDF or a massive spreadsheet workbook triggers heavy JavaScript memory allocation and high CPU load during text extraction.
• Context Dilution: Injecting tens of thousands of tokens of extracted text directly into model context windows crowds out conversation memory, drives up inference costs, and increases the risk of model hallucinations.
• Static File Stranding: Files uploaded to a single conversation remain trapped in that thread. Another team member asking an identical question must upload the same file again.

Self-hosters often evaluate raw object storage alternatives like AWS S3 or MinIO. While object stores handle raw binary bytes efficiently, they provide no built-in intelligence layer. S3 does not extract text, index embeddings, or expose query tools to conversational models without maintaining external indexing pipelines, vector databases, and retrieval logic.

The architectural alternative is to decouple storage and retrieval from the chat container entirely. Instead of uploading static reference files into chat prompts, teams connect LibreChat to an external workspace platform like Fastio.

Fastio provides shared, organization-owned intelligent workspaces designed for human and agent collaboration. When documents land in a Fastio workspace, Intelligence Mode auto-indexes them for hybrid retrieval, combining semantic meaning, exact full-text matching, and metadata filtering. Teams can also create Metadata Views, turning document repositories into structured, queryable tables with typed fields like contract dates, counterparties, and financial figures without manual OCR rules.

Fastio pricing scales transparently across tiers:

Monthly plans start with a 14-day free trial, which requires a credit card. Usage beyond plan allowances is billed transparently, with credits metering AI work only. Storage beyond the plan is $0.015 per GB a month and extra bandwidth $0.04 per GB, billed in money. Explore full details on the Fast.io pricing page. Maximum upload sizes accommodate massive reference corpora that would overwhelm local chat hosts.

Search multi-gigabyte document archives in LibreChat

Connect LibreChat to a shared Fast.io workspace over Streamable HTTP to query company documents with hybrid semantic search instead of bloating local attachments. Monthly plans start with a 14-day free trial that requires a credit card.

Start 14-Day Trial

Rather than forcing multi-gigabyte document collections through local chat attachments, LibreChat can connect directly to Fastio workspaces using the Model Context Protocol (MCP). LibreChat provides native support for remote MCP servers over Streamable HTTP, allowing language models to query live workspace files on demand.

Configuring the Remote MCP Server in LibreChat

To connect LibreChat to Fastio, declare the Fastio MCP endpoint inside the mcpServers block in librechat.yaml. Because LibreChat connects as a general MCP client, point the configuration to the tools endpoint at https://mcp.fast.io/mcp/tools using the streamable-http transport.

Add the following block to your librechat.yaml:

mcpServers:
  fastio:
    type: streamable-http
    url: "https://mcp.fast.io/mcp/tools"
    headers:
      Authorization: "Bearer ${FASTIO_API_KEY}"
    serverInstructions: "Query Fast.io workspaces for indexed documents, files, and workspace context."

Store your API key in your deployment .env file:

FASTIO_API_KEY=your_fastio_scoped_api_key_here

After updating librechat.yaml and .env, restart your LibreChat instance. The server establishes an outbound connection over Streamable HTTP, exposing Fastio storage and search actions directly to your connected models. Complete setup instructions, auth flows, and tool descriptions are documented in the Fast.io MCP setup guide and on Fast.io storage for agents.

The Remote Search Retrieval Flow

Connecting via MCP changes how LibreChat handles document references:

1. Clean Prompts: The user types a question into LibreChat: "What are our indemnification liabilities across our active vendor agreements?"
2. Selective Tool Execution: Instead of ingesting 200 pages of agreements into the conversation context, the model invokes the Fastio search action over MCP.
3. Hybrid Search Retrieval: Fastio's Intelligence engine searches the indexed workspace files using semantic meaning and full-text keyword matching, returning only the specific relevant clauses and document citations.
4. Context Conservation: The prompt context receives precise, targeted excerpts consuming a few hundred tokens rather than tens of thousands, preserving conversational memory and lowering inference latency.

Keeping Reference Data in Sync

Fastio supports scheduled and on-demand Cloud Sync for Google Drive, Dropbox, Box, and OneDrive. Organizations with existing document repositories can connect external folders directly to a Fastio workspace. SharePoint document libraries connect through the OneDrive connector.

When a team member updates a technical manual in Google Drive or adds a discovery brief to Dropbox, Cloud Sync updates the Fastio workspace. Intelligence Mode automatically re-indexes the modified files. When a user asks a question in LibreChat moments later, the model searches against the updated workspace data without anyone manually downloading and re-uploading attachments.

Workspace governance remains fully traceable. Fastio maintains full per-file version history, so teams can review prior revisions. Advisory per-file leases signal active editing across collaborators without blocking writes, and version history preserves each revision when concurrent updates land. A detailed activity log records uploads, edits, moves, deletions, and permission changes across the organization.