DEV Community

Jovan Chan
Jovan Chan

Posted on • Originally published at aifoss.dev

LibreChat Review 2026: Open-Source Chat for Every Provider

#opensource #ai #selfhosted #linux

This article was originally published on aifoss.dev

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.5 Open WebUI Jan.ai
Best for Teams, multi-provider setups Ollama-first local chat Offline solo use
Install Docker Compose, ~15 min Single container, ~5 min GUI installer, ~3 min
Multi-provider All major APIs + OpenAI-compatible Primarily Ollama Ollama + OpenAI
Hardware needs 2GB RAM minimum (full stack) ~1GB RAM ~512MB RAM
The catch No single-binary; heavier stack Limited enterprise auth No 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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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"]
Enter fullscreen mode Exit fullscreen mode

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"]
Enter fullscreen mode Exit fullscreen mode

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:

Plugin What it does Requires
DALL-E 3 Text-to-image, rendered inline OpenAI API key
Stable Diffusion Local image generation SD server endpoint
Wolfram Alpha Math, computation, factual queries Free Wolfram API key
Google Search Web search with citations Google Custom Search API
Tavily Search Web search (simpler setup than Google) Tavily API key
Calculator Math without API calls Nothing
Azure AI Search Enterprise document search Azure subscription
Code Interpreter Execute code in sandbox OpenAI 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"
Enter fullscreen mode Exit fullscreen mode

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 introdu

Top comments (0)