Open WebUI: a ChatGPT-style interface for your local models
Install Open WebUI without Docker (the uv path), create your account, and chat with the models you already pulled in Ollama. Tested end-to-end on a real machine.
What Open WebUI actually is
A web frontend that speaks to model providers. Point it at Ollama (or any OpenAI-compatible endpoint) and it turns a raw API into the familiar chat interface: sidebar with your conversations, model picker in the composer, thinking indicators, export, settings.
The division of labor is the key idea:
- Ollama / llama.cpp = the engine (runs the model, serves the API).
- Open WebUI = the cockpit (the human interface on top).
Nothing about this requires the internet. Once it’s installed, every byte of every conversation stays between your browser and your own machine.
Step 1 — Install (the uv path)
The official docs show Docker, but a plain uv install is faster to test and works anywhere Python runs:
$ uv tool install --python 3.13 open-webui --force
That gives you an open-webui command on your PATH. Open WebUI is ~1.5 GB of Python packages (it bundles a lot), so give it a minute.
uv pip install --python "C:/Users/you/.local/share/uv/tools/open-webui/Scripts/python.exe" audioop-lts(On Linux/macOS, swap that path for your tool venv.) With it installed, startup is clean. If your server on port 8091 is up but `/health` never responds, this is the reason.
Step 2 — Start the server
$ open-webui serve --host 127.0.0.1 --port 8091
Watch for the startup log, then check it’s alive:
$ curl http://127.0.0.1:8091/health
{"status":true}
Open http://127.0.0.1:8091/ in your browser.
Step 3 — First run: create the admin account
First launch shows a landing page → Démarrer / Start → a setup screen: Create an administrator account with your name, email, and password. (The interface auto-detects your language — it was in French on our test machine.)
The first account is the admin. There’s no separate “login” on this first screen — creating the account is logging in: you land straight on the dashboard with a sidebar of Conversations, Notes, and a composer.
Step 4 — The first chat
If you followed the Ollama tutorial, Open WebUI already sees your models — it probes the default Ollama endpoint (http://localhost:11434) and lists what’s there. On our test machine, qwen3:4b appeared in the model picker immediately, no configuration step.
Type something, hit Enter. What we tested:
Réponds EXACTEMENT avec ce texte et rien d'autre : OWU_OK
Answer from qwen3:4b, shown in the UI as:
Réflexion pendant 27 secondes OWU_OK
Two things in that exchange are worth noticing:
- The thinking indicator — Qwen 3-family models reason before answering, and Open WebUI shows the wait instead of hanging silently.
- The conversation lands in your sidebar (“Exact Response”) and survives restarts. Everything is stored locally in Open WebUI’s own database.
Where your connections live
Settings are under your avatar (bottom-left) → Réglages / Settings (Ctrl+.) → Système → IA → Connexions. There you’ll find:
- API Ollama — the connection to your local Ollama (base URL, default
http://127.0.0.1:11434). - API compatibles OpenAI — any OpenAI-compatible endpoint, including a llama.cpp server.
- Direct connections — per-user endpoints, so each person can plug in their own.
What you get for free
| Feature | Note |
|---|---|
| Chat with any connected model | Model picker in the composer |
| Conversation history, folders | Stored locally |
| Thinking/reasoning display | For thinking models |
| Web search, documents, images | Built-in tools (optional) |
| Multi-user | Everyone gets their own space |
| Offline | After install, nothing needs the internet |
Docker (the other path)
The official quick-start is docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main. It’s the same app; we used the uv path on this machine because the Docker engine wasn’t available here. Pick whichever you can start — the UI you get is identical.
Where this leaves you
You now have the full local stack working: an engine (Ollama or llama.cpp), a model on disk, an API, and a proper interface. That’s the same architecture as every “chat app”, minus the datacenter: