Open WebUI on your home network: one chat URL for Ollama, vLLM and LM Studio

One Docker container, one URL on your LAN, and every model in the house behind it — here's the complete Open WebUI setup, from compose file to HTTPS.

Listen to this post · 15 min

Accessibility: the whole post is read aloud — Space plays or pauses, ← → skip 10 seconds, and you can change the speed. It keeps playing with your screen locked.

Share this post

In short

  • Open WebUI is the glue for a multi-engine stack: one Docker container, one URL, connections to Ollama plus any OpenAI-compatible endpoint, and per-user model permissions.

What you're building: one URL, every model

Here's the pattern we keep hearing, because it's the pattern in our own group chats: Ollama on the desktop with the big GPU, vLLM on the box with the proper server card, LM Studio on the Mac — and family members who don't care about any of that. They want a chat box that works on their laptop and their phone.

Open WebUI is the glue. It's a self-hosted web interface — installable via Docker or pip — that speaks to Ollama natively and to any OpenAI-compatible endpoint. That one sentence covers vLLM, LM Studio's built-in server, llama.cpp's server, and hosted APIs. If you've already got two of those running and have been wondering how to give the household one clean front door, this is the piece you're missing.

What you end up with: one URL on your home network, a user account for each family member, per-user model permissions, and one place to manage RAG documents, prompts and settings. The kids get the small chat model; you get the big coding model; nobody fights over a terminal.

Honest scope: this guide covers the Docker setup, connecting three engine types, users and permissions, and HTTPS on your LAN. It does not cover exposing the instance to the public internet — that's a different risk profile and we'd treat it separately.

Prerequisites and the one decision to make first

You need Docker (or Docker Compose) on the machine that will serve the UI, and at least one engine already running: Ollama, vLLM, LM Studio's local server, or llama.cpp's server. If you haven't chosen engines yet, our LM Studio vs Ollama comparison covers that decision.

The one decision to make before you touch a compose file: same box or separate boxes? Open WebUI on the same machine as Ollama is the simplest possible setup. Engines on other machines are fine too — they just need to be reachable over the LAN and configured to accept remote connections:

  • Ollama: set OLLAMA_HOST=0.0.0.0 so it binds beyond localhost.
  • vLLM: pass --host 0.0.0.0 to vllm serve.
  • LM Studio: flip the "serve on network" toggle in the server tab.

One hardware note from our earlier coverage: vLLM needs a CUDA GPU of roughly compute capability 7.0 or newer. If your second box has a Pascal-era card (GTX 10-series), serve that box with Ollama or llama.cpp instead.

EngineOpenAI-compatible endpointCheck before connecting
OllamaNative port 11434 (no /v1 needed)OLLAMA_HOST=0.0.0.0, model pulled
vLLMhttp://<box>:8000/v1--host 0.0.0.0, model loaded at serve time
LM Studiohttp://<mac-or-pc>:1234/v1Local server on, "serve on network" enabled, model loaded
llama.cpp serverhttp://<box>:8080/v1--host 0.0.0.0, --api-key if set

Step 1: Docker Compose with Ollama attached

Here's the canonical starting point — a complete compose file you can paste:

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    volumes:
      - open-webui:/data
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    restart: unless-stopped

  ollama:
    image: ollama/ollama:latest
    # GPU passthrough on Linux/NVIDIA:
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]
    volumes:
      - ollama:/root/.ollama
    restart: unless-stopped

volumes:
  open-webui:
  ollama:

The open-webui volume is the important bit: it holds user accounts, chat history, RAG documents and settings. Lose it and you lose everything.

If Ollama already runs elsewhere, delete the ollama service and change the URL. This is the classic gotcha:

  • Docker Desktop (Mac, Windows): use http://host.docker.internal:11434 — the container can't see localhost the way your terminal can.
  • Linux Docker: host.docker.internal doesn't resolve by default, but the fix is one line, not a hard-coded IP. Add this to the open-webui service:
    extra_hosts:
      - "host.docker.internal:host-gateway"

Then http://host.docker.internal:11434 works on Linux too. If you'd rather not, the LAN IP of the Ollama machine (e.g. http://192.168.1.50:11434) also works — it just breaks if the IP changes.

First run:

  1. docker compose up -d
  2. Browse to http://<host-ip>:3000
  3. Create the first account — this becomes the admin. Do this yourself, before handing out accounts.
  4. Confirm your Ollama models appear in the model picker.

Step 2: Adding vLLM, LM Studio and any OpenAI-compatible endpoint

This is the part no single guide covers well: several engines side by side. Go to Admin Panel → Settings → Connections. Ollama is configured via OLLAMA_BASE_URL (or in the UI itself); everything else goes under OpenAI API connections — one entry per engine, each with a name, a base URL (including /v1) and whatever API key the engine requires.

  • vLLM: base URL http://<box>:8000/v1. vLLM doesn't enforce a key by default, so any dummy string works. The model name in the picker is whatever you passed to vllm serve — usually the full checkpoint path, not a short name. If you need the serve command itself, our vLLM install guide has a working one.
  • LM Studio: enable the local server and "serve on network", note the port (default 1234), base URL http://<mac-or-pc>:1234/v1. No key needed.
  • llama.cpp server: base URL http://<box>:8080/v1, dummy key unless you set --api-key.

Naming tip that saves an hour later: prefix connection names with the machine — office-pc / vLLM, mac-studio / LM Studio. The model picker shows model names, not engine names, and when the same model is served twice, the connection label is the only way to tell them apart.

Any hosted OpenAI-compatible API works the same way — which is also how you'd add a hosted endpoint if a family member wants a model too big for the house hardware. Inpherio's API is OpenAI-compatible, so it drops in like any other connection.

Step 3: Users, groups and per-user model permissions

This is the real reason to run Open WebUI rather than sharing one engine endpoint: control over who can use what.

In Admin Panel → Users:

  • Enable sign-ups, or disable them and add family manually — the safer default on a LAN where guests come and go.
  • Set the default user role to user, not admin. The first account is admin; nobody else needs to be.

Model permissions are where it earns its keep. Per-user and per-group access controls let you give the kids the 4B chat model and keep the big coding model to yourself. This isn't just tidiness: a big model loaded on shared hardware slows everyone down, and a curious family member clicking through the model picker can evict the model you were mid-conversation with.

Groups make this manageable: put family members in a group with a curated model list and shared knowledge documents, and keep an admin group with everything.

Two settings worth flipping early:

  1. New-user sign-ups pending approval — nothing goes live until you approve it.
  2. The default model a new user lands on — pick something small and fast, so the first experience isn't a heavyweight model crawling on a shared GPU.

One trade-off to admit: user management is where Open WebUI's complexity shows. It's a full admin panel, not a toy. Budget twenty minutes to read through it once before inviting anyone.

Step 4: HTTPS on the home network

Browsers complain about plain HTTP, and some Open WebUI features genuinely break without a secure context: microphone access for voice input, clipboard, notifications. Plain http://<ip> blocks them and throws mixed-content warnings. Even on a LAN you'll want HTTPS.

The easiest route is Caddy, added to the same compose file as a reverse proxy. Caddy handles certificates automatically, which is why we recommend it over hand-rolled nginx configs for a home setup:

  caddy:
    image: caddy:latest
    ports:
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy-data:/data
    restart: unless-stopped

volumes:
  caddy-data:

With a Caddyfile like:

ai.home.lan {
  tls internal
  reverse_proxy open-webui:8080
}

tls internal has Caddy run its own CA and issue a certificate — no domain, no Let's Encrypt, no manual openssl dance.

Alternative: if you own a real domain, point a DNS A record at your LAN IP and let Caddy get a Let's Encrypt certificate. Nicer, but unnecessary if you don't.

The client-side step everyone forgets: with an internal CA, each device needs to trust it once. Caddy stores its root certificate in the caddy-data volume — copy it out (docker cp), then:

  • iOS: AirDrop or email the .crt file, tap to install, then enable full trust in Settings → General → About → Certificate Trust Settings.
  • Android: Settings → Security → Install a certificate (or via the file manager), then it's trusted for apps; Chrome may need a site setting confirmed on first visit.

Keep it LAN-only. Bind Caddy to the LAN interface, don't port-forward anything at your router, and if you want access from outside the house, use a VPN (Tailscale or WireGuard) rather than exposing the port. That's a much smaller attack surface than an internet-facing login page.

Step 5: What's worth turning on once it works

RAG for the household. Upload documents — appliance manuals, school notes — in the workspace or per-chat. Embeddings need a model: Ollama users can ollama pull nomic-embed-text, and it's worth knowing hosted embedding models cost fractions of a penny per million tokens if you'd rather not run one locally.

Voice. Open WebUI supports STT and TTS through its pipeline connections. Pair it with a local whisper server, or a hosted STT endpoint — we compared the options and costs in our October speech-to-text breakdown.

Model presets and system prompts. Set a default temperature and system prompt per model, so family members get sensible behaviour without ever touching settings.

Update discipline. Open WebUI ships frequently. Pin a specific version tag in compose (e.g. ghcr.io/open-webui/open-webui:v0.6.x — check the releases page for the current one) instead of :main or :latest, and read the release notes before bumping — the same discipline we recommended for the llama.cpp v1.0 upgrade.

Backups. The single Docker volume holds everything — accounts, chats, RAG documents, settings. One volume, one backup job:

docker run --rm -v <volume-name>:/data -v $(pwd):/backup \
  alpine tar czf /backup/open-webui-$(date +%F).tar.gz /data

Check the real volume name with docker volume ls first — Compose prefixes it with the project name, so it's typically something like myproject_open-webui, not plain open-webui. Put the command in cron weekly and you're done.

Troubleshooting: the five errors you'll actually hit

Model picker is empty. Usually one of three things: the base URL is missing /v1 (for OpenAI connections — Ollama doesn't need it), the engine isn't bound to 0.0.0.0, or you're on Docker Desktop and used the LAN IP instead of host.docker.internal.

Connection works from the server but not from a phone. Host firewall, or the engine bound to localhost only. curl http://<lan-ip>:<port>/v1/models from another machine on the network is the fastest test.

Everything slows down when two people chat at once. Ollama can run a few parallel requests on one loaded model (OLLAMA_NUM_PARALLEL, default 4 on suitable hardware), so small-model chats often interleave fine — but it's not built for sustained concurrent load the way vLLM's continuous batching is. If the household chats at the same time on a big shared model, put that model on vLLM. We covered the detail in vLLM vs Ollama.

HTTPS warnings after setup. The CA isn't trusted on that device yet — back to Step 4's client-side bit.

Lost admin access. The first account created is the admin. If you deleted it, the Open WebUI docs describe a CLI reset path — but the simpler fix is prevention: keep sign-ups off until you're fully set up, and don't delete the admin account.

What we'd pick

For a typical household: Open WebUI in Docker on whichever machine is always on, Ollama beside it for the small default model everyone lands on, vLLM on the proper GPU box for anything big or shared, Caddy in the same compose stack for HTTPS, and sign-ups off with manual account creation. Twenty minutes of setup, and the family stops asking why the terminal is full of text.

Questions people ask

Can Open WebUI connect to Ollama and vLLM at the same time?

Yes. Ollama connects via its own base URL setting and every other engine — vLLM, LM Studio, llama.cpp's server, hosted APIs — connects as an OpenAI-compatible endpoint. All appear in the same model picker. | How do I access Open WebUI from other devices on my home network? | Browse to http://<host-ip>:3000 from any device on the LAN, after mapping port 3000 in your compose file. If it works on the server but not your phone, check the host firewall and that the engine isn't bound to localhost only. | Does Open WebUI need to run on the same machine as Ollama? | No. Point OLLAMA_BASE_URL at any reachable Ollama instance — use host.docker.internal on Docker Desktop, or add extra_hosts: ["host.docker.internal:host-gateway"] on Linux. | How do I stop family members using the big model? | Set per-user or per-group model permissions in the Admin Panel, and make the default model for new users something small and fast. | Does Open WebUI need HTTPS on a private network? | Not strictly, but browser features like microphone input require a secure context, so voice input won't work over plain HTTP. A Caddy reverse proxy in the same compose stack is the easy fix. | How do I back up Open WebUI chats and users? | Everything lives in one Docker volume. A one-line tar of the volume directory covers accounts, chats, RAG documents and settings. | Can I use Open WebUI with LM Studio? | Yes — enable LM Studio's local server and 'serve on network' toggle, then add it as an OpenAI connection with base URL http://<machine>:1234/v1.

Models in this post — live on Inpherio

Have a GPU, a Mac or a spare PC?

Let it earn while you sleep.

Run open models for people who need them. You set the price and keep everything but the 15% fee.

Become a host

Building with AI?

Every open model, one API.

OpenAI-compatible. Priced by the people who run the hardware.

Start free See the marketplace

Read “Open WebUI on your home network: one chat URL for Ollama, vLLM and LM Studio” at https://inpherio.co.uk/blog/open-webui-on-your-home-network-one-chat-url-for-ollama-vllm-and-lm-st