How to Install and Use Open WebUI with Ollama

Open WebUI is the most popular graphical interface for Ollama — it gives you a polished browser-based chat interface, conversation history, model management, and multi-user support, all running on your own machine. Where Ollama handles model downloading and inference through the command line, Open WebUI puts a clean UI on top of it. This guide covers installing Open WebUI alongside Ollama, connecting the two, and getting the most out of the combined setup.

What Open WebUI Adds to Ollama

Ollama on its own is a CLI and API tool — you interact with models by typing in a terminal or sending HTTP requests. This works well for developers but is less approachable for everyday use or for sharing access with others. Open WebUI adds a full chat interface accessible from any browser on your network, conversation history saved across sessions, the ability to switch models mid-conversation, document upload and RAG support, image generation integration, and user account management for multi-user deployments. It connects to Ollama’s local API and can also connect to cloud APIs like OpenAI and Anthropic alongside your local models.

Prerequisites

You need Ollama installed and running before installing Open WebUI. Open WebUI connects to Ollama’s API on port 11434 — if Ollama is not running, Open WebUI will install but show no models. Install Ollama first, verify it works with ollama run llama3.2, and then proceed. You also need Docker or Python 3.11+ — Docker is the recommended installation method as it handles all dependencies automatically.

Installing Open WebUI with Docker

Docker is the easiest and most reliable way to run Open WebUI. The official image bundles everything needed and handles updates cleanly. With Docker installed, pull and run Open WebUI with a single command that maps the web interface to port 3000 and connects it to your local Ollama instance. The --network=host flag on Linux gives the container direct access to localhost where Ollama is running. On Mac and Windows, use host.docker.internal as the Ollama host instead, since Docker Desktop uses a VM that cannot reach localhost directly.

After running the command, open your browser and navigate to http://localhost:3000. The first time you access it, Open WebUI prompts you to create an admin account — this first account gets admin privileges, so create it with your own credentials. Subsequent accounts created through the UI are regular users by default.

Installing without Docker (pip method)

If you prefer not to use Docker, Open WebUI installs as a Python package. You need Python 3.11 or later. Create a virtual environment, activate it, and install open-webui with pip. Once installed, start it with the open-webui serve command — it starts on port 8080 by default rather than 3000. The pip method works well for users who already manage Python environments and want to avoid Docker, but updates require re-running pip install rather than a simple container pull.

Connecting Open WebUI to Ollama

When both are running on the same machine, Open WebUI connects to Ollama automatically on first launch by checking the default Ollama API address. If the connection succeeds, your downloaded Ollama models appear immediately in the model dropdown at the top of the chat interface — no configuration needed. If models do not appear, go to Settings → Connections and check that the Ollama URL is set correctly. On Linux with Docker using host networking it should be http://localhost:11434. On Mac and Windows with Docker Desktop it should be http://host.docker.internal:11434.

You can also connect Open WebUI to a remote Ollama instance by changing the URL to the remote machine’s IP address and port, provided that machine’s Ollama is configured to accept external connections via OLLAMA_HOST. This lets you run Ollama on a powerful desktop and access the interface from a laptop or tablet on the same network.

Using Docker Compose for the Full Stack

For a cleaner setup that manages both Ollama and Open WebUI together, Docker Compose is the recommended approach. Create a docker-compose.yml file that defines both services — the Ollama container with GPU passthrough (if you have NVIDIA) and the Open WebUI container pointing at the Ollama service. With Compose, a single docker compose up -d starts everything, docker compose down stops it, and docker compose pull updates both containers. This is particularly useful on a home server or NAS where you want the AI stack to start automatically on boot — add restart: unless-stopped to both services in the Compose file.

Key Features to Know

Once Open WebUI is running, several features are worth knowing about beyond basic chat. Model management: you can pull new Ollama models directly from the Open WebUI interface under Admin → Models, without using the terminal. Document RAG: the paperclip icon in the chat input lets you upload PDFs, text files, and other documents — Open WebUI chunks and embeds them, and the model can answer questions about the content. This is a basic RAG implementation suitable for single documents; for production RAG pipelines with large document sets, a dedicated pipeline is more appropriate. Web search: Open WebUI supports connecting a web search API (SearXNG, Google PSE, or others) to give the model access to current information. Image generation: connect an image generation backend (AUTOMATIC1111 or ComfyUI) alongside Ollama for a combined text and image generation interface.

Multi-User Setup and Permissions

Open WebUI’s user account system makes it practical to share a local AI instance with housemates, colleagues, or a small team. The admin account controls which models are available to users, can set per-user or per-role permissions, and manages API keys for programmatic access. User accounts are local — there is no external authentication by default, though LDAP and OAuth integration is available for enterprise deployments. Each user’s conversation history is private to their account. For home or small team use, the default local account system is sufficient; for larger deployments or internet-facing instances, enable authentication hardening and consider putting Open WebUI behind a reverse proxy with HTTPS.

Troubleshooting Common Issues

A few problems come up consistently on first setup. If the interface loads but shows no models, Ollama is not reachable at the configured URL — check that Ollama is running with ollama ps and verify the connection URL in Settings. If you get a connection refused error on Mac or Windows with Docker, switch the Ollama URL from localhost to host.docker.internal. If Open WebUI starts but crashes immediately, check Docker logs with docker logs open-webui for the error — a common cause is a port conflict on 3000, which you can resolve by mapping to a different port in the Docker run command. If models are visible but responses are very slow, the model is running on CPU rather than GPU — verify GPU passthrough is configured correctly in your Docker run command or Compose file.

Frequently Asked Questions

Does Open WebUI work with models other than Ollama?

Yes. Open WebUI can connect to any OpenAI-compatible API endpoint, including the OpenAI API itself, Anthropic (via an OpenAI-compatible proxy), local alternatives like LM Studio, and self-hosted OpenAI-compatible servers. Configure additional connections under Settings → Connections.

Is Open WebUI safe to expose to the internet?

With proper configuration yes, but extra steps are needed. At minimum: enable user authentication, use a strong admin password, put it behind a reverse proxy with HTTPS (Nginx or Caddy with a TLS certificate), and consider restricting access to known IP ranges if the instance is not intended to be public.

How do I update Open WebUI?

With Docker: stop the container, pull the latest image with docker pull ghcr.io/open-webui/open-webui:main, and restart. With Docker Compose: run docker compose pull then docker compose up -d. With pip: run pip install --upgrade open-webui in the virtual environment.

Can I use Open WebUI on a mobile browser?

Yes. The interface is responsive and works well on mobile browsers when you access it from a device on the same local network as the machine running Open WebUI. Navigate to http://[machine-ip]:3000 from your phone’s browser.

Last updated: October 2026

Persistent Storage and Data Across Restarts

By default, conversation history, user accounts, uploaded documents, and settings are stored inside the Docker container. This means everything is lost if you remove the container. To persist data across updates and restarts, mount a local directory to the container’s data path when you run it. Add a volume flag pointing a local folder on your machine to /app/backend/data inside the container. With this in place, you can stop, remove, and recreate the Open WebUI container — including pulling a new version — and all your conversations, settings, and user accounts survive intact. This is the single most important configuration change to make on any non-throwaway Open WebUI installation, and it is easy to forget on first setup.

Accessing Open WebUI from Other Devices

Open WebUI runs on your local machine but is accessible from any device on the same network. Find your machine’s local IP address (on Mac: System Settings → Network; on Windows: ipconfig in terminal; on Linux: ip addr), then navigate to http://[your-ip]:3000 from a phone, tablet, or another computer. This makes Open WebUI a practical shared AI interface for a household or small office — everyone on the network can use it through their browser without installing anything. To make it available outside your local network, a reverse proxy with HTTPS and a domain name is the standard approach; tools like Cloudflare Tunnel make this straightforward without opening router ports.