Every team I work with asks the same question: how do we give everyone a ChatGPT-style interface without sending our data to a third party? The answer the open-source community converged on is Open WebUI — a self-hosted AI platform with more than 150,000 GitHub stars as of September 2026.
In this guide I show you exactly what Open WebUI is, how it works under the hood in 4 steps, and how to run it with Docker against Ollama or any OpenAI-compatible API.
1. What Open WebUI Is: Stars, License, Big Picture
Open WebUI (github.com/open-webui/open-webui) is a self-hosted, extensible, feature-rich AI chat platform created by Timothy Jaeryang Baek. It runs entirely offline, supports Ollama and any OpenAI-compatible API, and gives every user a polished multi-model chat UI with RAG, tools, and admin controls built in.
~151k stars
GitHub · Sep 2026
One of the most-starred AI repos on GitHub, with ~22k forks. I verified the count live on the repo page — it grows by thousands of stars every month.
Open WebUI License
BSD-3 + branding clause
Free to self-host at any scale. Since v0.6.6 (April 2025) it adds a branding-protection clause: keep the Open WebUI branding once you pass 50 users, or get an enterprise license.
Provider-agnostic
Ollama + OpenAI-compatible
Point it at local Ollama models, or at LM Studio, vLLM, OpenRouter, Mistral, GroqCloud — or mix local and cloud providers in the same UI.
Extensible core
Plugins, RAG, agents
Tools, Functions, Pipes, local RAG over 9 vector databases, web search, image generation, voice calls, and multi-model conversations out of the box.
The license catch you should know
GitHub classifies the license as NOASSERTION (not OSI-approved). Running it is free at any scale, including SSO, LDAP, and RBAC. The only restriction: do not strip the Open WebUI branding on deployments with more than 50 users in a rolling 30-day window without written permission or an enterprise license. Code up to v0.6.5 remains plain BSD-3.
2. Architecture in 4 Steps
Open WebUI looks like a simple chat app, but it is really a thin orchestration layer between your users and any model backend. Here is the request path in four steps.
Step 1 — Svelte frontend
Chat UI · PWA
The responsive SvelteKit UI handles chat, channels, notes, calendars, admin dashboards, and multi-model views. It talks to the backend over a documented REST + WebSocket API.
Step 2 — FastAPI backend
Auth · RBAC · pipelines
The Python backend owns users, groups, permissions, chat history, knowledge bases, and the plugin/filter pipeline. Every message passes through Functions and Filters before reaching a model.
Step 3 — Model router
Ollama · OpenAI-compatible
The backend forwards the assembled prompt to Ollama locally (default http://host.docker.internal:11434) or to any OpenAI-compatible base URL you configure — LM Studio, vLLM, OpenRouter, or OpenAI itself.
Step 4 — Data layer
SQLite/Postgres · S3 · vectors
Chats persist in SQLite (or Postgres), files go local/S3/GCS/Azure, and RAG embeddings land in one of 9 vector stores — ChromaDB, pgvector, Qdrant, Milvus, and more. Mount /app/backend/data or lose your DB on restart.
Why this design wins
Because inference and interface are decoupled, you can swap Llama for GPT, local for cloud, or Chroma for pgvector without retraining anyone. I treat Open WebUI as the frontend and Ollama as the engine — each upgrades independently.
3. Quickstart: Running It With Docker
The README-verified path is Docker with a mounted data volume. Pick the command that matches your setup — every snippet below comes straight from the official README, so flags like -p 3000:8080 and -v open-webui:/app/backend/data are exact.
Default: Ollama on the same machine
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main
With Nvidia GPU support
docker run -d -p 3000:8080 --gpus all --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:cuda
Bundled Ollama (single container, easiest)
docker run -d -p 3000:8080 --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama
OpenAI API only (no local models)
docker run -d -p 3000:8080 -e OPENAI_API_KEY=your_secret_key -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main
Ollama on another server
docker run -d -p 3000:8080 -e OLLAMA_BASE_URL=https://example.com -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main
After install: open http://localhost:3000
Create the first admin account in the UI, then go to Admin Settings → Connections to point OLLAMA_BASE_URL at your Ollama host. Pull a model with ollama pull llama3.1 and it appears in the model picker. On Python 3.11 you can also pip install open-webui and run open-webui serve (serves on port 8080).
4. Use Cases That Justify It
I recommend Open WebUI whenever the interface must be owned even if the models are rented. These are the four deployments I see paying off fastest.
Private home lab
Ollama + :ollama image
One container on a home server with local models only. Fully offline-capable with HF_HUB_OFFLINE=1. Your chats never leave the house — ideal for journals, code drafts, and kids’ homework help.
Team AI gateway
RBAC + groups + SSO
One URL for the whole company: per-group model access, usage analytics, shared channels where humans and models collaborate. SSO and LDAP cost nothing extra — a real edge over rivals that gate them.
RAG over internal docs
Knowledge bases + hybrid search
Load PDFs, wikis, and tickets into knowledge bases with hybrid BM25 + vector search and reranking. Support and onboarding bots grounded in your own docs, queryable with the # command right in chat.
Agent workbench
Tools · MCP · automations
Wrap models with custom instructions, tools, and scheduled automations. Connect external services via MCP/MCPO tool servers, approve tool calls with v0.11’s approval flow, and run multi-model arena evaluations.
5. When NOT to Use It
Open WebUI is the best default I know for a self-hosted chat UI — but it is not always the right call. Be honest about these four situations before you commit.
- • You need to white-label for 50+ users without paying: the branding clause forbids stripping Open WebUI marks at that scale. Budget an enterprise license or pick an MIT-licensed alternative.
- • You want a RAG framework, not a chat app: for programmatic pipelines, LangChain, LlamaIndex, or OpenRAG give you code-level control Open WebUI intentionally hides.
- • You expect multi-GPU inference serving: Open WebUI is a frontend — it does not serve weights. Pair it with vLLM, Ollama, or Ollama Cloud for serious throughput.
- • You need strict data-residency guarantees: self-hosting the UI changes nothing if you point it at a US cloud API. For air-gapped requirements, run local models only.
Golden rule
If your requirement is “ChatGPT experience, our infrastructure, our models, this week” — deploy Open WebUI. If your requirement is “custom AI product with our brand and our pipelines” — treat it as a prototype UI, then build on the backend APIs directly.
Conclusion
Open WebUI earned its 150k stars by solving the least glamorous problem in AI adoption: giving everyone a good interface on day one. I have deployed it for labs, teams, and RAG pilots, and the Docker path above gets you from zero to chatting in under ten minutes.
Start with the bundled :ollama image, keep the branding intact, and let the model router do the hard work. When you outgrow the UI, the backends and vector stores you chose will still be yours.
Cheat Sheet: Recap
Commands
- • Default Docker (port 3000→8080)
- • :cuda tag + --gpus all for Nvidia
- • :ollama tag for bundled setup
Concepts
- • Frontend → backend → router → data
- • Open WebUI License + 50-user rule
- • OLLAMA_BASE_URL for remote hosts
Next steps
- • Pull a model: ollama pull llama3.1
- • Add docs to a knowledge base
- • Try Tools + automations
