Open WebUI: ChatGPT Alternative for Local AI

What this article covers

• What Open WebUI is and how it gives you a ChatGPT-like interface for local models
• How to install Open WebUI with Docker or without Docker, and connect it to Ollama
• What features Open WebUI offers, from chat to RAG to multi-user management
• How to upload documents and chat with your own knowledge (RAG)
• Common pitfalls and how to avoid typical issues

Introduction: Understanding Open WebUI

Once you start working with local AI, a question surfaces quickly: how do I actually talk to my models? Ollama comes with a command-line tool, but that gets tedious fast. You want an interface that feels like ChatGPT, except everything runs on your own machine.

This is where Open WebUI comes in. It’s a web interface you can run locally, letting you communicate with models running through Ollama or other backends. You open your browser, pick a model, ask your question, and get an answer. Everything stays on your hardware.

In this article, you’ll learn what Open WebUI can do, how to install it, and which features make working with local AI easier. If you’re new to the topic, start with our guide on What is local AI?

Why do you need Open WebUI?

Picture this: you have Ollama installed and a model loaded. You open the terminal, type a command, and start chatting. It works, but there are limits. You can’t upload documents, save conversations, or give other people access.

But maybe you want this:

• An interface that looks and works like ChatGPT
• Save conversations, find them again, and pick up where you left off
• Upload documents and ask questions about them
• Give family or team members access without everyone needing to use the command line
• Use and compare different models side by side

Open WebUI solves all of this. It runs in your browser, looks familiar, and comes with features you know from commercial services. The difference: your data never leaves your machine.

For more background, check out our overview of Local AI Software.

Open WebUI in brief

Open WebUI is a self-hosted web interface for local language models. It connects to backends like Ollama and gives you a chat interface that closely resembles ChatGPT. Install it once, open it in your browser, and you’re ready to go.

Key features:

• Self-hosted: You run it on your computer or server
• Browser-based: No separate app needed, just a browser window
• Multi-backend: Works with Ollama, OpenAI-compatible APIs, and other backends
• Multi-user: Multiple people can use it simultaneously with roles and permissions
• RAG-capable: Upload documents and ask questions about them

If you’re not familiar with Ollama yet, read our guide on Ollama first.

Who is Open WebUI for?

Open WebUI serves several groups:

• Individual users who want to work with models locally without touching the command line
• Families who want a shared AI assistant without sending data to the cloud
• Teams and small businesses who want to provide multiple models centrally and control access
• Developers who need an interface to test and compare models
• Self-hosters who want to add an AI interface to their infrastructure

You don’t need prior knowledge. If you use Docker, installation takes a few minutes. Learn the basics in our article on Docker Basics.

Key terms around Open WebUI

Term	Explanation
Open WebUI	Web interface for local language models, self-hosted
Ollama	Backend that loads and runs models, which Open WebUI communicates with
Docker	Container technology to run Open WebUI in isolation
RAG	Retrieval-Augmented Generation, ask questions about your own documents
Multi-User	Multiple user accounts with roles and permissions in one installation
WebUI	Web-based user interface, accessible in the browser
Pipeline	Function to preprocess or postprocess requests
Model Selector	Dropdown field to switch the active model
System Prompt	Instruction that controls the model’s behavior
Authentication	Login with user account, protects access

Installation with Docker

The easiest way is to install via Docker. You’ll need Docker and Ollama on your machine. If you don’t have Ollama yet, our guide on Ollama with Docker can help.

One command is enough to start Open WebUI:

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

What each flag does:

• -d: Container runs in the background
• -p 3000:8080: Port 3000 on your machine maps to port 8080 in the container
• --add-host=host.docker.internal:host-gateway: Lets the container reach Ollama on the host
• -v open-webui:/app/backend/data: Preserves data like conversations and accounts
• --restart always: Container starts automatically after a reboot

After that, open http://localhost:3000 in your browser. If Ollama is running, Open WebUI connects automatically.

If Ollama should be accessible over the network, check our guide on Ollama Network Access.

Installation without Docker

If you prefer not to use Docker, you can install Open WebUI directly from source. You’ll need Python, Node.js, and Git.

Steps:

git clone https://github.com/open-webui/open-webui.git
cd open-webui

Install and start the backend:

cd backend
pip install -r requirements.txt
python -m uvicorn main:app --host 0.0.0.0 --port 8080

Build the frontend:

cd ../frontend
npm install
npm run build

This approach is more involved and better suited for developers who want to customize things. For regular operation, Docker is recommended.

Getting started

After installation, follow these steps:

1. Create an admin account: When you first open Open WebUI, it asks for a name, email, and password. The first account automatically becomes admin.
2. Connect to Ollama: By default, Open WebUI connects to Ollama at localhost:11434. If Ollama runs elsewhere, enter the address in settings.
3. Pick a model: In the Model Selector at the top, choose a model available in Ollama. If none appear, download one first, for example with ollama pull llama3.1.
4. Start chatting: Click “New Chat”, ask your question, and go.

That’s it. From here, conversations work like ChatGPT, except everything happens locally.

Features at a Glance

Open WebUI comes packed with capabilities that go beyond basic chatting:

• Chat: Multiple conversations at once, saved and searchable
• RAG with Documents: Upload files and ask targeted questions about them
• Web Search: Augment requests with results from the internet
• Model Management: Download, delete, and compare models
• Multi-User: Multiple accounts with roles like Admin, User, and Guest
• Permissions: Control who can view, download, or delete models
• System Prompts: Create templates for recurring instructions
• Pipelines: Add custom processing steps before or after model inference
• API: Open WebUI exposes an API for integrating it into other tools

For a deeper dive into RAG, check out our article Local RAG.

RAG in Open WebUI

RAG stands for Retrieval-Augmented Generation. In short: you feed the model your own documents so it can answer questions about them without having learned that information beforehand.

In Open WebUI, it works like this:

1. Open an existing chat or create a new one.
2. Click the plus icon or drag a file into the window.
3. Open WebUI processes the file and stores it as a knowledge base.
4. Ask your question. The model searches your documents for relevant passages and builds its response around them.

Supported formats include PDF, text files, Markdown, and more. The nice part: you can combine multiple documents in a single conversation and ask questions that span all of them.

A typical use case: upload a manual and ask how a specific feature works. The model finds the relevant section and quotes it in the answer.

Multi-User and Permissions

Open WebUI isn’t just for solo users. You can create multiple accounts and control access.

Here’s an overview of the roles:

• Admin: Full access, can create users, manage models, change settings
• User: Can chat, upload documents, manage own conversations
• Guest: Limited access, often read-only or chat without saving

As an admin, you set in the settings whether new users can self-register or if you add them manually. You also control which models are visible to which role and whether users can download models.

For families or teams, this is handy: everyone gets their own account, conversations stay separate, and you keep control of the infrastructure.

From a security standpoint, make sure Open WebUI isn’t exposed to the internet without protection. More on that in our article Network Security.

Open WebUI vs. LM Studio vs. Ollama

These three tools are often compared but serve different purposes:

Feature	Open WebUI	LM Studio	Ollama
Type	Web interface	Desktop app	Backend / CLI
Multi-User	Yes	No	No
RAG built-in	Yes	Limited	No
Browser-based	Yes	No	No
Docker support	Yes	No	Yes
Model selection	Via backends	Own management	Own management
Target audience	Teams, families	Single users	Developers, tinkerers

In short: Ollama is the backend that runs models. LM Studio is a desktop app for individual users. Open WebUI is the web interface that manages multiple users and works well for server deployments.

Example: Setting Up Open WebUI with Ollama

Here’s a complete workflow from scratch to your first chat:

1. Install Ollama: Download and install Ollama. Check it works with ollama --version.
2. Pull a Model: Run ollama pull llama3.1 to download a model.
3. Start Docker: Execute the docker run command from the “Installation with Docker” section.
4. Open Browser: Go to http://localhost:3000.
5. Create Admin Account: Enter your name, email, and password.
6. Select Model: Choose “llama3.1” from the Model Selector at the top.
7. Ask a Question: Click “New Chat” and start.

The whole process takes about 10 to 15 minutes depending on your internet connection and hardware.

Common Pitfalls with Open WebUI

Open WebUI usually runs smoothly, but a few things come up regularly:

1. Ollama Not Found: When Open WebUI and Ollama run in separate containers, the network address often doesn’t resolve correctly. Check whether host.docker.internal is working.
2. Models Don’t Appear: You must download models with ollama pull before they show up in the Model Selector.
3. Port Conflicts: Port 3000 is sometimes already in use. Change the port in the docker run command, for example to -p 8080:8080.
4. Data Loss After Updates: Without volume mapping, all conversations disappear after a restart. The -v parameter in the Docker command is essential.
5. RAG Produces Poor Results: Large documents get split into chunks. If chunks are too small, context gets lost. Experiment with RAG settings in the options.
6. Forgot Admin Password: There’s no simple password reset button. You’ll need to access the database or reinstall.
7. Performance Issues: With many concurrent users, hardware becomes the bottleneck. Ollama and Open WebUI share GPU and RAM.
8. Updates Fail: Docker images get updated regularly. Pull the latest image with docker pull and restart the container.

Hardware, Costs, and Security with Open WebUI

Hardware: Open WebUI itself uses minimal resources. The load comes from Ollama and the models. Small models work on any regular computer; larger models benefit from a GPU with sufficient VRAM. As a rule of thumb: 8 GB VRAM for models up to 8 billion parameters, more for larger ones.

Costs: Open WebUI is open source and free. You pay nothing for the software itself. Costs only arise from hardware upgrades if needed and electricity.

Security: Since everything runs locally, your data stays on your machine. That’s a big advantage over cloud services. Still keep these in mind:

• Don’t expose Open WebUI to the network without authentication
• Use a reverse proxy with HTTPS if you want to access it remotely
• Keep the software up to date to patch security vulnerabilities
• Separate user accounts cleanly, especially in team settings

Further Links and Info About Open WebUI

• Open WebUI on GitHub
• Official Documentation
• Ollama on BotServ.de
• Ollama with Docker on BotServ.de
• Local RAG on BotServ.de
• Docker Basics on BotServ.de

FAQ: Open WebUI - Common Questions

Is Open WebUI free? Yes, Open WebUI is open source and free. You pay nothing for the software, only for the hardware it runs on.

Do I need Ollama for Open WebUI? Not necessarily. Open WebUI also supports OpenAI-compatible APIs and other backends. Ollama is the most common and easiest choice for local models.

Can I install Open WebUI without Docker? Yes, you can install it directly from source. That requires Python and Node.js and is more involved than the Docker approach.

Does Open WebUI work on a Raspberry Pi? In theory yes, but a Raspberry Pi’s hardware is too weak for larger models. For small models and testing, it’s possible.

Can I use multiple models at the same time? Yes, you can switch between them anytime in the Model Selector. Within a conversation, you can also compare models by sending the same question to multiple ones.

How does Open WebUI save my conversations? Conversations are stored in a database located in the Docker volume. As long as the volume persists, your chats remain.

Can I upload documents and ask questions about them? Yes, that’s the RAG feature. You upload documents and ask questions that the model answers based on your files.

Is Open WebUI safe for multiple users? Yes, if you keep authentication enabled and separate roles cleanly. Just don’t expose it to the open internet without protection.

Do I need a GPU? Small models run fine on a CPU. For smooth work with larger models, a GPU is recommended.

Can I connect Open WebUI to cloud services? Yes, you can add OpenAI-compatible APIs as a backend. But then requests go through the cloud service and your data leaves your machine.

How do I update Open WebUI? With Docker, pull the latest image with docker pull ghcr.io/open-webui/open-webui:main and restart the container. Your volume keeps your data intact.

Sources and Further Reading

• Open WebUI Documentation: https://docs.openwebui.com/
• Open WebUI GitHub Repository: https://github.com/open-webui/open-webui
• Ollama Documentation: https://ollama.com/
• More articles on BotServ.de: Local AI Software, What is Local AI?