Open WebUI installieren: ChatGPT-Alternative mit Docker

Stell dir vor, du hättest eine private, leistungsstarke KI-Oberfläche, die so elegant aussieht wie ChatGPT, aber zu 100 % unter deiner Kontrolle auf deinem eigenen Homeserver läuft. Genau das ist Open WebUI. Alle Daten bleiben lokal, es gibt keine externen Abhängigkeiten und nichts verlässt deinen Server. Du kannst hier beliebige Open-Source-Sprachmodelle wie Llama, Mistral oder Deepseek nutzen – komplett offline und privat.

Damit das reibungslos klappt, zeige ich dir, wie du Open WebUI mit Docker installieren und mit Ollama verbinden kannst, um deine eigene KI-Plattform zu hosten.

Warum überhaupt Open WebUI? Die Kontrolle zurückgewinnen

Die großen Sprachmodelle sind faszinierend, aber sie kommen mit einem Kompromiss: Man gibt die Kontrolle über seine Daten ab. Open WebUI ist die Antwort darauf. Da es sich um Open-Source handelt, hast du volle Transparenz und die Gewissheit, dass deine Gespräche privat bleiben.

Open WebUI bietet eine elegante Benutzeroberfläche für verschiedene LLMs (Large Language Models). Du kannst:

• Lokale Modelle über Ollama nutzen.
• Mehrere KI-Modelle parallel vergleichen.
• Dokumente hochladen und direkt im Chat damit arbeiten.
• Die Weboberfläche an deine Bedürfnisse anpassen.

Voraussetzungen: Die richtige Hardware für deine lokale KI

Für den Start brauchen wir zunächst einmal einen Server. Auf deinem Server brauchst du ein Linux-Betriebssystem. Ich arbeite in diesem Tutorial mit Ubuntu, aber die Schritte sind für andere Distributionen nahezu identisch.

Hier entscheidet sich, wie leistungsfähig deine KI-Oberfläche am Ende sein wird:

• Ohne lokale Modelle (nur API-Nutzung): Wenn du Open WebUI lediglich als Frontend für externe Dienste wie die API von OpenAI oder OpenRouter verwendest, reichen 2 GB RAM und zwei CPU-Kerne.
• Mit lokalen Modellen (Ollama): Hier ist der Arbeitsspeicher der begrenzende Faktor. Jedes Sprachmodell, das du verwenden möchtest, muss komplett in den RAM geladen werden.
• Grafikkarte (GPU): Für eine flüssige Inferenz empfiehlt sich eine CUDA-fähige NVIDIA-GPU. Ohne GPU funktioniert die Verarbeitung zwar auch, aber du musst mit spürbar längeren Wartezeiten rechnen.

Ich nutze für dieses Tutorial einen VPS bei Hetzner. Falls du mehr zur Einrichtung deines ersten VPS erfahren möchtest, findest du hier eine ausführliche Anleitung.

Schritt 1: Server vorbereiten und Docker installieren

Nachdem du deinen Server erstellt hast, verbinde dich per SSH. Zuerst legen wir einen neuen Benutzer an und geben ihm sudo-Rechte.

# Auf dem Server ausführen
adduser deployn
usermod -aG sudo deployn
exit

Jetzt verbinden wir uns erneut mit dem neuen Benutzer und bringen das System auf den neuesten Stand.

ssh deployn@DEINE_SERVER_IP
sudo apt update && sudo apt upgrade -y

Nun müssen wir Docker installieren. Der einfachste Weg auf Ubuntu ist über das offizielle apt-Repository.

# Docker-Abhängigkeiten installieren
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Repository hinzufügen
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

# Docker Engine installieren
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Wir überprüfen die Installation von Docker mit docker --version und docker compose version.

Schritt 2: Open WebUI und Ollama mit Docker installieren

Jetzt geht es darum, Open WebUI in möglichst kurzer Zeit zum Laufen zu bringen. Dafür nutzen wir Docker Compose.

Verzeichnisstruktur anlegen

Damit die Projektdaten übersichtlich bleiben, lege ich einen neuen Ordner im Home-Verzeichnis an.

# Verzeichnis erstellen und hineinwechseln
mkdir open-webui && cd open-webui

# Notwendige Unterverzeichnisse für persistente Daten erstellen
mkdir data ollama

Die compose.yaml für Ollama und Open WebUI

Wir erstellen die zentrale compose.yaml-Datei. Diese beschreibt, welche Dienste Docker starten soll.

nano compose.yaml

Füge folgenden Inhalt ein. Diese Konfiguration startet sowohl die Benutzeroberfläche (open-webui) als auch den Backend-Dienst für die Modelle (ollama).

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

    ollama:
        image: ollama/ollama:0.9.6
        container_name: ollama
        volumes:
            - ./ollama:/root/.ollama
        # Wenn du eine NVIDIA GPU hast, kommentiere die folgenden Zeilen aus
        # deploy:
        #   resources:
        #     reservations:
        #       devices:
        #         - driver: nvidia
        #           count: 1
        #           capabilities: [gpu]
        restart: unless-stopped

Erläuterung der Konfiguration:

• image: Wir verwenden spezifische Versionen, um die Nachvollziehbarkeit zu gewährleisten. Du kannst die neueste Version auf Docker Hub (Ollama) und GitHub (Open WebUI) finden.
• ports: Wir geben Port 8080 frei, um auf die Web UI zugreifen zu können.
• volumes: Wir erstellen die Ordner data und ollama, um die Konfiguration und die heruntergeladenen Modelle dauerhaft zu speichern.
• environment: Hier teilen wir Open WebUI mit, wo es den Ollama-Dienst findet.

Container starten

Jetzt starten wir die Anwendung mit dem Befehl sudo docker compose up -d.

sudo docker compose up -d

Der Parameter -d sorgt dafür, dass die Befehle im Hintergrund ausgeführt werden. Docker lädt nun die Images herunter, was beim ersten Mal ein paar Minuten dauern kann. Mit sudo docker ps kannst du überprüfen, ob die Container laufen.

Schritt 3: Erster Login und das richtige Modell finden

Wenn alles läuft, kannst du die Weboberfläche im Webbrowser erreichen (http://DEINE_SERVER_IP:8080).

Erstelle dein Administratorkonto. Nach dem Login ist die Benutzeroberfläche noch leer. Wir müssen zuerst ein Sprachmodell installieren.

1. Gehe in die Administrationseinstellungen (Klick auf deinen Namen oben rechts).
2. Wähle “Einstellungen” -> “Modelle”.
3. Klicke auf “Modelle verwalten”.
4. Gib den Namen eines Modells von ollama.com/library ein (z.B. llama3.1 oder deepseek-r1:8b) und klicke auf “Download”.

Das Modell wird nun automatisch heruntergeladen. Danach kannst du es im Chat-Fenster auswählen.

Die flexibelste Lösung: Externe APIs mit OpenRouter

Falls deine Hardware für große LLMs nicht ausreicht, gibt es eine elegante Lösung: Open WebUI kann als zentrale Oberfläche für externe, leistungsstarke KI-Modelle dienen. Der Schlüssel dazu ist die Integration von OpenRouter.ai.

1. API-Schlüssel erstellen: Erstelle ein Konto auf OpenRouter.ai, lade bei Bedarf Guthaben auf und generiere einen neuen API-Schlüssel.
2. Verbindung in Open WebUI hinzufügen:
   • Gehe in Open WebUI zu “Administration” -> “Einstellungen” -> “Verbindungen”.
   • Klicke auf “Verbindung hinzufügen”.
   • Trage die Basis-URL von OpenRouter ein: https://openrouter.ai/api/v1.
   • Füge deinen API-Schlüssel ein und speichere.

Nach dem Speichern siehst du unter “Modell auswählen” eine riesige Liste externer Modelle. Du kannst nun nahtlos zwischen deinen lokalen Modellen und den leistungsstarken externen Modellen wechseln, ohne die Benutzeroberfläche zu verlassen. Das ist die ultimative Flexibilität.

Fazit: Deine eigene KI-Plattform

Herzlichen Glückwunsch! Du hast erfolgreich Open WebUI mit Docker installiert und bist nun in der Lage, deine eigene KI zu hosten. Die Kombination aus Ollama und Open WebUI ist eine mächtige, flexible Alternative zu kommerziellen Diensten.

Du hast jetzt die volle Kontrolle. Experimentiere mit den verfügbaren Modelle, passe die Oberfläche an und entdecke die Welt der lokalen KI-Modelle auf deinem eigenen Server.