Home » Blog » OpenWebUI Docker Setup: A Comprehensive Guide

Information

OpenWebUI Docker Setup: A Comprehensive Guide

Benhcmark Administrator

12/08/2025

2 Views 0

SaveSavedRemoved 0

Your Ultimate Guide to Installing OpenWebUI with Docker

Running your own powerful AI models locally is no longer a far-fetched dream. Thanks to tools like OpenWebUI and Docker, you can set up a private, customizable, and feature-rich chat interface for Large Language Models (LLMs) right on your own hardware. This approach gives you complete control over your data and conversations, free from third-party monitoring.

This guide will walk you through the entire process of setting up OpenWebUI using Docker. We’ll cover everything from the basic installation to advanced configurations like GPU acceleration and using Docker Compose for a more robust deployment.

What is OpenWebUI?

OpenWebUI is a user-friendly and extensible web interface for interacting with LLMs like Llama 3, Mistral, and many others. It’s designed to work seamlessly with Ollama, a popular tool for running these models locally. Think of it as your personal ChatGPT-style interface, but one that runs entirely on your own machine.

Prerequisites

Before we begin, ensure you have the following installed and ready:

• Docker: You’ll need Docker or Docker Desktop installed on your system (Windows, macOS, or Linux). This is the containerization platform we’ll use to run OpenWebUI.
• Ollama: Ollama must be installed and running on your machine. This tool manages the download and execution of the actual AI models.
• (Optional but Recommended) An NVIDIA GPU: For significantly faster response times, an NVIDIA graphics card with the appropriate drivers and the NVIDIA Container Toolkit installed is highly recommended.

Step 1: Install Ollama and Download an AI Model

If you haven’t already, the first step is to get Ollama running. It’s the engine that powers the AI models OpenWebUI will interact with.

1. Install Ollama: Visit the official Ollama website and follow the simple installation instructions for your operating system.

2. Download a Model: Once Ollama is running, you need to download an LLM. Open your terminal or command prompt and pull a model. Llama 3 is an excellent starting point.

   ollama pull llama3
   

You can replace llama3 with any other model you’d like to try, such as mistral or phi3.

Step 2: Basic OpenWebUI Installation with Docker

With your AI model ready, it’s time to launch the OpenWebUI interface. The simplest method is using a single docker run command.

This command tells Docker to download the OpenWebUI image and run it in a container, connecting it to your host system’s network so it can communicate with the Ollama service.

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

Let’s break down this command:

• -d: Runs the container in detached mode (in the background).
• -p 3000:8080: Maps port 3000 on your local machine to port 8080 inside the container. You’ll access the UI via http://localhost:3000.
• --add-host=host.docker.internal:host-gateway: A crucial step that allows the container to find and communicate with the Ollama service running on your host machine.
• --name open-webui: Assigns a convenient name to your container.
• -v open-webui:/app/backend/data: Creates a Docker volume to persist your OpenWebUI data, like user accounts and chat history.
• ghcr.io/open-webui/open-webui:main: The official OpenWebUI Docker image.

After running this command, wait a minute or two for the container to start. Then, open your web browser and navigate to http://localhost:3000. You’ll be prompted to create your first admin account.

Step 3: Enabling GPU Acceleration (For NVIDIA Users)

To unlock the full potential of your hardware, you’ll want to give OpenWebUI access to your GPU. This dramatically speeds up model inference, making your conversations much faster.

Ensure you have the NVIDIA Container Toolkit installed first. Then, stop and remove the previous container before running the new, GPU-enabled command.

1. Stop and Remove the Old Container:

   docker stop open-webui
   docker rm open-webui
   

2. Run with GPU Support:
   The command is very similar, but with the addition of the --gpus=all flag.

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

This single flag tells Docker to pass your NVIDIA GPU(s) through to the container, allowing OpenWebUI and Ollama to leverage them for processing.

Step 4: A More Robust Setup with Docker Compose

For a more manageable and reproducible setup, using Docker Compose is the recommended approach. It allows you to define your entire application stack—including Ollama and OpenWebUI—in a single configuration file.

Create a file named docker-compose.yml and paste the following content into it. This example defines services for both OpenWebUI and Ollama, complete with GPU support and persistent data volumes.

version: '3.8'

services:
  ollama:
    image: ollama/ollama
    container_name: ollama
    volumes:
      - ollama:/root/.ollama
    ports:
      - "11434:11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    networks:
      - ai-network

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    depends_on:
      - ollama
    ports:
      - "3000:8080"
    environment:
      - 'OLLAMA_BASE_URL=http://ollama:11434'
    volumes:
      - open-webui:/app/backend/data
    networks:
      - ai-network
    extra_hosts:
      - "host.docker.internal:host-gateway"

volumes:
  ollama:
  open-webui:

networks:
  ai-network:
    driver: bridge

To launch everything, navigate to the directory containing your docker-compose.yml file in your terminal and run:

docker-compose up -d

This command will create and start both the Ollama and OpenWebUI containers in the correct order. You can access the web interface at http://localhost:3000 as before.

Security and Best Practices

Running your own AI service is powerful, but it’s essential to keep it secure.

• Avoid Exposing to the Internet: By default, this setup is only accessible on your local machine. Do not expose these ports directly to the internet without placing them behind a secure reverse proxy like Nginx or Traefik.
• Use Strong Passwords: When you create your admin account in OpenWebUI, use a strong, unique password.
• Keep Software Updated: Regularly update Docker, the OpenWebUI image, and your Ollama models to benefit from the latest features and security patches. You can update your Docker images by running docker pull for the respective image followed by restarting the container.

By following this guide, you have successfully deployed a private, high-performance AI chat environment. You are now in full control, ready to explore the rapidly evolving world of local Large Language Models.

Source: https://centlinux.com/openwebui-docker/