What is LibreChat? Features, setup and Open WebUI comparison

Andreas Nigg
Andreas Nigg · Co-Founder, Pondhouse Data
Published Updated 13 min read
What is LibreChat? Features, setup and Open WebUI comparison
On this page

LibreChat is a free, open-source chat platform that you run on your own server. It looks much like ChatGPT, but you choose the models (OpenAI, Anthropic, Google, Azure OpenAI, AWS Bedrock or any OpenAI-compatible endpoint, including local models), and chats, files and users stay in your own database. In 2026 it is much more than a chat window: agents with tools, MCP servers, file search over your documents, artifacts, web search, memory and an admin panel with roles.

We installed the current release, v0.8.8 (October 2026), with the official Docker Compose setup and tested it with OpenAI's gpt-5.4-mini: registration and login, a plain chat, an agent that calls an MCP server, an agent that answers from an uploaded PDF, a React artifact, web search and memory. All of these worked. The effort goes into the configuration around them.

What is LibreChat?

LibreChat started in 2023 as an open-source clone of the ChatGPT interface. Today it is a multi-user AI workspace: every employee gets a login, picks a model or an agent, and works with the same features they know from ChatGPT or Claude. The code is under the MIT license and has about 46,800 stars on GitHub (November 2026). In 2025 the project was acquired by ClickHouse, which uses LibreChat internally for agentic data analysis. Releases and release candidates have come out every few weeks since.

LibreChat itself does not run any language model. It sends requests to the providers you configure, so it needs no GPU. It fits these situations well:

  • Companies that want ChatGPT-style chat for their staff but with their own API keys, their own data storage and their choice of models.
  • Teams that use several providers and want one interface, with agents and tools that work across them.
  • Organizations that need single sign-on, roles and an audit trail, which hosted consumer chat apps do not give them.

If you only want a private chat with local models on your laptop, LibreChat is more than you need. Open WebUI is simpler for that; see the comparison further down.

The LibreChat chat view with gpt-5.4-mini answering a question about AI usage rules for staff

How LibreChat works

The default Docker Compose file starts six services. The LibreChat API (Node.js) serves the web interface, handles logins and talks to the model providers. MongoDB stores users, chats, agents and memories. Meilisearch makes your chat history searchable. The RAG API, a small Python service, splits uploaded files into chunks, embeds them and stores the vectors in PostgreSQL with pgvector. The admin panel is a separate web app for roles, groups and configuration.

Architecture of the default LibreChat Docker Compose stack: the LibreChat API with MongoDB, Meilisearch, RAG API, pgvector and the admin panel, plus external model providers, MCP servers, web search, code interpreter and embedding model

Everything else is external: the language models, MCP servers that give agents tools, a search provider for web search, an embedding model for file search and, optionally, a code interpreter service.

Configuration lives in two files. .env holds secrets, API keys and switches (the example file has 1,456 lines). librechat.yaml describes features: custom endpoints, MCP servers, web search, memory, interface options. Since v0.8.5 the admin panel can also edit most of this in the browser.

How to install LibreChat with Docker Compose

You need Git and Docker. According to the Docker installation guide, LibreChat's containers need at least 1 GiB of RAM and 1 vCPU, and 2 GB of memory for Docker is recommended when everything runs. In our test the six containers used about 1.4 GB of RAM after a round of chats, and the images took about 10 GB of disk (the LibreChat image alone is 4.2 GB).

The official steps, quoted from the docs:

1git clone https://github.com/LibreChat-AI/LibreChat.git
2cd LibreChat
3cp .env.example .env
4docker compose up -d

To get exactly the version we tested, check out the release tag with --branch v0.8.8.

Set your keys and secrets in .env

Before anyone else uses the instance, set real secrets. These are the values we changed in .env (generate the random ones with openssl rand -hex 32, and openssl rand -hex 16 for CREDS_IV):

1OPENAI_API_KEY=sk-...
2OPENAI_MODELS=gpt-5.4-mini,gpt-5-mini,gpt-4.1-mini
3CREDS_KEY=<64 hex characters>
4CREDS_IV=<32 hex characters>
5JWT_SECRET=<random>
6JWT_REFRESH_SECRET=<random>
7MEILI_MASTER_KEY=<random>
8ADMIN_PANEL_SESSION_SECRET=<random>

With OPENAI_API_KEY set, all users share your key. If you set it to user_provided instead, every user enters their own key in the interface. OPENAI_MODELS limits the model list to the models you want to pay for.

Mount librechat.yaml and pin the version

librechat.yaml is only read if you mount it into the container. The docs do this with a docker-compose.override.yml, so the official compose file stays untouched for updates. Ours also pins the images to release tags:

1services:
2 api:
3 image: registry.librechat.ai/librechat-ai/librechat:v0.8.8
4 volumes:
5 - type: bind
6 source: ./librechat.yaml
7 target: /app/librechat.yaml
8 rag_api:
9 image: registry.librechat.ai/librechat-ai/librechat-rag-api-dev-lite:v0.9.0

Pinning matters: the default docker-compose.yml uses librechat-dev:latest, which is built from the main branch, not from a release. The numbered release images are called librechat and are tagged per version.

This is the librechat.yaml we used. It turns on memory, adds web search through Keenable (which works without an API key) and connects the public Microsoft Learn MCP server:

1version: 1.3.17
2cache: true
3
4interface:
5 customWelcome: "Welcome to LibreChat!"
6 agents:
7 use: true
8 create: true
9
10memory:
11 tokenLimit: 2000
12 personalize: true
13
14webSearch:
15 searchProvider: keenable
16 scraperProvider: keenable
17 rerankerType: none
18
19mcpServers:
20 microsoft-learn:
21 type: streamable-http
22 url: https://learn.microsoft.com/api/mcp

After changing either file, restart the stack (from the docs):

1docker compose down && docker compose up -d

Create the first account

Open http://localhost:3080 and click Sign up. There are no default credentials. In a single-tenant installation, the first account you register gets the ADMIN role, so create it yourself before you share the URL. After that, decide whether people may register on their own (ALLOW_REGISTRATION) or should sign in through your identity provider.

LibreChat supports email and password with optional email verification, OAuth2 and OpenID Connect (for example Microsoft Entra ID, Keycloak or Authentik), SAML, LDAP and passkeys, and you can require two-factor authentication for local accounts. The details are in the authentication docs.

Connect OpenAI and other model providers

With the .env above, OpenAI shows up in the model menu with the three models from OPENAI_MODELS. Google, Anthropic and Assistants also appear, with a gear icon: .env.example sets their keys to user_provided, so each user could enter a personal key. If you don't want that, set a real key or comment the line out. The Assistants endpoint in particular is obsolete, because OpenAI shut down the Assistants API on August 26, 2026; use agents instead.

The LibreChat model menu with OpenAI, My Agents, Assistants, Google and Anthropic

Native integrations exist for OpenAI, Azure OpenAI, Anthropic, Google and AWS Bedrock. Everything else, from OpenRouter to a local Ollama or vLLM server, connects as a custom endpoint in librechat.yaml, because all of them speak the OpenAI API. If you run your own model server, our guide to hosting your own LLM with HTTPS covers the server side.

LibreChat features we tested

Agents and the Agent Builder

Agents are the center of LibreChat today. An agent bundles a model, instructions and tools; you build it in the side panel and then pick it from the model menu like any model. Agents can be shared with other users or groups.

The LibreChat Agent Builder with name, model gpt-5.4-mini, instructions and the microsoft-learn MCP server as a tool

Add under Tools opens the tool library. Native tools are Run Code, Web Search, Artifacts, File Search, Ask User and Memory. Below them are your MCP servers and twelve built-in tools such as DALL-E 3, OpenAI Image Tools, Wolfram, Tavily, Azure AI Search and a calculator. This is also the answer to the old question about "LibreChat plugins": the plugin store from earlier versions is gone, and tools, MCP servers and actions (OpenAPI) took its place.

The LibreChat Tool Library with native tools, the microsoft-learn MCP server and built-in tools

MCP servers

MCP (Model Context Protocol) servers give agents access to external tools. You define them in librechat.yaml (as above) or, with the right permissions, in the interface under MCP Settings. LibreChat supports stdio servers that it starts itself and remote servers over streamable HTTP, including OAuth.

On startup LibreChat connected to the Microsoft Learn server and found its three tools (microsoft_docs_search, microsoft_code_sample_search, microsoft_docs_fetch). We built a "Microsoft Docs Helper" agent with gpt-5.4-mini and asked how to add a SharePoint list as a knowledge source in Copilot Studio. The agent ran two searches (0.6 and 0.7 seconds) and answered with steps, limits and links to the pages it used. Our own walkthrough of SharePoint lists in Copilot Studio has the details.

An agent answer in LibreChat with two expanded microsoft_docs_search tool calls, steps, limits and source links

If the tool you need has no MCP server yet, you can write one; see our guide to building an MCP server with FastMCP.

File upload and RAG

LibreChat has two ways to work with files, and the difference matters.

In a normal chat, the paperclip attaches a file to the message. In v0.8.8 LibreChat routes attachments automatically; our PDF went to the model as a document, without passing through the vector index, even with File Search switched on. For a short document that works well, because the model reads all of it.

For a knowledge base that a team uses, build an agent with File Search and upload the files in the Agent Builder. LibreChat sends them to the RAG API, which splits and embeds them (default: OpenAI text-embedding-3-small) and stores the vectors in pgvector. Everyone who chats with the agent can then search those files. Our two-page test PDF, a sample travel expense policy, was indexed in 2.5 seconds.

The File Search dialog of a LibreChat agent with an uploaded PDF

We asked the agent what an employee can claim for a 620 km trip with a colleague and two hotel nights. It searched the files and answered with the correct rates, the right sums and the section of the policy each rule came from.

A LibreChat agent answering a travel expense question from the uploaded policy, with the "Searched your files" step

According to the file search docs, LibreChat retrieves the 5 closest chunks per file and passes the 10 best to the model. That is fine for policies, manuals and a few dozen documents. It is not a document management system: there is no sync with SharePoint or a file share, and no per-document permissions beyond who can use the agent. For larger collections with complex layouts, a dedicated RAG engine such as RAGFlow is the better tool.

Artifacts

With the Artifacts tool, an agent can return React components, HTML pages, SVG, Markdown documents or Mermaid diagrams that render in a panel next to the chat. We asked an agent for a travel expense calculator with the rules from the policy. gpt-5.4-mini built a working React component; with 620 km, one passenger, two nights and a hotel price of 155 euros it arrived at 1,086 euros, which is what the policy's rates give (the hotel capped at 140 euros a night).

A React travel expense calculator artifact rendered in the LibreChat side panel

The preview runs in a sandboxed iframe that loads CodeSandbox's Sandpack bundler from codesandbox.io. If your network blocks that domain or you don't want the dependency, the docs describe how to self-host the bundler.

Web search needs a search provider and a scraper; a reranker (Jina or Cohere) is optional. Keenable works without a key, which makes it the fastest way to try it. With Web Search enabled in the composer, the model searched twice and answered our question about the latest LibreChat release correctly, with citations.

A LibreChat answer with "Searched the web, 2 searches" and inline source citations

For production, the web search docs describe the other providers: Serper, SearXNG or Tavily for search, Firecrawl or the providers' own scrapers for reading pages.

Memory

Memory stores a few facts about each user and adds them to every new conversation. It is off until you add a memory block to librechat.yaml. We asked the model to remember that we want answers in German with a short summary first; it saved one entry (25 tokens). A new chat with an English question then got a German answer that started with "Kurz gesagt". Users can see, edit and delete their entries in the Memories panel, and admins can let them turn memory off.

The LibreChat Memories panel with one saved entry and a German answer that follows the stored preference

Code interpreter

Agents can also run code, but this needs a separate service. LibreChat uses ClickHouse/code-interpreter (Apache 2.0), which runs Python, JavaScript, Go, Java, Rust and more in a sandbox. It is not part of the default compose file, and we did not test it. The setup is in the code interpreter docs.

Prompts, presets and other chat features

The side rail also has Prompts (reusable templates with variables that users fill in), Bookmarks and Parameters, and the top bar has Presets for saved model settings. Conversation forking, message editing, voice input, sharing chats by link and a temporary chat mode are all there.

Users, roles and the admin panel

The missing role management was the biggest drawback in our 2024 review. That is solved. The admin panel runs as its own container on port 3000 and needs an account with the ADMIN role. It has roles (ADMIN and USER by default, plus your own), groups, grants that control which capabilities each role has, an audit log, and a configuration editor that covers providers, custom endpoints, model specs, MCP servers and features without editing YAML.

The LibreChat admin panel with the configuration editor for AI providers

LibreChat vs Open WebUI

Both are open-source, self-hosted chat interfaces, and both now have agents, MCP, RAG and role-based access. The differences are in architecture, extensibility and license. The LibreChat column is from our test of v0.8.8, the Open WebUI column from our Open WebUI guide, where we tested v0.13.0 (November 2026), and the Open WebUI docs.

AspectLibreChat 0.8.8Open WebUI 0.13.0
LicenseMIT (admin panel AGPL-3.0)Open WebUI License: BSD-3 with a branding clause above 50 users
Default setupSix containers incl. MongoDB, Meilisearch, pgvectorOne container with SQLite and ChromaDB
Model providersNative OpenAI, Azure, Anthropic, Google, Bedrock; others as custom endpointsOllama, OpenAI, Anthropic, any OpenAI-compatible API
Local modelsVia custom endpoint (Ollama, vLLM)Ollama integration built in
Agents and MCPAgent Builder; MCP via YAML or UICustom models with tools; MCP since v0.6.31 (Streamable HTTP, added by admins)
ArtifactsReact, HTML, SVG, Markdown, MermaidHTML, SVG, JS visualizations; no React
ExtendingMCP, OpenAPI actions, Agents APIPython tools, functions, pipelines, MCP, OpenAPI
Code executionSeparate code interpreter servicePyodide in the browser, Jupyter, Open Terminal
Configuration.env, librechat.yaml, admin panelMostly in the admin UI
GitHub stars (Nov 2026)about 46,800about 157,900

Our take: Open WebUI is quicker to start and better if you mainly run local models through Ollama or want to extend the chat with your own Python code (see integrating n8n with Open WebUI for an example). LibreChat fits better when you want an interface that feels like ChatGPT for many users, several commercial providers side by side, agents with React artifacts, and a permissive MIT license that lets you rebrand without restrictions.

Limits and pitfalls

Configuration is spread out

Secrets and switches live in .env, features in librechat.yaml, more settings in the admin panel, and the admin panel can override YAML values per role or group. Plan who changes what, and keep both files in version control (without the secrets).

The default image is a development build

As mentioned above, docker-compose.yml pulls librechat-dev:latest. Pin librechat:<version> in your override file and update deliberately; the changelog for v0.8.8 alone lists more than 100 changes since the last release candidate.

Resources

LibreChat runs fine on a small VM, but the stack is not tiny: about 1.4 GB RAM and 10 GB of images in our test, plus a separate code interpreter service if you want code execution.

Default exposure

MongoDB runs without authentication (--noauth) in the default compose file. That is fine as long as only the LibreChat containers can reach it; never publish its port. Put LibreChat behind a reverse proxy with HTTPS before you invite users.

Login rate limit

By default LibreChat accepts 7 logins per IP address in 5 minutes (LOGIN_MAX and LOGIN_WINDOW), successful ones included, and answers further attempts with HTTP 429. Raise the limit if many users sign in from behind one NAT address, and set TRUST_PROXY correctly behind a reverse proxy so LibreChat sees the real client IPs.

Licensing

LibreChat, the RAG API and the code interpreter are under permissive licenses (MIT, MIT, Apache 2.0). The admin panel is AGPL-3.0, which matters if you modify it and offer it to others over a network. Your model provider's terms still apply to everything users type.

Our assessment

LibreChat v0.8.8 covers what most teams use a hosted ChatGPT plan for, on your own infrastructure and with the models you choose. Once configured, every feature we tried did its job: the MCP agent found current documentation, the file search agent answered with correct numbers from a policy PDF, and the artifact calculated correctly. The interface is familiar enough that users need no training. What takes time is the setup around it: secrets, SSO, a reverse proxy, pinned versions, decisions on which providers and tools each role may use, and a plan for updates.

If you are evaluating a self-hosted chat platform for your company, start with a pilot like the one above: one provider, two or three agents for real tasks, a handful of users. We help companies in Austria, Germany and Switzerland plan and run self-hosted AI chat with agents, MCP and RAG; our AI consulting is a good place to start.

Interested in building high-quality AI agent systems?

We prepared a comprehensive guide based on cutting-edge research for how to build robust, reliable AI agent systems that actually work in production. This guide covers:

  • Understanding the 14 systematic failure modes in multi-agent systems
  • Evidence-based best practices for agent design
  • Structured communication protocols and verification mechanisms
Andreas Nigg

About the author

Andreas Nigg

Co-Founder, Pondhouse Data

Andreas has spent more than eight years building data applications. At Pondhouse Data he designs and ships AI systems and integrates them into complex, real-world environments.