How to Install Open WebUI Locally

Tool overview

Open WebUI is a browser interface for local and remote AI models. It is especially popular with Ollama users because it gives local models a polished chat UI, user accounts, document upload, knowledge bases, admin settings, and provider connections without requiring a custom app.

Use it when you want a ChatGPT-like interface for models running on your own machine or local network.

Step-by-step setup

ollama pull llama3.2
ollama list
curl http://localhost:11434/api/tags

Step 1: Install Open WebUI with Docker

Run:

docker run -d \
  -p 3000:8080 \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Open:

http://localhost:3000

The first account you create becomes the admin account. After that, manage users, groups, providers, models, and permissions from the admin area.

Step 2: Connect Open WebUI to Ollama

If Open WebUI and Ollama are in the same bundled container, the :ollama image handles that path for you.

If Ollama runs on the host and Open WebUI runs in Docker, the container needs a host-reachable URL. On Linux, the common Docker command is:

docker run -d \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

On Docker Desktop for Windows and macOS, host.docker.internal is normally available. If the UI does not show your models, go to the admin connection settings and set the Ollama URL to:

http://host.docker.internal:11434

If Open WebUI is installed directly with Python on the same host as Ollama, use:

http://localhost:11434

Step 3: Use the bundled Ollama image when you want the least networking pain

The all-in-one image is useful for simple local testing:

docker run -d \
  -p 3000:8080 \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:ollama

With Nvidia GPU support:

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

Use this if you want one container to manage both the UI and Ollama data. Use separate Ollama and Open WebUI installs if you already manage Ollama on the host or share it with other tools.

Step 4: Install Open WebUI with Python instead of Docker

Docker is the most common path, but Python works for manual setups:

python -m venv .venv
source .venv/bin/activate
pip install open-webui
open-webui serve

Open:

http://localhost:8080

On Windows PowerShell:

python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install open-webui
open-webui serve

If you want a specific data directory:

DATA_DIR=./data open-webui serve

On Windows:

$env:DATA_DIR=".\data"; open-webui serve

Step 5: Preserve chat history and uploads

For Docker, this flag preserves Open WebUI data:

-v open-webui:/app/backend/data

That data can include user accounts, settings, chat history, uploaded files, knowledge bases, and local database state.

Avoid this unless you intend to delete data:

docker volume rm open-webui

For Python installs, keep the configured DATA_DIR. If you do not set one, Open WebUI uses its default local data location for that install method.

Step 6: Upload documents and use local RAG

Open WebUI supports document workflows through chat file uploads and reusable knowledge bases.

For quick one-off use:

1. Open a chat.
2. Upload a file.
3. Ask questions about that file.

For reusable document collections:

1. Go to Workspace.
2. Open Knowledge.
3. Create a knowledge base.
4. Upload documents.
5. Attach or reference that knowledge base in chats or models.

RAG uses embeddings and retrieval. If document answers are poor, check the embedding model, file parsing, chunking behavior, and whether file upload permissions are enabled for the user or model.

Step 7: Manage users, roles, and permissions

Open WebUI has three main role states:

• Admin: full system control.
• User: normal access controlled by permissions.
• Pending: no access until approved.

The first account becomes admin. For multi-user local installs, set new users to pending by default and approve them manually.

Admins can manage groups and permissions for features such as file upload, model access, image generation, tools, and shared resources. Groups are additive: if one group grants a capability, the user gets that capability.

For a family, team, or small office setup, a good default is:

• One admin account.
• New registrations as pending.
• A normal user group with limited model and file permissions.
• Separate groups for trusted power users.

Updating Open WebUI

For Docker:

docker rm -f open-webui
docker pull ghcr.io/open-webui/open-webui:main
docker run -d \
  -p 3000:8080 \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Do not remove the open-webui volume during an update.

For Python:

pip install -U open-webui
open-webui serve

If you run multiple workers or replicas, perform migrations with one worker first to avoid database problems.

Common problems

Open WebUI cannot connect to Ollama

Use the right URL for your install:

• Docker to host Ollama: http://host.docker.internal:11434
• Python install on same host: http://localhost:11434
• Podman host access: http://host.containers.internal:11434
• Bundled image: use the bundled connection path

Test Ollama:

curl http://localhost:11434/api/tags

The UI opens but models are missing

Check the admin connection settings. Also confirm that you have pulled at least one model:

ollama list

Data disappeared after reinstall

You likely removed or changed the data volume or DATA_DIR. Restore from backup if available and restart with the same persistent storage path.

Document upload works but answers are weak

Test with a small, clean text document. Then check embedding settings, RAG permissions, and whether the model has file context enabled.

Background, planning, and caveats

Approximate planning cost (U.S.)

For Open WebUI local installs, most cost is local infrastructure and provider usage:

• Hardware: enough RAM/VRAM for model serving and document processing.
• Storage: chat history, uploaded files, embeddings, and SQLite/other backend data.
• Optional VPS: useful if you want always-on service or separate team access.
• API/provider costs: cloud providers add monthly or token-based costs even when Open WebUI is local.
• Optional managed hosting: Open WebUI can be deployed with orchestrators for teams who need scaling and observability.

If your use is a single-user workstation, local Docker/Python is usually cheaper than managed service.

Cost breakdown

• one-time:
  • host hardware or monthly instance,
  • secure storage capacity,
  • optional TLS/domain if exposing externally.
• recurring:
  • external model or retrieval API costs,
  • backups and monitoring overhead.

Data persistence and backups

Use persistent storage intentionally:

• Docker: keep open-webui:/app/backend/data across restarts.
• Python: keep DATA_DIR stable and backed up.

Back up chat history, user settings, and knowledge folders before major updates.

Credential handling

• Keep admin/user credentials in a password manager.
• Do not keep provider API keys in plain shell history or shared scripts.
• For shared installs, create role-based access and review admin users before enabling new teams.

Security risk and operational cautions

• Local browser-based UIs are often exposed accidentally; avoid binding to open interfaces unless you intend network access.
• Restrict document tools and file upload features for untrusted users.
• Review admin role permissions before enabling integrations that can call external systems.

Questions before installing

• Do you need low-latency local inference or shared chat access?
• Are model providers local-only or cloud-backed?
• Do you have a stable backup and restore path for /app/backend/data?
• How many users will need separate roles from day one?

Red flags

• Reinstalling without retaining the same volume/data path.
• Unclear ownership of uploaded user documents.
• No plan for authentication before inviting collaborators.

Rollback and update guidance

For rollback:

• keep snapshots of your data volume (Docker) or DATA_DIR.
• test a restore on a fresh container path before replacing a working system.

For updates:

• back up data, pull the latest image, and recreate the container,
• keep your mounted volume and compare behavior with a short smoke test before full rollout.

Bottom line

For most users, install Open WebUI with Docker, keep -v open-webui:/app/backend/data, connect Ollama through a host-reachable URL, and create the first admin account locally. After that, enable document RAG and multi-user permissions only as needed.