Open WebUI + Ollama unter Linux: Eigene ChatGPT-Alternative lokal betreiben

Mit Ollama und Open WebUI lässt sich unter Linux eine eigene KI-Umgebung aufbauen, die optisch und vom Bedienkonzept an bekannte KI-Chats erinnert. Ollama übernimmt dabei die Ausführung und Verwaltung der Sprachmodelle. Open WebUI stellt eine moderne Weboberfläche mit Chatverläufen, Modellverwaltung und zusätzlichen KI-Funktionen bereit.

Das Spannende daran: Verwendest du ausschließlich lokale Modelle, können Anfragen direkt auf deiner eigenen Hardware verarbeitet werden. Du brauchst also nicht zwingend für jede Frage einen externen KI-Dienst.

In dieser Anleitung zeige ich dir Schritt für Schritt, wie du Open WebUI mit Ollama unter Linux installierst und deine eigene lokale ChatGPT-Alternative aufbaust.

Was sind Ollama und Open WebUI?

Zunächst müssen wir zwei Dinge unterscheiden.

Ollama: Der Motor hinter der lokalen KI

Ollama ist vereinfacht gesagt die Laufzeitumgebung für deine KI-Modelle. Ollama kümmert sich unter anderem um:

• das Herunterladen von Modellen
• das Starten von Large Language Models
• CPU- und GPU-Nutzung
• die Modellverwaltung
• eine lokale API
• die Kommunikation mit anderen Anwendungen

Die Ollama-API läuft standardmäßig lokal über Port 11434. Du kannst Ollama bereits direkt im Terminal verwenden, zum Beispiel mit ollama run gemma3. Das funktioniert – ist aber noch nicht besonders komfortabel. Genau hier kommt Open WebUI ins Spiel. Wie du Ollama unter Linux überhaupt installierst, GPU-Unterstützung einrichtest und die API nutzt, zeigt der Grundlagenartikel Ollama unter Linux installieren: KI lokal betreiben (Zum Artikel).

Open WebUI: Die grafische Oberfläche

Open WebUI ist eine selbst gehostete KI-Plattform mit Weboberfläche. Sie verbindet sich unter anderem direkt mit Ollama und kann die dort verfügbaren Modelle verwenden. Neben normalen Chat-Unterhaltungen unterstützt Open WebUI inzwischen zahlreiche zusätzliche Funktionen wie Modellverwaltung, Wissensdatenbanken, Tools und die Anbindung verschiedener externer KI-Anbieter. Wie du eine KI grundsätzlich kontrolliert an Werkzeuge und externe Dienste anbindest, erklärt MCP einfach erklärt: Was ist das Model Context Protocol? (Zum Artikel) – relevant, sobald du Open WebUI später um solche Tool-Anbindungen erweiterst.

Vereinfacht sieht die Architektur so aus:

Browser
  |
  v
Open WebUI
  |
  v
Ollama API
  |
  v
Lokales KI-Modell
  |
  v
CPU / GPU / RAM

Ollama ist also der KI-Motor – Open WebUI das Cockpit.

Ist Open WebUI + Ollama wirklich eine ChatGPT-Alternative?

Jein. Die Kombination kann sich für den Anwender ähnlich wie ChatGPT anfühlen: Chatfenster, Chatverlauf, verschiedene Modelle, Dateien und Wissen, Systemanweisungen, Benutzerverwaltung, Erweiterungen und Tools.

Technisch ist es aber kein lokaler Klon von ChatGPT. ChatGPT ist ein kompletter KI-Dienst von OpenAI mit eigenen Modellen, eigener Infrastruktur und zusätzlichen Diensten. Bei Open WebUI + Ollama entscheidest du dagegen selbst, welches Modell verwendet wird. Die Qualität deiner lokalen KI hängt deshalb stark von folgenden Faktoren ab: verwendetem Modell, Modellgröße, Quantisierung, verfügbarem RAM, GPU und VRAM, Kontextgröße, Prompt und Aufgabenstellung. Dafür erhältst du deutlich mehr Kontrolle über deine eigene Infrastruktur.

Warum sollte man KI lokal betreiben?

Lokale KI ist längst nicht mehr nur ein Experiment für Entwickler.

1. Mehr Kontrolle über Daten

Bei lokal ausgeführten Ollama-Modellen werden Prompts und Antworten lokal verarbeitet. Ollama erklärt ausdrücklich, dass bei lokal laufenden Modellen die Prompts und Daten nicht an Ollama übertragen werden. Cloud-Modelle sind davon getrennt zu betrachten.

Das kann interessant sein für interne Dokumente, Programmcode, Unternehmenswissen, IT-Dokumentationen, Protokolle, Schulungsmaterial, private Notizen sowie Tests und Entwicklung.

Dabei gilt trotzdem: Lokal bedeutet nicht automatisch DSGVO-konform oder sicher. Zugriffsrechte, Benutzerkonten, Backups, Modelllizenzen und sensible Daten müssen weiterhin sauber administriert werden.

2. Keine klassischen Kosten pro lokaler Anfrage

Bei lokal ausgeführten Modellen benötigst du keinen externen API-Aufruf für jede einzelne Anfrage. Stattdessen bezahlst du indirekt über Hardware, Strom, Speicherplatz, Administration und gegebenenfalls eine GPU. Gerade bei häufigen internen Anfragen kann das interessant sein.

3. Modelle selbst auswählen

Du bist nicht auf ein einziges Modell festgelegt. Ollama verwaltet verschiedene Modelle und Open WebUI kann diese anschließend über die Ollama-Verbindung im Modellselektor bereitstellen. Damit kannst du beispielsweise unterschiedliche Modelle für allgemeine Fragen, Programmierung, Zusammenfassungen, Analyse und Übersetzungen verwenden.

4. KI im eigenen Netzwerk

Open WebUI eignet sich nicht nur für einen einzelnen Rechner. Es kann beispielsweise zentral auf einem Linux-Server betrieben und anschließend mehreren Benutzern innerhalb eines geschützten Netzwerks zur Verfügung gestellt werden. Damit entsteht im Prinzip ein interner KI-Chat für das eigene Unternehmen.

Voraussetzungen für Open WebUI und Ollama

Für diese Anleitung eignet sich beispielsweise Ubuntu, Debian, Linux Mint oder eine andere aktuelle Linux-Distribution mit Docker. Zusätzlich benötigen wir Ollama, Docker, ausreichend Arbeitsspeicher, ausreichend freien Speicher für Modelle und optional eine NVIDIA- oder AMD-GPU.

Eine GPU ist nicht zwingend erforderlich. Auch CPUs können lokale Modelle ausführen. Größere Modelle profitieren allerdings erheblich von geeigneter GPU-Hardware.

Schritt 1: Ollama unter Linux installieren

Falls Ollama bereits installiert ist, kannst du diesen Abschnitt überspringen. Die offizielle Linux-Installation erfolgt derzeit mit:

curl -fsSL https://ollama.com/install.sh | sh
ollama -v

Die offizielle Ollama-Dokumentation nennt diesen Installationsweg weiterhin für Linux. Prüfe bei produktiven oder besonders geschützten Systemen grundsätzlich Installationsskripte, bevor du sie mit administrativen Rechten ausführst.

Ollama-Service kontrollieren

sudo systemctl status ollama
sudo systemctl start ollama
sudo systemctl enable ollama

Die systemd-Integration ist für einen dauerhaften Linux-Betrieb vorgesehen. Eine ausführliche Schritt-für-Schritt-Anleitung inklusive GPU-Unterstützung, API und Local-only-Modus findest du in Ollama unter Linux installieren: KI lokal betreiben (Zum Artikel).

Schritt 2: Ein erstes lokales KI-Modell installieren

Testen wir zunächst, ob Ollama grundsätzlich funktioniert:

ollama run gemma3

Alternativ kannst du Modelle zunächst nur herunterladen:

ollama pull gemma3

Die verfügbaren Modelle kannst du anschließend prüfen:

ollama list

Welche Modelle sich für dich eignen, hängt vor allem von deiner Hardware und deinem Einsatzzweck ab. Ein kleines Modell ist häufig die bessere Wahl für den Einstieg.

Schritt 3: Open WebUI mit Docker installieren

Open WebUI unterstützt mehrere Installationsvarianten. Die offizielle Dokumentation empfiehlt Docker für die meisten Anwender. Daneben existieren unter anderem Python- und Kubernetes-Varianten.

Das normale Open-WebUI-Container-Image lautet ghcr.io/open-webui/open-webui:main. Die Weboberfläche läuft innerhalb des Containers auf Port 8080.

Variante A: Ollama läuft direkt auf dem Linux-Host

Für einen lokalen Linux-Rechner ist eine besonders interessante Variante das Docker-Host-Netzwerk. Damit kann Open WebUI auf Ollama über dessen lokale Adresse zugreifen, ohne Ollama zwingend im gesamten LAN freigeben zu müssen.

docker run -d \
  --network=host \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://127.0.0.1:11434 \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Diese Variante wird auch in der offiziellen Open-WebUI-Dokumentation als Lösung für die Kommunikation zwischen Docker und einem auf dem Host laufenden Ollama beschrieben. Anschließend erreichst du Open WebUI unter http://localhost:8080 – oder von deinem lokalen Netzwerk aus, sofern Firewall und Netzwerkzugriff entsprechend eingerichtet wurden, über die IP-Adresse des Servers.

Variante B: Open WebUI über Port 3000 starten

Die klassische Docker-Installation sieht folgendermaßen aus:

docker run -d \
  -p 3000:8080 \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

Open WebUI erreichst du danach unter http://localhost:3000. Das Docker-Volume open-webui speichert die Daten persistent und verhindert, dass Chatverläufe und Einstellungen beim normalen Austausch des Containers verloren gehen.

Schritt 4: Ollama mit Open WebUI verbinden

Open WebUI versucht eine vorhandene Ollama-Installation automatisch zu erkennen. Du kannst die Verbindung zusätzlich über die Administration kontrollieren: Admin Settings → Connections → Ollama. Dort können Ollama-Instanzen verwaltet und Modelle eingebunden werden.

Läuft Ollama außerhalb des Open-WebUI-Containers, kann beispielsweise folgende Adresse verwendet werden:

http://host.docker.internal:11434

Bei Host-Networking verwenden wir dagegen:

http://127.0.0.1:11434

Problem: Open WebUI findet Ollama nicht

Das gehört zu den häufigsten Fehlern bei dieser Installation. Der Grund ist meistens Docker-Netzwerkisolierung. localhost innerhalb eines Containers bezeichnet zunächst den Container selbst – nicht automatisch deinen Linux-Host. Das führt schnell zu Meldungen wie Connection refused oder dazu, dass einfach keine Modelle angezeigt werden. Die offizielle Open-WebUI-Fehlerdokumentation weist ausdrücklich auf diese Netzwerkproblematik hin.

Lösung 1: Host-Netzwerk verwenden

--network=host

Dann:

OLLAMA_BASE_URL=http://127.0.0.1:11434

Für eine rein lokale Linux-Installation ist das oft eine einfache Lösung.

Lösung 2: host.docker.internal verwenden

host.docker.internal wird von Open WebUI offiziell vor allem für Docker Desktop unter macOS und Windows dokumentiert. Unter Linux kann zusätzlich ein Host-Gateway eingebunden werden, damit derselbe Name funktioniert:

--add-host=host.docker.internal:host-gateway

Anschließend kann Open WebUI Ollama über http://host.docker.internal:11434 erreichen.

Ollama nicht unnötig ins Netzwerk öffnen

Ollama bindet standardmäßig an 127.0.0.1:11434. Das ist aus Sicherheitssicht sinnvoll. Die lokale Ollama-API benötigt auf localhost:11434 keine Authentifizierung. Deshalb solltest du nicht einfach ohne weitere Schutzmaßnahmen OLLAMA_HOST=0.0.0.0 setzen und Port 11434 anschließend öffentlich freigeben. Dadurch könnte die API von anderen erreichbaren Systemen angesprochen werden. Port 11434 gehört nicht ungeschützt ins Internet.

Schritt 5: Open WebUI öffnen

Nach erfolgreichem Containerstart:

docker ps

Du solltest einen Container namens open-webui sehen. Öffne anschließend beispielsweise http://SERVER-IP:8080 oder bei der klassischen Portzuordnung http://SERVER-IP:3000. Nun erscheint die Weboberfläche.

Der erste Benutzer, der sich bei einer neuen Open-WebUI-Instanz registriert, wird Administrator. Nachfolgende Registrierungen können durch die Administration kontrolliert beziehungsweise zunächst als ausstehend behandelt werden.

Willkommen bei deiner eigenen lokalen KI

Nach der Anmeldung sollte dein Ollama-Modell im Modellselektor erscheinen. Wähle beispielsweise dein zuvor installiertes Modell aus und schreibe: Erkläre mir Docker so, dass es auch ein Anfänger versteht.

Die Anfrage läuft nun: Browser → Open WebUI → Ollama → lokales Modell → Antwort. Damit läuft dein eigener KI-Chat.

Läuft die KI jetzt wirklich vollständig lokal?

Das hängt davon ab, wie du dein System konfigurierst. Ollama unterstützt inzwischen sowohl lokale als auch optionale Cloud-Modelle. Cloud-Modelle werden nicht auf deinem Rechner ausgeführt, sondern über Ollamas Cloud-Infrastruktur verarbeitet.

Wenn du bewusst einen Local-only-Betrieb möchtest, kannst du die Cloud-Funktionen abschalten. Zum Beispiel über:

sudo systemctl edit ollama

Dann:

[Service]
Environment="OLLAMA_NO_CLOUD=1"

Danach:

sudo systemctl daemon-reload
sudo systemctl restart ollama

Ollama dokumentiert OLLAMA_NO_CLOUD=1 ausdrücklich als Möglichkeit, Cloud-Modelle und Cloud-Funktionen zu deaktivieren. Damit reduzierst du das Risiko, versehentlich ein Cloud-Modell auszuwählen.

Wie sicher ist Open WebUI?

Hier wird es besonders wichtig. Solange Open WebUI nur auf deinem Rechner oder innerhalb eines geschützten LANs läuft, ist die Situation relativ überschaubar.

Sobald du Open WebUI jedoch aus dem Internet erreichbar machen möchtest, solltest du die Anwendung wie jede andere interne Webanwendung behandeln. Die Open-WebUI-Dokumentation empfiehlt für sicherheitskritische Installationen ausdrücklich Schutz durch beispielsweise VPN, Zero-Trust-Zugriff, Reverse Proxy, IP-Allowlisting, Rate Limiting und HTTPS. Open WebUI sollte nicht einfach direkt mit offenem Port ins Internet gestellt werden. Wie du KI-Ausgaben und Systemzugriffe grundsätzlich kritisch hinterfragen solltest, bevor du sie ungeprüft übernimmst, zeigt Prompt Injection erklärt: Wie Angreifer KI-Agenten manipulieren (Zum Artikel) – relevant, sobald Open WebUI über Tools oder Wissensdatenbanken mit externen Inhalten in Kontakt kommt.

Open WebUI mit HTTPS betreiben

Für einen produktiven Server bietet sich beispielsweise folgende Architektur an:

Internet
  |
  v
HTTPS
  |
  v
Nginx / HAProxy / Caddy
  |
  v
Open WebUI
  |
  v
Ollama
  |
  v
Lokales Modell

Die Open-WebUI-Dokumentation unterstützt Reverse-Proxy-Szenarien mit unter anderem Nginx, Caddy, HAProxy sowie privaten Netzwerken und Tunnelsystemen. HTTPS schützt dabei unter anderem Chatdaten, Zugangsdaten und hochgeladene Dateien während der Übertragung.

Achtung bei WebSockets

Open WebUI verwendet WebSockets für verschiedene Echtzeitfunktionen und Streaming. Wer Open WebUI hinter Nginx, HAProxy oder einem anderen Reverse Proxy betreibt, muss deshalb sicherstellen, dass WebSocket-Verbindungen korrekt weitergereicht werden – insbesondere über korrekt gesetzte Upgrade- und Connection-Header sowie proxy_http_version 1.1 bei Nginx.

Wenn beispielsweise Antworten plötzlich hängen bleiben oder die Oberfläche ungewöhnlich reagiert, lohnt sich ein Blick auf: WebSocket-Upgrade-Header, Proxy-Konfiguration, CORS sowie die HTTP-Version zwischen Proxy und Backend. Das ist besonders bei professionellen Serverinstallationen wichtig.

Open WebUI aktualisieren

Container lassen sich relativ einfach aktualisieren. Zunächst:

docker rm -f open-webui

Danach das aktuelle Image laden:

docker pull ghcr.io/open-webui/open-webui:main

Anschließend den Container wieder mit den gleichen Parametern starten. Die Daten liegen weiterhin im Volume open-webui und bleiben deshalb beim Austausch des Containers erhalten.

Für produktive Umgebungen empfiehlt die Dokumentation außerdem, statt eines beweglichen :main-Tags eine konkrete Version zu pinnen. Dadurch werden Deployments und Rollbacks reproduzierbarer.

Ollama aktualisieren

Unter Linux lässt sich Ollama aktuell durch erneutes Ausführen des Installationsskripts aktualisieren:

curl -fsSL https://ollama.com/install.sh | sh

Das entspricht der offiziellen Linux-Anleitung. Danach:

ollama -v
sudo systemctl status ollama

Fehleranalyse bei Ollama

Falls Ollama nicht startet:

sudo systemctl status ollama

Für ausführlichere Logs:

journalctl -e -u ollama

Dieser journalctl-Befehl wird auch von Ollama für die Diagnose des systemd-Dienstes dokumentiert. Wie du solche Fehlermeldungen strukturiert mit ChatGPT analysierst, zeigt systemd-Fehler mit ChatGPT analysieren: systemctl und journalctl richtig nutzen (Zum Artikel).

Für wen lohnt sich Open WebUI + Ollama?

Privatanwender

Ideal zum Experimentieren mit lokaler KI, ohne für jede Unterhaltung zwingend einen Cloud-Anbieter verwenden zu müssen.

Entwickler

Lokale Modelle lassen sich für Programmierung, Tests, Prototyping, APIs und Automatisierungen einsetzen. Wer zusätzlich KI-gestützte Coding-Werkzeuge direkt im Terminal nutzen möchte, findet eine Anleitung in Codex CLI unter Linux installieren und richtig nutzen (Zum Artikel).

Administratoren

Spannend werden lokale KI-Systeme für Loganalysen, Dokumentationssuche, Shell-Erklärungen, interne Wissensdatenbanken und Support. Natürlich sollten Passwörter, Secrets, produktive Zugangsdaten und sensible Logs auch einer lokalen KI nicht ungeprüft übergeben werden.

Unternehmen

Eine zentrale Open-WebUI-Installation kann als interne KI-Plattform dienen. Open WebUI unterstützt neben einzelnen Nutzern auch umfangreichere Benutzer- und Teamfunktionen. Damit kann eine Organisation eine eigene KI-Infrastruktur aufbauen, statt jeden Mitarbeiter einzeln verschiedene KI-Dienste verwenden zu lassen.

Open WebUI + Ollama vs. ChatGPT

Die Systeme verfolgen also unterschiedliche Konzepte. ChatGPT ist ein fertiger Cloud-KI-Dienst. Open WebUI + Ollama ist eine selbst betriebene KI-Plattform.

Was ist besser?

Das hängt vom Einsatzzweck ab. Cloud-KI ist besonders praktisch, wenn du sofort starten möchtest, keine eigene Hardware betreiben willst, sehr leistungsfähige Modelle benötigst und dich nicht um Updates und Server kümmern möchtest.

Lokale KI ist interessant, wenn du mehr Kontrolle über deine Daten möchtest, eigene Infrastruktur besitzt, offline arbeiten willst, Modelle testen möchtest, interne KI-Dienste bereitstellen willst und Cloud-Abhängigkeiten reduzieren möchtest.

In vielen professionellen Umgebungen wird langfristig vermutlich nicht lokal oder Cloud, sondern ein kontrollierter Hybridansatz interessant sein.

Eine eigene KI ist einfacher geworden

Noch vor wenigen Jahren war das lokale Ausführen eines Large Language Models ein Projekt für Spezialisten. Heute reichen für den Einstieg im Grunde: Linux, Ollama, Open WebUI und ein geeignetes Modell.

Aus einem gewöhnlichen Linux-Rechner kann damit eine erstaunlich leistungsfähige lokale KI-Workstation werden. Und aus einem Linux-Server kann eine zentrale interne KI-Plattform entstehen.

Fazit: Open WebUI und Ollama machen lokale KI alltagstauglich

Open WebUI und Ollama gehören aktuell zu den interessantesten Kombinationen für Menschen, die generative KI auf eigener Linux-Hardware betreiben möchten.

Ollama kümmert sich um die Modelle. Open WebUI liefert die komfortable Oberfläche. Docker vereinfacht Installation und Updates. Und mit geeigneter Netzwerk- und Sicherheitskonfiguration lässt sich daraus weit mehr als ein kleines KI-Experiment bauen.

Wer zunächst nur lokale Modelle nutzt, kann einen persönlichen KI-Assistenten auf dem eigenen Rechner betreiben. Wer später weitergehen möchte, kann daraus eine interne KI-Plattform mit mehreren Nutzern, Wissensdatenbanken, APIs und zusätzlichen Werkzeugen entwickeln.

Lokale KI bedeutet damit nicht mehr zwingend komplizierte Forschung – sie wird zunehmend zu ganz normaler IT-Infrastruktur.

Häufige Fragen zu Open WebUI und Ollama unter Linux

Was ist Open WebUI?

Open WebUI ist eine selbst gehostete Webplattform für KI-Modelle. Sie kann unter anderem direkt mit Ollama und OpenAI-kompatiblen APIs kommunizieren.

Was ist Ollama?

Ollama ist eine Laufzeitumgebung, mit der verschiedene KI-Sprachmodelle lokal ausgeführt und über CLI oder API verwendet werden können.

Kann ich mit Ollama eine eigene ChatGPT-Alternative betreiben?

Ja. In Kombination mit einer Oberfläche wie Open WebUI entsteht ein Chat-System, das vom Bedienkonzept an bekannte KI-Chats erinnert. Es verwendet allerdings nicht automatisch dieselben Modelle oder Funktionen wie ChatGPT.

Brauche ich eine GPU für Ollama?

Nein. Lokale Modelle können auch über die CPU laufen. Eine geeignete GPU kann die Ausführung jedoch deutlich beschleunigen.

Läuft Open WebUI vollständig lokal?

Open WebUI kann vollständig in deiner eigenen Infrastruktur betrieben werden. Ob die KI-Verarbeitung ebenfalls lokal bleibt, hängt vom verwendeten Modell und den konfigurierten Providern ab.

Kann ich Ollama ohne Internet verwenden?

Bereits heruntergeladene lokale Modelle können lokal verwendet werden. Downloads, Updates und Cloud-Funktionen benötigen eine Internetverbindung. Cloud-Funktionen können mit OLLAMA_NO_CLOUD=1 deaktiviert werden.

Welchen Port verwendet Ollama?

Ollama verwendet standardmäßig Port 11434 und bindet lokal an 127.0.0.1.

Welchen Port verwendet Open WebUI?

Open WebUI verwendet innerhalb des offiziellen Docker-Containers Port 8080. Dieser kann beispielsweise als Port 3000 auf dem Host veröffentlicht werden.

Weiterführende Themen

Ollama unter Linux installieren: KI lokal betreiben (Zum Artikel)

MCP einfach erklärt: Was ist das Model Context Protocol? (Zum Artikel)

Prompt Injection erklärt: Wie Angreifer KI-Agenten manipulieren (Zum Artikel)

Codex CLI unter Linux installieren und richtig nutzen (Zum Artikel)

systemd-Fehler mit ChatGPT analysieren: systemctl und journalctl richtig nutzen (Zum Artikel)

Quellen und Aktualität: Stand des Artikels: August 2026. Für die technische Prüfung wurden insbesondere die aktuellen offiziellen Dokumentationen von Ollama und Open WebUI herangezogen, darunter die Hinweise zu Docker-Installation, Netzwerkverbindung zwischen Container und Host, HTTPS-Reverse-Proxy-Betrieb und WebSocket-Konfiguration.