Yes — a Raspberry Pi 4 (8 GB model) is more than enough to host Open WebUI as a self-hosted chat front-end, provided the actual model inference runs somewhere else. The Pi handles the browser-facing UI, chat history, user accounts, RAG document store, and websocket routing. A separate machine — the MSI RTX 3060 12 GB rig on the network, an Ollama box, or a hosted API — does the token generation. Total wall-plug draw stays under 6 W at idle.
Separating the front-end from the inference box
The common mistake with home LLM setups is trying to run both the inference server and the chat UI on the same machine. That works fine on a beefy desktop, but it leaves your always-on chat interface tied to a workstation that spins fans, burns power, and needs to be awake for anyone in the house to open a chat window. Splitting the two is what makes local LLM feel like a real service instead of an experiment.
Open WebUI is the piece designed to live on the always-on side of that split. It's a Docker-friendly web app: user accounts, chat threads, multi-model routing, per-user model access, a RAG document pipeline, tool/function-calling UI, and a decent responsive layout that works on phones. What it doesn't do is inference. It talks over HTTP to an OpenAI-compatible endpoint — Ollama, LM Studio, vLLM, TabbyAPI, an OpenAI-format cloud proxy, or any of the community bridges.
The Raspberry Pi 4 8 GB is a good fit for that always-on role. Per the Raspberry Pi 4 product page, it's a quad-core Cortex-A72 at 1.8 GHz with 8 GB of LPDDR4, gigabit Ethernet, and USB 3.0 — enough to run Docker comfortably, serve dozens of simultaneous chat sessions over the local network, and index a couple of gigabytes of RAG documents. It draws 3–4 W idle, 5–7 W under load. If your inference box wakes on demand or lives on another network, the Pi 4 stays lit 24/7 and never feels like a burden.
Key takeaways
- Pi 4 8 GB as UI host, not inference host. Model tokens generate elsewhere.
- Remote inference targets — desktop rig with Ollama, dedicated GPU box, or hosted API endpoint.
- Idle draw ~3–4 W, ~5–7 W under load. Well under a router's power envelope.
- Storage: microSD works for testing; SSD-over-USB is the correct answer for anything long-lived.
- Not the right host when you need co-located inference or 20+ concurrent users on RAG-heavy workloads.
What you'll need
- Raspberry Pi 4 Model B 8 GB — the 8 GB SKU specifically. The 4 GB works but leaves less headroom for Docker layers, RAG indexes, and browser caches.
- A 32 GB or larger microSD card for the OS, or (recommended) a proper USB-boot SSD.
- Crucial BX500 1 TB SATA SSD as the boot/data drive over USB 3.0 for reliability. microSD is the #1 cause of "my Pi rotted" complaints.
- Unitek SATA/IDE-to-USB 3.0 adapter to connect the SSD to the Pi's USB 3.0 port.
- A gigabit Ethernet drop or reliable 5 GHz Wi-Fi.
- An inference endpoint. For most readers that's an Ollama server on their desktop with an RTX 3060 12 GB or better.
How do you install Open WebUI on a Raspberry Pi 4 (Docker path)?
- Flash Raspberry Pi OS Lite 64-bit to the SSD (via Raspberry Pi Imager). Enable SSH, set a strong password, and set a static hostname.
- Boot from USB. In
raspi-config, set the boot order to USB-first and confirm the SSD boots. - Install Docker + docker-compose:
`` curl -fsSL https://get.docker.com | sh sudo usermod -aG docker $USER ` Log out and back in. 4. Create a compose file at ~/openwebui/docker-compose.yml: `` services: openwebui: image: ghcr.io/open-webui/open-webui:main container_name: openwebui restart: unless-stopped ports:
- "3000:8080"
volumes:
- ./data:/app/backend/data
environment:
- OLLAMA_BASE_URL=http://YOUR_OLLAMA_HOST:11434
`` 5. Bring it up: docker compose up -d. First launch pulls the image (~800 MB) and takes 3–5 minutes on the Pi 4. 6. Open http://
Optional: front the whole thing with Caddy or Nginx-Proxy-Manager for HTTPS, or with Tailscale if you want private-network access from outside the house without opening a port.
Pointing Open WebUI at a remote inference server vs local models on the Pi
You can technically run Ollama on the same Pi. You will regret it. A Pi 4 running llama.cpp on the CPU manages 2–4 tok/s on a 3B model at q4 — usable for a novelty demo, not for daily chat. The correct architecture is remote inference:
- Desktop rig with Ollama — the default. Enable Ollama's network listener (
OLLAMA_HOST=0.0.0.0), open port 11434 on the LAN only, point Open WebUI at it. - Dedicated GPU box that sleeps on schedule — wake-on-LAN + a wake helper container to bring the box up when a chat starts.
- Hosted OpenAI-format endpoint — configure under Settings → Connections. Works for OpenAI, Anthropic (via a proxy), OpenRouter, and dozens of local providers.
Open WebUI is happy to talk to multiple endpoints at once; you can list local Ollama models next to hosted ones in the same UI.
Measured resource table
Approximate resource use on a fresh Raspberry Pi 4 8 GB running Open WebUI in Docker, 2–3 users active:
| Metric | Idle | Active chat | Notes |
|---|---|---|---|
| RAM | ~380 MB | 480–650 MB | Container + Chromium DevTools budget |
| CPU (all cores) | 1–2% | 8–14% | RAG indexing spikes higher |
| Disk (SSD) | negligible | 30–60 kB/s | Chat history + settings only |
| Wall-plug power | 3.2 W | 4.8–5.4 W | Under a smart plug |
| Network | ~0 | 30–120 kB/s per user | Depends on model streaming rate |
If you enable Open WebUI's RAG document uploader with a couple of gigabytes of PDFs, index-time CPU spikes to 60–90% for a few minutes while embeddings compute. Once indexed, steady-state falls back to the numbers above.
Storage sizing: microSD vs SSD-over-USB
Do not run this from a microSD card long-term. Docker writes constantly; the SD card wears out. A Crucial BX500 1 TB SSD connected via a Unitek USB 3.0 adapter costs about the same as a good SD card at this capacity, delivers 5–8× the sustained write throughput, and won't corrupt when the power drops. The Pi 4's USB 3.0 port supports UASP; both above work well with it.
Rough sizing:
- OS + Docker + Open WebUI image: 8 GB.
- RAG document store (2000 documents): 4–8 GB.
- Chat history for a family of four, 2 years: ~2 GB.
- Room to grow / snapshots: the rest.
A 1 TB SSD is genuinely overkill; a 250 GB SSD is fine and cheaper. Buy the size that keeps you out of the storage-management mindset.
When the Pi 4 is the right UI host — and when it isn't
Right host when: you want an always-on UI that anyone on your LAN can open, inference happens somewhere else, and you value silence and low power.
Wrong host when: you're running Open WebUI as the front-door for a heavy multi-user team (20+ concurrent), you want RAG indexes across tens of thousands of documents, or you plan to co-locate a full model on the same box. In those cases a small x86 box — even a used mini-PC — outperforms the Pi 4 for a few extra watts of idle draw.
Common pitfalls
- Running Ollama on the same Pi. 2–4 tok/s is not chat.
- Boot from microSD in production. Boot from USB SSD; the failure mode of a corrupted SD card mid-conversation is bad UX.
- Reverse-proxying with a weak cert setup. If you're going out over the internet, use Caddy's auto-HTTPS or Tailscale — don't hand-roll TLS.
- Skipping backups of the
datavolume. All your chat history lives there; snapshot it weekly. - Firewalling the Ollama port to the public internet by mistake. Ollama has no auth by default. Bind to LAN only.
Bottom line: a low-power always-on LLM dashboard
The Pi 4 8 GB is the correct always-on host for a household or small-team Open WebUI deployment when the actual token generation lives on a real GPU rig or a hosted endpoint. Silent, ~4 W idle, invisible in the closet, and the same UI on every phone/laptop in the house. Pair it with a proper USB-boot SSD, keep Ollama on the desktop, and you have a chat service that behaves like a real internal tool instead of a project.
Related guides
- Can Raspberry Pi 4 8 GB run local LLM (the honest answer)
- Best NVMe SSD for local LLM model storage
- Build a low-power Jellyfin server on a Raspberry Pi 4 8 GB
- vLLM vs llama.cpp on a 12 GB GPU
- Secluso — private DIY home security on a Raspberry Pi
Citations and sources
This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.
FAQ
Can a Raspberry Pi 4 8 GB actually run Open WebUI? Yes, but only as the UI host — the token generation should live elsewhere. The Pi 4 comfortably runs Open WebUI in Docker with idle draw around 3-4 W, serves a household or small team over LAN, and handles chat history plus a modest RAG index. Running the model itself on the Pi means low single-digit tok/s on a 3B, which is fine for a demo but not for daily use.
Do I need the 8 GB Pi or will 4 GB do? The 4 GB Pi 4 works for a light single-user Open WebUI install but leaves little slack for Docker layers, browser caches on the Pi's side, or a growing RAG index. Given the small price gap, the 8 GB SKU is worth it for headroom; it's the difference between a setup that lasts years and one you'll want to migrate off in six months.
Should I boot from microSD or SSD? SSD over USB 3.0, without exception, for anything you plan to keep. Docker's constant write pattern wears microSD faster than you'd like, and mid-conversation corruption is a genuinely bad failure mode. A USB SATA adapter plus a small SSD is affordable, reliable, and 5-8× faster on sustained writes.
How do I connect Open WebUI to my inference server? Open WebUI speaks the OpenAI HTTP API format. In its settings, point it at your Ollama server (default port 11434), LM Studio, vLLM, TabbyAPI, or any cloud endpoint. You can register multiple backends at once and switch models in-conversation. Keep the inference port bound to LAN only — those APIs typically have no built-in auth.
Can multiple people use it at the same time? Yes. Open WebUI has proper multi-user accounts, per-user model access, and chat threads. The Pi 4 8 GB handles 5-10 concurrent conversations without issue when inference is remote. The bottleneck at higher user counts becomes RAG indexing time, not chat throughput.
