Summary: Open WebUI is a free, self-hosted chat interface that lets a small team share one private "ChatGPT" connected to local models (through Ollama) or to the paid APIs you already use. This playbook walks through a realistic rollout for a team of up to about 50 people: install it with Docker, lock down sign-ups, connect a model, load your documents into a knowledge base, build a team assistant, and keep everything backed up. Every step and number below was checked against Open WebUI's official documentation on 2026-10-27.
The use case: one private AI workspace your team actually controls
Many small teams end up in the same spot: half the office pastes work into personal chatbot accounts, nobody knows which documents left the building, and there is no shared place to keep good prompts. Open WebUI solves the "one shared place" part. You run it on a machine you control, everyone signs in with their own account, and you decide which models and documents each group can see.
It is worth being precise about privacy, because the docs are. Open WebUI keeps chats, users and uploaded files in its own storage on your server, but where document content is processed depends on the extraction, embedding and model providers you connect. If you point it at a cloud API, your prompts still go to that provider. If you pair it with a local model through Ollama, they can stay on your hardware.
This guide assumes a team of 50 or fewer. That number matters for licensing, which is covered in the comparison section below.
Step 1: Install it with Docker (about 10 minutes)
Docker is the officially recommended route and works on macOS, Linux (including ARM boards) and Windows. Pick a machine that stays on, such as a small office server or a cloud VM, then:
- Generate a secret key with
openssl rand -hex 32. Keep it somewhere safe. The docs warn that without a fixedWEBUI_SECRET_KEY, every time the container is recreated everyone gets logged out. - Run the container:
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data -e WEBUI_SECRET_KEY=your-secret-key --name open-webui --restart always ghcr.io/open-webui/open-webui:main - Open
http://your-server:3000in a browser. The-v open-webui:...part is the volume that holds all chats, users and settings, so never drop it.
Which image should you pick?
The default :main image includes local embedding and speech-to-text models, which is what you want if your team will chat with documents and you don't already run separate services for that. The :slim image is roughly 197 MB to download instead of 1.62 GB (the docs' figure for Linux/amd64, checked October 16, 2026), but it hands embeddings, PDF and Office extraction, and voice off to external services. If you choose slim and skip that setup, uploading a PDF returns an error. For a first team rollout, :main is the simpler choice. There is also :cuda for NVIDIA GPUs (add --gpus all) and :ollama, which bundles Ollama in the same container.
If you prefer Python, Open WebUI supports Python 3.11 and 3.12 only (3.13 is not supported yet); install with pip install open-webui and start with open-webui serve, which listens on port 8080.
Step 2: Claim the admin account and close the front door
This is the step people skip and regret. The very first account created on a fresh install automatically becomes the Admin. So create your own account immediately after the container starts, before you share the URL with anyone.
Then decide what happens when a colleague signs up. New sign-ups get the default user role, which you control with the DEFAULT_USER_ROLE environment variable:
pending: the account exists but cannot do anything until an admin approves it. The docs recommend this for shared instances.user: immediate access with default permissions.admin: every new person becomes a full administrator. Avoid this.
Add -e DEFAULT_USER_ROLE=pending to your docker command, then approve people from Admin Panel > Users. Remember that admins bypass most granular permissions, so keep the admin list short.
Step 3: Connect a model
Option A: local models through Ollama
If Ollama runs on the same machine, Open WebUI tries to connect automatically. If it doesn't, go to Settings > Admin > Connections, find Manage Ollama API Connections, and set the URL. For Docker users with Ollama on the host, the docs give http://host.docker.internal:11434, which is exactly why the install command includes the --add-host flag. The Manage button in that same section lets you download models straight from the admin UI. If Ollama itself misbehaves, our Ollama troubleshooting guide covers the usual causes.
Option B: a cloud API
Open WebUI also connects to OpenAI, Anthropic and any OpenAI-compatible endpoint. This gives your team stronger models without each person needing a subscription, but you pay per use and data goes to that provider. Many teams mix both: a local model for sensitive documents, a cloud model for heavy writing or coding.
If you've been running models on a single desktop with LM Studio, that is a good way to test which local model is good enough before you put it in front of the whole team.
Step 4: Turn your documents into a knowledge base
This is where Open WebUI becomes more useful than a plain chatbot. The official first-run flow:
- Click Workspace > Knowledge, then Create, and give it a name and description (for example "Employee handbook").
- Upload a small text-based PDF or text file first and wait for processing to finish before asking about it.
- In a chat, type
#to reference the knowledge base, or attach it to a model in Workspace > Models > Edit. - Ask a question whose answer you know is in the file, and ask for a quote. Compare the answer with the source before trusting it for real work.
Two practical details from the docs: focused retrieval works best with a model that supports native function calling, with the Knowledge Base tools enabled, and you can control who sees each knowledge base from its three-dot menu, under Access. Start with one small, clean collection rather than dumping a whole shared drive in on day one.
Step 5: Build team assistants with Workspace > Models
A "model" in Open WebUI's workspace is really a preset on top of a base model: you bind a system prompt, knowledge bases, tools and parameter overrides to it, then share it. Practical examples for a small business:
- Policy helper: base model plus the handbook knowledge base, with a system prompt that says to answer only from the documents and quote the passage.
- Proposal drafter: a stronger cloud model with your proposal template and tone guide in the system prompt.
- Meeting summarizer: a fixed output format (decisions, owners, deadlines) so every summary looks the same.
System prompts can include variables such as {{USER_NAME}} and {{CURRENT_DATE}}, written without spaces inside the braces. The docs are honest that a system prompt is an instruction, not a guarantee: how closely it is followed depends on the base model.
Step 6: Use groups so the right people see the right things
Groups live in Admin Panel > Users > Groups and do two jobs: granting feature permissions and controlling access to private models, knowledge bases and tools. One rule to know before you design them: permissions are additive. If someone is in two groups and only one allows image generation, they get image generation. There is no "deny." The docs suggest keeping permission groups (who can use which features) separate from sharing groups (Sales, Engineering), which keeps things readable as the team grows.
Step 7: Back up before every update
All data lives in the open-webui volume. The official backup one-liner archives it to the current folder:
docker run --rm -v open-webui:/data -v $(pwd):/backup alpine tar czf /backup/openwebui-$(date +%Y%m%d).tar.gz /data
Updating means pulling a newer image and recreating the container, and your data stays in the volume. The catch: if a release runs a database migration, rolling the container back does not undo it, so you need a backup taken before the update. The docs recommend backing up before every update and on a daily or weekly schedule.
Open WebUI vs AnythingLLM vs LibreChat
All three are self-hosted, multi-user AI chat apps. The facts below come from each project's own README, license and pricing pages, checked on 2026-10-27.
| Open WebUI | AnythingLLM | LibreChat | |
|---|---|---|---|
| Self-hosting cost | Free | Free (Docker) | Free |
| License | Open WebUI License (BSD-3 plus a branding clause since v0.6.6) | MIT | MIT |
| Rebranding | Allowed with 50 or fewer users in a 30-day period; above that, branding must stay unless you have permission or an enterprise license | White-labeling in the Docker version | MIT, no branding clause |
| Hosted option | Self-hosted (enterprise licensing available) | Cloud Basic $50/month, Pro $99/month, Enterprise by quote | Self-hosted |
| Strength | Knowledge bases, model presets, groups and permissions, SSO/LDAP, SCIM | Desktop app for Mac, Windows and Linux; workspaces; agents; multi-user only in Docker | Multi-provider chat, agents with MCP, admin panel for users, groups and roles; OAuth2 and LDAP login |
In short: choose Open WebUI if documents and fine-grained team access are the point; AnythingLLM if you want a no-server desktop app or a hosted plan someone else maintains; LibreChat if you mainly want one clean interface for many paid model providers with an MIT license.
Editor's note
Who this is for: small teams, clinics, agencies or workshops with someone comfortable running a Docker container, who want one controlled place for AI chat and internal documents. Not for: a solo user who just wants a chatbot (a desktop app is simpler), or anyone who needs a vendor to own uptime and support without an enterprise contract.
Gotchas I verified in the docs: the first account becomes admin, so create yours before sharing the link; forgetting WEBUI_SECRET_KEY logs everyone out after each container rebuild; the slim image returns errors on PDF uploads unless you connect an extraction service; and group permissions only add, never subtract.
Common errors and fixes: "can't reach Ollama" from inside Docker is usually a localhost problem, so use http://host.docker.internal:11434; a knowledge base that seems ignored often means the model doesn't support tool calling well, so test with a stronger model before rewriting prompts; and a rollback that won't start after an update usually needs the pre-update backup because of a database migration.
FAQ
Is Open WebUI really free for a business?
Yes, self-hosting is free. The license asks you to keep the Open WebUI branding visible, unless you have 50 or fewer users in a 30-day period, are a substantive contributor with written permission, or hold an enterprise license.
Does my data stay private?
Chats, users and files are stored on your server. Prompts and document content go wherever your connected providers are: a cloud API sees what you send it, while a local Ollama model keeps processing on your hardware.
Can I automate things around it, like sending chat results to other apps?
Open WebUI has tools, MCP support and webhooks, and many teams pair it with an automation tool. If you go that route with n8n and local models, our n8n AI Agent errors guide covers the connection problems you're likely to hit.
Start with one clean knowledge base, one shared assistant and approval-only sign-ups, and you'll have a private team AI that's easy to grow.
Official Open WebUI documentation screenshots are attached at the end of this post. Image credit: Open WebUI Docs (docs.openwebui.com).
Last verified: 2026-10-27
Sources:
Open WebUI Docs: Quick Start
Open WebUI Docs: Roles
Open WebUI Docs: Groups
Open WebUI Docs: Starting with Ollama
Open WebUI Docs: Knowledge
Open WebUI Docs: Models
Open WebUI Docs: Updating and Backup
Open WebUI License
AnythingLLM on GitHub
AnythingLLM Pricing
LibreChat on GitHub
댓글
댓글 쓰기