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

The default LibreChat file upload limit restricts attachments to 25MB per file and 10 files per prompt across standard endpoints. While self-hosters can raise these boundaries in librechat.yaml and adjust reverse proxy buffers, local server storage quickly exhausts under large document collections. Connecting external workspaces via the Model Context Protocol allows LibreChat to query multi-gigabyte document corpora through semantic search without local attachment bottlenecks.

Source: https://fast.io/resources/librechat-file-upload-limit/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-11-05

## What Are the Default LibreChat File Upload Limits?

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](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/file_config):

* **`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:

| Platform or Endpoint | Single-File Limit | Batch File Limit | Controlling Condition | Verification Date | Primary Source |
| :--- | :--- | :--- | :--- | :--- | :--- |
| LibreChat Default (`endpoints.default`) | 25MB | 10 files | Standard chat routes (OpenAI, Anthropic, Ollama) | 2026-11-05 | LibreChat Documentation |
| LibreChat Assistants (`endpoints.assistants`) | 10MB | 5 files | OpenAI Assistants API and code interpreter | 2026-11-05 | LibreChat Documentation |
| LibreChat Agents (`endpoints.agents`) | 10MB | 10 files | Autonomous agent execution with tool actions | 2026-11-05 | LibreChat Documentation |
| Claude Web Chat | `500 MB` | 20 files | Anthropic direct conversational interface | 2026-09-14 | Anthropic Help Center |
| Claude Projects | 30MB | Unlimited count | Bounded strictly by model context window | 2026-09-14 | Anthropic Help Center |
| Fast.io Starter Workspace | 25GB | Unlimited count | Cloud workspace storage and remote MCP retrieval | 2026-11-05 | Fast.io Product Specifications |

## How Do You Increase File Size and Batch Limits in librechat.yaml?

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:

```yaml
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`:

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

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

```bash
docker compose restart api
```

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

```bash
docker compose down && docker compose up -d
```

## Why Do LibreChat File Uploads Fail Across Proxies and Rate Limits?

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:

```nginx
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:

```bash
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.

## How Do You Query Large Document Collections Without Server Storage Bloat?

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](/product/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](/product/document-data-extraction/), 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:

| Plan | Monthly Billing | Storage Included | Seats Included | Monthly Credits | Single File Upload Limit |
| :--- | :--- | :--- | :--- | :--- | :--- |
| Starter | $9.99/mo | 250 GB | 3 seats | 100,000 | 25 GB |
| Business | $49.99/mo | 5 TB | 10 seats | 600,000 | 50 GB |
| Enterprise | $199.99/mo | 25 TB | 30 seats | 3,000,000 | 100 GB |

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](/pricing/). Maximum upload sizes accommodate massive reference corpora that would overwhelm local chat hosts.

## How Do You Connect LibreChat to Fast.io Workspaces Over MCP?

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`:

```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:

```bash
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](https://mcp.fast.io/docs) and on [Fast.io storage for agents](/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.

## Frequently asked questions

### What is the default file upload limit in LibreChat?

The default LibreChat file upload limit is 25MB for individual files and 10 files per prompt turn on standard endpoints. Individual endpoints like assistants and agents define separate internal defaults, typically starting at `10 MB` per file.

### How do you increase file size limit in LibreChat?

To increase the file size limit, open `librechat.yaml` and define the `fileConfig` block. Adjust `serverFileSizeLimit` for the global server ceiling, and update `fileSizeLimit` and `totalSizeLimit` under `fileConfig.endpoints.default` or specific endpoint blocks like `agents`.

### Why does LibreChat show an upload failed error after raising limits in librechat.yaml?

Upload failures often occur upstream at the reverse proxy. Nginx enforces a default `client_max_body_size` of `1 MB`, which rejects larger uploads before LibreChat sees them. Configure `client_max_body_size 100M;` in your Nginx configuration and reload the proxy service.

### How can LibreChat search files stored in cloud workspaces?

LibreChat can connect to external Fast.io workspaces using the Model Context Protocol (MCP). By configuring a `streamable-http` connection to the Fast.io remote MCP server in `librechat.yaml`, models can search indexed workspace files on demand instead of uploading attachments. See the [Fast.io MCP setup guide](https://mcp.fast.io/docs) and [Fast.io storage for agents](/storage-for-agents/).

### What is the difference between fileSizeLimit and fileContextSizeLimit in LibreChat?

The `fileSizeLimit` setting controls the physical upload size of a file saved to the server. The `fileContextSizeLimit` setting is an aggregate per-turn safety ceiling (defaulting to `128 MB`) that restricts how many megabytes of attachment data enter the model prompt buffer.

### Does LibreChat support Cloud Sync with Google Drive, Dropbox, and OneDrive?

LibreChat itself does not natively synchronize external cloud storage folders. However, connecting LibreChat to a Fast.io workspace over MCP allows models to query repositories synchronized from Google Drive, Dropbox, Box, and OneDrive on a schedule or on demand.

## Sources

- [LibreChat Documentation: File Config Object Structure](https://www.librechat.ai/docs/configuration/librechat_yaml/object_structure/file_config): In LibreChat's server configuration schema, serverFileSizeLimit defines the global maximum size for any file uploaded to the server, establishing an overarching ceiling across all endpoints.
- [Claude Help Center: Upload files to Claude](https://support.claude.com/en/articles/8241126-upload-files-to-claude): Anthropic documents that Claude web chat accepts up to 20 files at up to 500MB each, while Claude Projects accepts files up to 30MB each with an unlimited file count bounded by the context window.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli. MCP setup is at https://mcp.fast.io/docs: Claude and most MCP clients connect to https://mcp.fast.io/mcp/tools, ChatGPT to https://mcp.fast.io/mcp/operations, and coding agents to https://mcp.fast.io/mcp/code.