It is a self-hosted chat interface for models you are already running somewhere else. It looks and works much like a commercial chat app — conversation history, multiple models, document upload, user accounts — but it holds no model itself. It talks to a backend over HTTP, usually Ollama or anything exposing an OpenAI-compatible API, and everything stays on hardware you control.

How much VRAM does Open WebUI need?

Effectively none of its own. It is a web application — a Python backend and a browser front end — so it costs you some RAM and a container, not graphics memory. The VRAM is consumed entirely by whichever backend actually holds the model. That is why the table on this page lists model requirements rather than Open WebUI's: the question that decides what you can run is which model your GPU can hold.

Do I need Ollama to use Open WebUI?

No, though it is the most common pairing and the one the project documents most thoroughly. Open WebUI speaks the OpenAI chat-completions format, so llama.cpp's llama-server, vLLM, and hosted APIs all work as backends — and it can hold several at once, letting you switch between a local model and a remote one in the same conversation list.

Can Open WebUI run without internet access?

Yes, and that is a large part of why people choose it. Once the container image and the model weights are on the machine, the whole stack runs offline — no request leaves your network, and there is no account with a third party holding your conversation history. Features that reach outward, such as web search, are additions you enable rather than defaults.

Is Open WebUI the same as Ollama's interface?

No. Ollama ships a command line and an HTTP API; recent versions include a basic desktop app, but it is deliberately minimal. Open WebUI is a separate project that supplies the parts Ollama leaves out — persistent chat history, multiple users with permissions, document upload for retrieval, model presets. They are complements, which is why the pairing is so common.

Open WebUI: what your hardware can serve

Open WebUI is the chat interface, not the model. It costs you a container and some RAM, and essentially no VRAM at all — which means the only question that decides what you can actually run is what your GPU can hold behind it. A mainstream 16GB card runs 12 of the 30 models below; the smallest needs 2.5GB.

What to put behind it

Open WebUI speaks the OpenAI chat-completions format, so any backend that does will work — and it can hold several at once. The choice is about how the model is served, not about which models are available; all three of these load the same weights.

Ollama
The default pairing, and the least work. Ollama manages the model files and exposes them on port 11434; Open WebUI finds them with no configuration beyond the address.
Ollama models & VRAM
llama.cpp
When you want the flags. llama-server exposes an OpenAI-compatible endpoint, so Open WebUI treats it like any other backend while you keep direct control over layer offload, cache type and context.
llama.cpp models & VRAM
vLLM
When several people share the interface. vLLM batches concurrent requests properly, which matters the moment Open WebUI has more than one user — and it asks for far more VRAM in return.
vLLM models & VRAM

Open WebUI is distributed as a Docker image, which is why almost every setup guide starts there — the container carries its Python backend, the built front end and a database, so nothing has to be installed onto the host. The detail worth getting right is networking: the container needs a route to the backend on the host, which is a different address from inside a container than it is from your browser.

All 30 models and what they cost

Q4 is what these tools load by default; Q8 roughly doubles the memory for a quality difference most people cannot pick out in ordinary use. The pull command is Ollama’s, since that is the most common backend — the memory figure holds whichever one you use.

Model	Q4 VRAM	Q8 VRAM	Ollama command
Meta Llama 3.2 3B Instruct 3.21B · General	2.5GB	4.2GB	`ollama run llama3.2:3b`
Qwen 2.5 Coder 7B Instruct 7.6B · Coding	5.5GB	9.5GB	`ollama run qwen2.5-coder:7b`
DeepSeek R1 Distill Llama 8B 8.0B · Reasoning	5.8GB	9.8GB	`ollama run deepseek-r1:8b`
Llama 3.1 8B Instruct 8.03B · General	6GB	10GB	`ollama run llama3.1:8b`
Qwen3 8B 8.2B · General	6.4GB	10.7GB	`ollama run qwen3:8b`
Google Gemma 2 9B 9.24B · General	7GB	11.5GB	`ollama run gemma2:9b`
Gemma 4 12B 12B · General	8.7GB	14.7GB	`ollama run gemma4:12b`
Mistral NeMo 12B Instruct 12.2B · General	9GB	15GB	`ollama run mistral-nemo:12b`
DeepSeek R1 Distill Qwen 14B 14.8B · Reasoning	10.5GB	17.5GB	`ollama run deepseek-r1:14b`
Qwen 2.5 Coder 14B Instruct 14.7B · Coding	10.5GB	17GB	`ollama run qwen2.5-coder:14b`
Microsoft Phi-4 14B 14.7B · Reasoning	10.5GB	17.5GB	`ollama run phi4:14b`
Mistral Codestral 22B 22.2B · Coding	15GB	26GB	`ollama run codestral:22b`
OpenAI gpt-oss-20b 20.9B (3.6B active) · Reasoning	15.3GB	24.2GB	`ollama run gpt-oss:20b`
Mistral Small 3 24B 24.0B · General	16GB	28GB	`ollama run mistral-small:24b`
Gemma 4 26B-A4B (MoE) 26.5B (3.8B active) · General	17.4GB	30.1GB	`ollama run gemma4:26b`
Google Gemma 2 27B 27.2B · General	18GB	32GB	`ollama run gemma2:27b`
Qwen3.8 27B 27.8B · General	18.2GB	31.5GB	`ollama run qwen3.8:27b`
Qwen3-Coder 30B-A3B Instruct 30.5B (3.3B active) · Coding	19.8GB	34.3GB	`ollama run qwen3-coder:30b`
Gemma 4 31B 31.3B · General	20.3GB	35.2GB	`ollama run gemma4:31b`
DeepSeek R1 Distill Qwen 32B 32.5B · Reasoning	21.5GB	38GB	`ollama run deepseek-r1:32b`
Qwen 2.5 Coder 32B Instruct 32.5B · Coding	21.5GB	38GB	`ollama run qwen2.5-coder:32b`
Cohere Command R 35B 35.0B · RAG	23GB	40GB	`ollama run command-r:35b`
Qwen3.6 35B-A3B (MoE) 36B (3B active) · General	23.1GB	40.2GB	`ollama run qwen3.6:35b`
Llama 3.3 70B Instruct 70.6B · General	42GB	78GB	`ollama run llama3.3:70b`
DeepSeek R1 Distill Llama 70B 70.6B · Reasoning	45GB	80GB	`ollama run deepseek-r1:70b`
Qwen 2.5 72B Instruct 72.7B · General	45GB	82GB	`ollama run qwen2.5:72b`
OpenAI gpt-oss-120b 116.8B (5.1B active) · Reasoning	66.5GB	125.8GB	`ollama run gpt-oss:120b`
Llama 4 Scout (17B active, 16 experts) 109B (17B active) · General	66.9GB	117.5GB	`ollama run llama4:16x17b`
DeepSeek V4-Flash 284B (13B active) · Reasoning	171.9GB	303GB	`(not in the Ollama library; use llama.cpp or vLLM)`
DeepSeek V3 671B MoE 671B (37B active) · General	400GB	740GB	`ollama run deepseek-v3:671b`

Start from your GPU instead

If you already know your card, the tier pages are the faster route — each scores every model against what a card that size realistically gives you once the display and the framework have taken their share.

Why people self-host the interface

The model running locally is only half of it. A local model reached through someone else’s front end still sends your conversations through their service; Open WebUI closes that gap by keeping the interface, the history and the uploaded documents on hardware you own. For anyone handling material they cannot paste into a hosted chat — client files, medical notes, unreleased code — that is usually the deciding factor rather than cost.

It also covers the things a bare API does not: accounts and permissions when a team shares one machine, document upload with retrieval, and per-model presets. Those are the features that make a local setup usable by people who did not build it.

Self-hosted AI: the full stack Local LLM vs Cloud API

Common questions

What is Open WebUI?: It is a self-hosted chat interface for models you are already running somewhere else. It looks and works much like a commercial chat app — conversation history, multiple models, document upload, user accounts — but it holds no model itself. It talks to a backend over HTTP, usually Ollama or anything exposing an OpenAI-compatible API, and everything stays on hardware you control.
How much VRAM does Open WebUI need?: Effectively none of its own. It is a web application — a Python backend and a browser front end — so it costs you some RAM and a container, not graphics memory. The VRAM is consumed entirely by whichever backend actually holds the model. That is why the table on this page lists model requirements rather than Open WebUI's: the question that decides what you can run is which model your GPU can hold.
Do I need Ollama to use Open WebUI?: No, though it is the most common pairing and the one the project documents most thoroughly. Open WebUI speaks the OpenAI chat-completions format, so llama.cpp's llama-server, vLLM, and hosted APIs all work as backends — and it can hold several at once, letting you switch between a local model and a remote one in the same conversation list.
Can Open WebUI run without internet access?: Yes, and that is a large part of why people choose it. Once the container image and the model weights are on the machine, the whole stack runs offline — no request leaves your network, and there is no account with a third party holding your conversation history. Features that reach outward, such as web search, are additions you enable rather than defaults.
Is Open WebUI the same as Ollama's interface?: No. Ollama ships a command line and an HTTP API; recent versions include a basic desktop app, but it is deliberately minimal. Open WebUI is a separate project that supplies the parts Ollama leaves out — persistent chat history, multiple users with permissions, document upload for retrieval, model presets. They are complements, which is why the pairing is so common.

Guides that go deeper

Setting it up, the licence catch, document chat, and the embedding models and vector stores behind it.