LibreChat Review 2026: Open-Source Chat for Every Provider

By AIFoss · 11 min read

TL;DR: LibreChat v0.8.5 is the only self-hosted chat interface that puts OpenAI, Anthropic, Google, Ollama, and a dozen more providers in one UI with real enterprise authentication. Setup is Docker Compose only — no single binary — and the full stack needs 2GB RAM. If you’re running a single local model and want simplicity, Open WebUI is the better fit. If you need multiple providers or team auth, nothing else comes close.

LibreChat v0.8.5Open WebUIJan.ai
Best forTeams, multi-provider setupsOllama-first local chatOffline solo use
InstallDocker Compose, ~15 minSingle container, ~5 minGUI installer, ~3 min
Multi-providerAll major APIs + OpenAI-compatiblePrimarily OllamaOllama + OpenAI
Hardware needs2GB RAM minimum (full stack)~1GB RAM~512MB RAM
The catchNo single-binary; heavier stackLimited enterprise authNo agents or plugins

Honest take: If you use more than one LLM provider or need LDAP/OAuth for team access, LibreChat is the only open-source option that handles it without workarounds.

What LibreChat actually is

LibreChat is a self-hosted chat frontend and orchestration layer. It does not run models itself — it connects to API endpoints you provide. What makes it different from every other self-hosted ChatGPT clone is the breadth of what it connects to: OpenAI, Anthropic, Google Vertex AI, AWS Bedrock, Azure OpenAI, Groq, Mistral, DeepSeek, OpenRouter, and any OpenAI-compatible endpoint including Ollama.

That last part is the key unlock. Most self-hosted UIs pick a lane: either Ollama-first (Open WebUI, Jan.ai) or cloud-API-first (Chatbot UI). LibreChat genuinely treats all providers as peers. You can have a conversation, switch from Claude Opus to a local Qwen model mid-thread, and LibreChat routes the request to the right endpoint without any friction.

As of v0.8.5 (April 2026), the feature set is substantial:

  • Multi-provider switching per conversation
  • Agent builder with MCP (Model Context Protocol) support
  • Built-in plugins: DALL-E 3, Wolfram Alpha, web search, code interpreter, calculator
  • RAG via pgvector: PDF/DOCX/TXT ingestion with a dedicated Python service
  • Authentication: email, OAuth2/OIDC, LDAP/AD, social logins
  • Artifacts: code blocks, markdown, and HTML previews rendered in the UI
  • Conversation branching and message search
  • Custom presets: saved model configs with system prompts

The project is MIT-licensed. Danny Avila started it as a personal ChatGPT clone in early 2023; as of May 2026 it has 34,500+ GitHub stars and over 23 million container registry pulls. That pull count signals production deployments, not just homelab curiosity.

Installing it: Docker Compose in 15 minutes

There is no single binary. The LibreChat stack involves MongoDB (conversation storage), MeiliSearch (message search), the main Node.js app, and an optional Python RAG service. Docker Compose packages all of this sensibly.

The install is four commands:

git clone https://github.com/danny-avila/LibreChat.git
cd LibreChat
cp .env.example .env
docker compose up -d

Access the UI at http://localhost:3080. The first account you register becomes the admin.

The initial docker compose up pulls images — expect 2–5 minutes on a fresh machine. Subsequent starts are under 30 seconds.

The .env file controls secrets and infrastructure settings. At minimum, set these before starting:

# Session encryption (generate random hex strings)
CREDS_KEY=         # 64 hex characters
CREDS_IV=          # 32 hex characters
JWT_SECRET=        # any long random string

# Registration policy
ALLOW_REGISTRATION=true
# Optional: lock registration to one domain
ALLOWED_DOMAINS=yourcompany.com

The librechat.yaml file controls everything else: which providers appear, which models are available, agent configs, and MCP server definitions. The separation is intentional — .env holds credentials and infra; the YAML handles features.

Hardware requirements: the official documentation recommends a minimum of 2GB RAM for a full deployment. Without the optional RAG API enabled, the core stack (LibreChat + MongoDB + MeiliSearch) runs lighter, but plan for 2GB on the host to avoid swap.

For a public-facing deployment, put nginx in front and add TLS. The Docker Compose stack exposes only port 3080 by default, so nothing is accidentally open.

Connecting providers: Ollama alongside cloud APIs

The multi-provider setup happens in librechat.yaml. Here’s what connecting both a local Ollama instance and OpenAI looks like:

endpoints:
  custom:
    - name: "Ollama"
      apiKey: "ollama"
      baseURL: "http://host.docker.internal:11434/v1"
      models:
        default: ["llama3.2:8b", "qwen2.5:14b"]
      titleModel: "llama3.2:8b"

  openAI:
    apiKey: "${OPENAI_API_KEY}"
    models:
      default: ["gpt-4o", "gpt-4o-mini"]

On Linux, host.docker.internal may not resolve without adding --add-host=host.docker.internal:host-gateway to your Docker Compose file. Use your host’s actual LAN IP if you hit connection issues.

After restarting the stack, both providers appear in the model selector dropdown. Switching models mid-conversation keeps the full conversation history — LibreChat sends the entire thread to the new provider on the next message.

The same pattern applies to Anthropic, Google Vertex AI, Groq, or any OpenAI-compatible API like vLLM:

  anthropic:
    apiKey: "${ANTHROPIC_API_KEY}"
    models:
      default: ["claude-opus-4-8", "claude-sonnet-4-6"]

The breadth here is genuinely unique among self-hosted options. Open WebUI supports multiple providers through its Pipeline system, but first-class multi-provider support is newer and requires more manual work.

The plugin toolkit

LibreChat’s plugins work through function-calling. When you enable a plugin, it adds a tool definition to the system prompt, and the model decides when to invoke it. This is the same mechanism as ChatGPT’s tool use.

Built-in plugins:

PluginWhat it doesRequires
DALL-E 3Text-to-image, rendered inlineOpenAI API key
Stable DiffusionLocal image generationSD server endpoint
Wolfram AlphaMath, computation, factual queriesFree Wolfram API key
Google SearchWeb search with citationsGoogle Custom Search API
Tavily SearchWeb search (simpler setup than Google)Tavily API key
CalculatorMath without API callsNothing
Azure AI SearchEnterprise document searchAzure subscription
Code InterpreterExecute code in sandboxOpenAI API key

Plugin activation is per-user — each account can enable the tools they want. Admin controls which plugins are available site-wide.

The honest limitation: this ecosystem is much smaller than the ChatGPT plugin store. There’s no “marketplace” of third-party LibreChat plugins. MCP integration (covered in the next section) is the intended path for adding custom tools beyond what ships out of the box.

Agents, MCP, and the Assistants API

The agent builder is one of LibreChat’s stronger differentiators. Each agent is a configurable AI assistant with its own system prompt, model selection, and tool access. You create them in the sidebar UI — no config file editing required.

What makes agents compelling is native MCP support. Add MCP servers to librechat.yaml:

mcpServers:
  filesystem:
    type: stdio
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/documents"]
  
  brave-search:
    type: sse
    url: "http://localhost:3001/sse"

Those tools appear in the agent builder, scoped per-user. One agent can get filesystem read access; another gets only web search. The deferred tool loading introduced in recent releases means MCP tools don’t consume context window space until actually called — a meaningful fix when you have many tools registered.

LibreChat also supports the OpenAI Assistants API. If your team has existing agents built against OpenAI’s API, LibreChat can act as the frontend without requiring changes to the agent logic. That’s a meaningful migration path for teams evaluating whether to move off OpenAI infrastructure while keeping existing tooling.

Authentication and multi-user support

LibreChat’s auth system is the most complete in the self-hosted chat space. Options:

Email/password: Works out of the box. No external dependencies.

OAuth2/OIDC: Supports Keycloak, Auth0, Authelia, Azure AD, AWS Cognito, Authentik, and any OIDC-compliant provider. Configuration is done through .env variables:

OPENID_CLIENT_ID=your-client-id
OPENID_CLIENT_SECRET=your-client-secret
OPENID_ISSUER=https://your-keycloak.example.com/realms/your-realm
OPENID_SCOPE=openid profile email
OPENID_CALLBACK_URL=/oauth/openid/callback

LDAP/Active Directory: Authenticates against your existing directory. Required variables:

LDAP_URL=ldap://your-dc:389
LDAP_USER_SEARCH_BASE=dc=yourcompany,dc=com

LibreChat maps LDAP attributes to user fields and handles session management. For teams already running Active Directory, this is the fastest path to deploying shared LibreChat access without building a separate user database.

Role-based access control: v0.8.5 introduced custom roles and groups via the admin panel. You can restrict which endpoints, models, or tools different user groups can access. This is still maturing — the admin panel is functional but not all RBAC scenarios are GUI-configurable yet.

All stored credentials are encrypted with AES-256-CBC. OAuth tokens and API keys are never stored in plaintext.

This is where LibreChat’s advantage over alternatives is most concrete. AnythingLLM supports multi-user mode but lacks LDAP and OIDC. Open WebUI’s enterprise auth is improving but LDAP support is partial.

Built-in RAG

The RAG service is a separate Python FastAPI container in the Docker Compose stack. It handles document ingestion, embedding generation, and retrieval using pgvector backed by PostgreSQL.

Upload a PDF in the chat interface and LibreChat chunks it, embeds it, and makes it searchable in that conversation or across a shared agent knowledge base. Supported types include PDF, DOCX, TXT, HTML, and CSV.

The default embedding provider is OpenAI’s text-embedding-3-small. You can swap in a local embedding model if you’re avoiding cloud dependencies entirely — the configuration goes in librechat.yaml under the embeddingProvider block.

For solo use or small teams with a few hundred documents, this covers the basics without needing a separate tool. Once you’re managing thousands of documents across multiple users with separate access permissions, you’ll want something purpose-built — AnythingLLM handles that scenario better, and it’s worth evaluating before committing to the LibreChat RAG pipeline at scale.

When NOT to use LibreChat

Single-provider personal use: If you only run Ollama and don’t need agents or LDAP, Open WebUI installs in one Docker command and has a better UX for model management, voice input, and image generation. LibreChat’s complexity isn’t justified for a single-user, single-provider setup.

Completely offline requirements: LibreChat can be configured to run fully local, but the install process assumes internet access (image pulls, npm packages). Jan.ai is built for air-gapped use.

Non-technical users: Docker Compose is developer-friendly. Anyone not comfortable with the terminal and editing YAML files will struggle to configure and maintain it.

Resource-constrained hardware: The full stack with RAG API needs 2GB RAM. On a shared VPS or low-spec machine, you’re fighting the allocator. The Open WebUI + Ollama Linux setup guide covers a lighter alternative.

Image generation workflows: LibreChat’s image generation is a plugin bolt-on via DALL-E or Stable Diffusion. If image gen is your primary workload, ComfyUI or Automatic1111 are better fits with dedicated workflow tooling.

The version to track: v0.8.6

As of this writing, v0.8.6-rc1 is in pre-release. The planned additions include Agent Skills, Subagents, and Code Execution within the agent framework. If those ship stable, LibreChat’s agent system moves from “configurable” to “genuinely powerful” for automated workflows. Worth watching the releases page before committing to a deployment plan.

Frequently Asked Questions

Does LibreChat work without any cloud API keys?
Yes. Configure it to point at a local Ollama instance and the core chat and agent features run entirely offline. The DALL-E 3, Wolfram Alpha, and Google Search plugins won’t work — those require cloud API keys — but everything else functions locally.

Can LibreChat connect to a vLLM or LocalAI server?
Any OpenAI-compatible API endpoint works. Set the baseURL to your vLLM or LocalAI server address in librechat.yaml, and it appears in the model selector alongside cloud providers.

Is LibreChat production-ready for a team?
It is running in production for many teams — 23M+ container pulls confirm that. LDAP, OIDC, and RBAC are all functional in v0.8.5. The admin panel is still maturing, so expect some configuration that still requires YAML editing rather than GUI clicks.

What’s the difference between LibreChat agents and plugins?
Plugins are tools attached to standard chat sessions. Agents are persistent, configurable AI assistants — each has its own system prompt, model selection, and tool access. Agents support MCP servers; standard plugin chat does not. If you want a specialized assistant that always uses web search and has file access, build an agent.

How does LibreChat handle model switching mid-conversation?
You switch the active model from the UI at any point. LibreChat preserves the full conversation history and sends it to the new model on the next message, recalculating the token count for the new model’s context window.

Sources

Was this article helpful?