Open WebUI

Open WebUI (formerly Ollama WebUI) is a feature-rich web frontend for large language models. It provides a ChatGPT-like conversational experience with support for connecting to Ollama and OpenAI-compatible APIs. Features include multi-user management, conversation history, model switching, RAG document Q&A, and more, making it ideal for deploying a private AI chat platform for teams or enterprises.

Features

• Modern ChatGPT-like interface
• Multi-model switching (Ollama, OpenAI, vLLM, etc.)
• Multi-user management and access control
• Conversation history saving and search
• RAG (Retrieval-Augmented Generation) document Q&A
• Model customization and Modelfile management
• Markdown rendering and code highlighting
• Voice input and TTS support

System Requirements

• CentOS Stream 9 & 10 / AlmaLinux 9 & 10 / Rocky Linux 9 & 10
• Docker or Podman
• A deployed Ollama service or other OpenAI-compatible API (see Ollama Local LLM)

Deploy with Docker

Install Docker

If Docker is not yet installed:

Install Docker (EL 9 / EL 10)

sudo dnf install -y dnf-plugins-core
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
sudo systemctl enable --now docker
sudo usermod -aG docker $(whoami)

Log out and back in for the group change to take effect.

Deploy Open WebUI (Connecting to Local Ollama)

If Ollama is running on the same machine:

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

Visit http://your-server-ip:3000 to open the interface.

Deploy Open WebUI (Connecting to Remote Ollama)

If Ollama is running on another server:

docker run -d \
  --name open-webui \
  --restart always \
  -p 3000:8080 \
  -v open-webui-data:/app/backend/data \
  -e OLLAMA_BASE_URL=http://192.168.1.100:11434 \
  ghcr.io/open-webui/open-webui:main

Connect to an OpenAI-Compatible API (e.g., vLLM)

If using vLLM or another OpenAI API-compatible backend:

docker run -d \
  --name open-webui \
  --restart always \
  -p 3000:8080 \
  -v open-webui-data:/app/backend/data \
  -e OPENAI_API_BASE_URL=http://192.168.1.100:8000/v1 \
  -e OPENAI_API_KEY=not-needed \
  ghcr.io/open-webui/open-webui:main

Using Docker Compose

Create a docker-compose.yml file to deploy both Ollama and Open WebUI together:

mkdir -p /opt/open-webui && cd /opt/open-webui

cat > docker-compose.yml <<'EOF'
services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: always
    volumes:
      - ollama-data:/root/.ollama
    ports:
      - "11434:11434"
    # If you have a GPU, uncomment the following configuration
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    restart: always
    depends_on:
      - ollama
    ports:
      - "3000:8080"
    volumes:
      - open-webui-data:/app/backend/data
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434

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

Start the services:

docker compose up -d

Pull models in the Ollama container:

docker exec -it ollama ollama pull qwen2.5
docker exec -it ollama ollama pull llama3.1

Deploy with Podman

EL9 systems come with Podman pre-installed, so Docker is not required.

Basic Deployment

# Note: with --network=host the container uses host port 8080 directly, so `-p 3000:8080` is ignored
podman run -d \
  --name open-webui \
  --restart always \
  -v open-webui-data:/app/backend/data \
  --network=host \
  -e OLLAMA_BASE_URL=http://localhost:11434 \
  ghcr.io/open-webui/open-webui:main
# Open http://<host>:8080 (not 3000)

Note

Using --network=host allows the Podman container to directly access the host’s Ollama service without additional network configuration.

Managing Podman Containers with systemd

# Generate a systemd service file
mkdir -p ~/.config/systemd/user
# generate systemd is deprecated since Podman 4.4; new deployments should use Quadlet (see /en/containers/quadlet/)
podman generate systemd --name open-webui --new > ~/.config/systemd/user/open-webui.service

# Enable auto-start (user-level service)
systemctl --user daemon-reload
systemctl --user enable open-webui.service

# Enable lingering so the service runs even when the user is not logged in
sudo loginctl enable-linger $(whoami)

Initial Configuration

Create an Admin Account

When accessing Open WebUI for the first time, you need to register the first account. The first registered account will automatically become the administrator.

1. Open your browser and go to http://your-server-ip:3000
2. Click “Sign up” to register
3. Fill in your username, email, and password
4. You will be automatically logged in after registration

Important

Make sure to register the admin account immediately. Anyone who can access the page can register, and the first registered user will have administrator privileges.

Admin Settings

After logging in, click the avatar in the bottom-left corner to access settings.

User Management: Administrators can do the following in the Admin Panel:

• View and manage all users
• Set user registration policy (open registration / requires approval / registration closed)
• Change user roles (admin / regular user)

Admin Panel > Settings > General > Enable New Sign Ups

Model Management:

• Select which models are visible to users
• Set the default model
• Create custom models (based on Modelfile)

Connection Settings

Configure backend connections in the admin settings:

Ollama Connection:

Admin Panel > Settings > Connections > Ollama API
URL: http://host.docker.internal:11434

OpenAI API Connection:

Admin Panel > Settings > Connections > OpenAI API
URL: http://your-vllm-server:8000/v1
API Key: your-api-key

General Configuration

Environment Variables

Open WebUI supports configuration through environment variables. Here are commonly used ones:

Environment Variable	Description	Default
OLLAMA_BASE_URL	Ollama API URL	http://localhost:11434
OPENAI_API_BASE_URL	OpenAI-compatible API URL	-
OPENAI_API_KEY	OpenAI API key	-
WEBUI_AUTH	Enable authentication	true
WEBUI_SECRET_KEY	JWT secret key	Auto-generated
DEFAULT_MODELS	Default selected model	-
ENABLE_SIGNUP	Allow registration	true
ENABLE_WEB_SEARCH	Enable web search (the old ENABLE_RAG_WEB_SEARCH no longer takes effect)	false

Data Persistence

Open WebUI stores data in the /app/backend/data directory inside the container. Persist this data using Docker Volumes:

# View volume information
docker volume inspect open-webui-data

# Backup data
docker run --rm \
  -v open-webui-data:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/open-webui-backup.tar.gz -C /data .

# Restore data
docker run --rm \
  -v open-webui-data:/data \
  -v $(pwd):/backup \
  alpine tar xzf /backup/open-webui-backup.tar.gz -C /data

Updating Open WebUI

# Docker method
docker pull ghcr.io/open-webui/open-webui:main
docker stop open-webui
docker rm open-webui
# Re-run the docker run command (data is persisted via the volume)

# Docker Compose method
cd /opt/open-webui
docker compose pull
docker compose up -d

Firewall Configuration

sudo firewall-cmd --permanent --add-port=3000/tcp
sudo firewall-cmd --reload

FAQ

Cannot Connect to Ollama

Verify that the Ollama listening address is correct:

# Check if Ollama is listening
curl http://localhost:11434/api/tags

# If the Docker container cannot access the host's Ollama,
# make sure Ollama is listening on 0.0.0.0
sudo systemctl edit ollama

[Service]
Environment="OLLAMA_HOST=0.0.0.0"

sudo systemctl daemon-reload
sudo systemctl restart ollama

Container Fails to Start

# View container logs
docker logs open-webui

# Common cause: port conflict
# Change the port
docker run -d --name open-webui -p 8080:8080 ...

Forgot Admin Password

# Enter the container to reset
docker exec -it open-webui bash

# Run the reset command inside the container (specific command depends on the version)
# Or delete the volume and reinitialize (this will lose all data)
docker stop open-webui
docker rm open-webui
docker volume rm open-webui-data
# Recreate the container