Open WebUI: The Self-Hosted ChatGPT You’ve Been Waiting For

You know that feeling when you realize you’re spending $20/month on ChatGPT Plus while your homelab sits there humming quietly, completely underutilized? Yeah. That’s what Open WebUI fixed for me.

Here’s the thing: running a local LLM with Ollama is easy enough, but the command-line interface is basically a text terminal from 1995. You get no conversation history, no document uploads, no image generation—just raw model output. It works, sure, but it feels janky compared to the polished experience you get from ChatGPT.

Open WebUI solves this elegantly. It’s a gorgeous, feature-rich web interface that sits on top of Ollama (or any OpenAI-compatible API) and gives you everything you’d expect from a modern AI chat tool—all self-hosted, all private, all under your control.

What Makes Open WebUI Actually Worth Running

Let me be direct: if you’re already running local LLMs, Open WebUI is not optional. It’s the difference between having a working tool and having something you actually want to use daily.

The interface is clean and modern. No clunky UI, no weird quirks—it just feels like ChatGPT, because the designers clearly studied ChatGPT’s UX and said “let’s do that but better.” You get a sidebar for conversation history, easy model switching, responsive chat bubbles, and markdown rendering that actually works.

But it’s not just a pretty face. The real meat is in the features:

• RAG (Retrieval Augmented Generation) — Upload PDFs, images, or text documents and have the model reference them in answers. This alone is worth hosting.
• Web search integration — Feed current information into your local model so it’s not stuck with old training data.
• Image generation — Pipe requests to Stable Diffusion or other image models running locally.
• Multi-user with role-based access — Run this for your whole household or team with proper permissions and isolation.
• Model management — Switch between different LLMs on the fly, manage which models you have loaded, pull new ones from Ollama.
• Conversation export — Save chats as markdown, JSON, or PDF. Actually useful when you need to reference something later.

I’ve been running this for 6 months and it’s become my default first stop before I even consider touching the cloud version of ChatGPT. Faster response times (for small prompts), zero latency concerns, and everything stays on my network.

The Install (It’s Stupidly Easy)

Okay, confession: I was expecting this to be annoying. It’s not. Docker Compose, 30 seconds, done.

First, you need Ollama running somewhere. If you haven’t got that yet, grab it from ollama.ai. Pull at least one model:

ollama pull mistral

Mistral is solid for the resource cost. Or grab Llama 2, Neural Chat, whatever you like. Just make sure it’s running before you spin up Open WebUI.

Now, the Docker Compose. Drop this in a file called docker-compose.yml:

version: '3.8'
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:latest
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui-data:/app/backend/data
    networks:
      - webui-network
    restart: unless-stopped

  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    volumes:
      - ollama-data:/root/.ollama
    networks:
      - webui-network
    restart: unless-stopped

volumes:
  open-webui-data:
  ollama-data:

networks:
  webui-network:
    driver: bridge

Then just run:

docker-compose up -d

Hit localhost:3000 in your browser, create an admin account, and boom—you’ve got ChatGPT running on your hardware. Seriously, that’s it.

Pro tip: If Ollama is already running separately on another machine, change that environment variable to point at the actual IP and port. Same applies if you’re running this in Proxmox or on a separate homelab box.

Making It Play Nice With Your Homelab

The default setup works, but if you’re like me and you’ve got a whole ecosystem running, you probably want to integrate this properly.

Put it behind Traefik. If you’re using Traefik for reverse proxy (and you should be), add labels to the Open WebUI service:

labels:
  - "traefik.enable=true"
  - "traefik.http.routers.openwebui.rule=Host(`chat.yourdomain.com`)"
  - "traefik.http.routers.openwebui.entrypoints=websecure"
  - "traefik.http.services.openwebui.loadbalancer.server.port=8080"

Now you’ve got encrypted HTTPS access from anywhere. Beautiful.

Add it to Home Assistant. If you’re running Home Assistant, you can expose Open WebUI as a service and create automations that send alerts or summaries to it. Not essential, but it’s a nice way to keep everything talking to everything else.

Resource-aware placement. Don’t run this on the same machine as Ollama if you’re starving for CPU or RAM. Open WebUI is lightweight, but if your Ollama container is already thrashing, separating them helps. I run Open WebUI on my Proxmox management node and Ollama on a dedicated container host.

Real Talk: What Sucks and What’s Great

Full transparency: Open WebUI is not perfect, but the good far outweighs the bad.

The annoying parts: Updates come frequently, and occasionally they introduce bugs. The web search feature relies on external APIs unless you configure a custom search backend. If you’re using smaller models (3B parameters and down), response quality is spotty—don’t expect ChatGPT-level intelligence from Mistral running on a 4-core VM.

The actually great parts: It’s actively developed and the community is helpful. Multi-user support actually works. Document upload and RAG are legitimately powerful—I’ve fed entire developer documentation into it and it becomes your personal technical assistant. The model switching is seamless. And here’s the kicker: it’s completely open source and self-hosted, so your conversations stay yours.

I’ve replaced my ChatGPT subscription entirely for tasks that don’t need cutting-edge reasoning. Code generation, documentation writing, brainstorming, summarizing—all faster on my local setup.

The Real Win

Let’s be honest: the biggest reason to run Open WebUI is sovereignty. Your conversations aren’t being logged by OpenAI. You’re not feeding proprietary data into someone else’s training set. You’re not paying per token or worrying about rate limits. It’s your infrastructure, your privacy, your data.

Plus, once it’s running, you stop thinking about it. It just works. You close the browser tab, come back tomorrow, and it’s still there, exactly as you left it.

If you’ve got a homelab and you’re not running Open WebUI yet, you’re leaving a really good tool on the table. Spin it up this weekend. You’ll be using it by Monday.

Explore Open WebUI in our AI Homelab Toolkit.