Open WebUI installieren: Deine eigene ChatGPT-Alternative mit Docker und Ollama
Lerne, wie du Open WebUI mit Docker und Ollama auf deinem eigenen Server installierst, um eine private und leistungsstarke ChatGPT-Alternative zu erstellen. Schritt-für-Schritt-Anleitung.

Inhaltsverzeichnis
- Warum überhaupt Open WebUI? Die Kontrolle zurückgewinnen
- Voraussetzungen: Die richtige Hardware für deine lokale KI
- Schritt 1: Server vorbereiten und Docker installieren
- Schritt 2: Open WebUI und Ollama mit Docker installieren
- Schritt 3: Erster Login und das richtige Modell finden
- Fazit: Deine eigene KI-Plattform
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 Port8080
frei, um auf die Web UI zugreifen zu können.volumes
: Wir erstellen die Ordnerdata
undollama
, 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.
- Gehe in die Administrationseinstellungen (Klick auf deinen Namen oben rechts).
- Wähle “Einstellungen” -> “Modelle”.
- Klicke auf “Modelle verwalten”.
- Gib den Namen eines Modells von ollama.com/library ein (z.B.
llama3.1
oderdeepseek-r1:8b
) und klicke auf “Download”.
CAUTION
Achte darauf, dass du genügend Speicherplatz auf deinem Server hast (df -h
). Große Modelle können schnell mehrere Gigabyte belegen. Der
RAM
-Verbrauch steigt ebenfalls stark an, wenn ein Modell geladen wird.
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.
- API-Schlüssel erstellen: Erstelle ein Konto auf OpenRouter.ai, lade bei Bedarf Guthaben auf und generiere einen neuen API-Schlüssel.
- 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.
FAQs
Welche Hardware brauche ich wirklich, um Open WebUI zu hosten?
Das hängt stark davon ab, was du vorhast. Wenn du Open WebUI nur als schicke Oberfläche für externe APIs wie OpenAI oder OpenRouter nutzen willst, reicht ein kleiner Server mit 2 CPU-Kernen und 2-4 GB RAM völlig aus. Sobald du aber lokale Modelle mit Ollama betreiben willst, wird der Arbeitsspeicher (RAM) zum wichtigsten Faktor. Für kleine Modelle (z.B. 3B Parameter) sind 8 GB RAM das Minimum, für mittlere (7-13B) solltest du 16-32 GB einplanen. Eine NVIDIA-GPU beschleunigt die Antwortzeiten enorm, ist aber für den Einstieg nicht zwingend notwendig.
Kann ich Open WebUI auch ohne Docker installieren?
Ja, eine Installation ohne Docker ist möglich, zum Beispiel mit Conda und pip. Die Anleitung dafür findest du in der offiziellen Dokumentation. Diese Methode erfordert jedoch mehr manuelle Schritte, z.B. bei der Einrichtung von Python-Umgebungen und der Verwaltung des Frontends mit Node.js. Für die meisten Benutzer ist die Installation mit Docker deutlich einfacher und wartungsärmer.
Wie aktualisiere ich Open WebUI und Ollama?
Dank Docker ist das Update unkompliziert. Navigiere im Terminal in dein `open-webui`-Verzeichnis und führe `sudo docker compose pull` aus. Dieser Befehl lädt die neuesten Images für alle Dienste herunter. Danach startest du die Container mit `sudo docker compose down && sudo docker compose up -d` neu. Es ist ratsam, vorher in die Release Notes auf GitHub zu schauen, um über mögliche Änderungen informiert zu sein.
Was ist der Unterschied zwischen Open WebUI und Ollama?
Man kann es sich so vorstellen: Ollama ist der Motor, der die LLMs (Large Language Models) antreibt. Es ist das Backend, das die Sprachmodelle lädt und die Rechenarbeit leistet. Open WebUI ist die Karosserie und das Cockpit – eine benutzerfreundliche Web UI, über die du mit dem Motor interagierst. Du kannst Ollama auch ohne Open WebUI über das Terminal nutzen, aber Open WebUI macht die Verwaltung und den Chat mit mehreren KI-Modellen deutlich komfortabler.