Eine lokale ChatGPT-Alternative selbst hosten: Komplett offline mit Open WebUI und Ollama

Artikel-Übersicht

In diesem Leitfaden baust du dir deine eigene ChatGPT-Alternative, die komplett auf deinem eigenen Rechner läuft – ohne Cloud, ohne monatliches Abo und ohne dass deine Daten irgendein Rechenzentrum auf der anderen Seite des Atlantiks zu sehen bekommen. Wir starten mit der Frage, warum sich der Aufwand überhaupt lohnt: Datenschutz und DSGVO, Kostenkontrolle und echte Unabhängigkeit von Anbietern. Danach lernst du die elegante Zwei-Komponenten-Architektur kennen – Ollama als Motor, der die Sprachmodelle ausführt, und Open WebUI als komfortables Cockpit, das aussieht und sich anfühlt wie ChatGPT. Wir klären ehrlich, welche Hardware du brauchst, wie sich Apple Silicon und NVIDIA-Grafikkarten unterscheiden und welche Modellgröße auf welcher Maschine flüssig läuft. Im praktischen Teil installierst du Ollama, ziehst dein erstes Modell und startest Open WebUI per Docker – inklusive eines vollständigen Docker-Compose-Beispiels. Anschließend schauen wir uns die spannendsten offenen Modelle 2026 an (Llama, Qwen, Gemma, Mistral, DeepSeek) und ich sage dir, welches wofür taugt. Zum Schluss gehen wir die wichtigsten Features von Open WebUI durch, vergleichen die lokale Lösung ehrlich mit Cloud-ChatGPT und ich gebe dir Performance-Tipps sowie eine Liste der häufigsten Stolpersteine.

Einleitung: Dein eigenes ChatGPT im Keller

Stell dir vor, du hättest einen klugen Assistenten, der rund um die Uhr für dich arbeitet, jede deiner Fragen beantwortet, deine Dokumente durchsucht und beim Programmieren hilft – und der dabei niemals auch nur ein einziges Wort nach draußen plaudert. Kein Abo, keine Datenübertragung, keine Nutzungsbedingungen, die sich nächsten Monat wieder ändern. Genau das ist das Versprechen einer lokal gehosteten ChatGPT-Alternative.

Lange Zeit klang das nach Science-Fiction oder zumindest nach einem Projekt für Hardcore-Bastler mit einer Serverfarm im Keller. Das hat sich grundlegend geändert. Dank zweier herausragender Open-Source-Projekte – Ollama und Open WebUI – ist der Aufbau eines eigenen KI-Chats heute eine Sache von wenigen Minuten und einer Handvoll Terminal-Befehle. Und das Beste: Es läuft auf ganz normaler Consumer-Hardware. Ein moderner Laptop mit 16 GB RAM reicht für den Einstieg völlig aus.

Die Analogie, die ich am liebsten verwende: Cloud-ChatGPT ist wie ein Restaurantbesuch. Bequem, das Essen ist exzellent, aber du zahlst pro Gang, du weißt nicht genau, was in der Küche passiert, und du musst dich an die Speisekarte halten. Eine lokale Installation ist deine eigene Küche. Du musst sie einmal einrichten, aber danach kochst du, was du willst, wann du willst, mit Zutaten, die deinen Tresen nie verlassen. Lass uns diese Küche zusammen aufbauen.

Warum überhaupt lokal? Datenschutz, Kosten und Unabhängigkeit

Bevor wir loslegen, lohnt sich ein ehrlicher Blick auf das Warum. Es gibt drei große Argumente, und je nachdem, wer du bist, wiegt jedes unterschiedlich schwer.

1. Datenschutz und DSGVO. Das ist für viele das schlagende Argument. Wenn du ChatGPT, Claude oder Gemini nutzt, schickst du jeden Prompt – samt potenziell sensibler Inhalte – an einen externen Dienstleister, der die Daten meist in den USA verarbeitet. Für Privatpersonen ist das ärgerlich, für Unternehmen, Anwälte, Ärzte oder Steuerberater ist es schlicht ein Compliance-Problem. Mandantendaten, Patientenakten oder interne Geschäftszahlen haben in einer fremden Cloud nichts verloren. Bei einer lokalen Installation verlässt kein einziges Byte deinen Rechner oder dein Firmennetz. Die DSGVO-Frage löst sich damit elegant in Luft auf, weil schlicht keine Drittland-Datenübermittlung stattfindet.

2. Kosten. Cloud-KI wird pro Token oder per Monatsabo abgerechnet. Für gelegentliche Nutzung ist das günstig, aber wer den ganzen Tag mit dem Modell arbeitet, viele Dokumente verarbeitet oder gar mehrere Mitarbeiter ausstatten will, sieht die Rechnung schnell wachsen. Eine lokale Lösung hat einmalige Hardwarekosten (oder nutzt Hardware, die du ohnehin hast) und danach kostet jede einzelne Anfrage genau null Euro. Die Stromkosten sind bei einem Laptop oder Desktop vernachlässigbar.

3. Unabhängigkeit und Verfügbarkeit. Modelle in der Cloud werden ohne Vorwarnung abgeschaltet, verteuert oder durch zensiertere Nachfolger ersetzt. Eine API, auf die du deinen Workflow aufgebaut hast, kann morgen anders funktionieren. Dein lokales Modell hingegen bleibt exakt so, wie es ist – für immer. Es funktioniert im Flugzeug, im Zug ohne Empfang und auch dann noch, wenn der Anbieter pleite gehen sollte. Diese Unabhängigkeit ist ein unterschätzter Luxus.

Natürlich gibt es auch eine Kehrseite, und die will ich nicht verschweigen: Die absolut größten Modelle der Cloud-Anbieter sind nach wie vor leistungsfähiger als das, was du lokal betreiben kannst. Aber die Lücke ist 2026 erstaunlich klein geworden – dazu später mehr.

Die Architektur: Ollama als Motor, Open WebUI als Cockpit

Unsere lokale ChatGPT-Alternative besteht aus zwei sauber getrennten Bausteinen. Diese Trennung ist kein Zufall, sondern gutes Software-Design – jeder Teil macht eine Sache richtig gut.

Ollama ist der Motor. Es ist ein schlankes Programm, das im Hintergrund läuft und sich um das Schwierige kümmert: Es lädt Sprachmodelle herunter, lädt sie in den Speicher, nutzt deine Grafikkarte (oder den Apple-Silicon-Chip) zur Beschleunigung und stellt eine einfache API bereit, über die andere Programme mit dem Modell reden können. Du kannst dir Ollama wie einen Datenbankserver vorstellen, nur eben für KI-Modelle. Ohne Oberfläche, ohne Schnickschnack – pure Rechenleistung.

Open WebUI ist das Cockpit. Es ist eine ausgereifte Weboberfläche, die optisch und funktional bewusst an ChatGPT angelehnt ist. Hier tippst du deine Fragen, siehst die Antworten Wort für Wort erscheinen, verwaltest deine Chatverläufe, lädst Dokumente hoch und schaltest Funktionen wie die Websuche frei. Open WebUI spricht mit Ollama über dessen API und übersetzt die nüchterne Technik in ein angenehmes Nutzererlebnis.

Der Datenfluss ist dabei denkbar einfach:

Du  ?  Open WebUI (Browser, Port 3000)
              ¦
              ?  Ollama (API, Port 11434)
                       ¦
                       ?  Sprachmodell (z.B. Llama, Qwen, Gemma)

Der Charme dieser Architektur: Du kannst beide Teile unabhängig austauschen oder erweitern. Open WebUI kann nicht nur mit Ollama reden, sondern auch mit jeder OpenAI-kompatiblen API – falls du also für bestimmte Aufgaben doch mal ein Cloud-Modell anbinden willst, geht das problemlos im selben Interface. Und Ollama kann nicht nur Open WebUI bedienen, sondern auch deine eigenen Skripte, deine IDE oder andere Tools.

Hardware-Anforderungen: Was läuft auf welcher Maschine?

Das ist die Frage, die am häufigsten gestellt wird, und die Antwort lautet: weniger, als du denkst. Die Faustregel ist einfach – entscheidend ist der verfügbare schnelle Speicher, denn ein Modell muss komplett in den Speicher passen, damit es flott läuft. Passt es nur teilweise hinein und muss auf die langsame SSD auslagern, bricht die Geschwindigkeit um das 5- bis 30-fache ein.

Die offiziellen Minimalanforderungen von Ollama sind bescheiden: 8 GB RAM, etwa 10 GB freier Festplattenspeicher und eine 64-Bit-CPU mit AVX2-Befehlssatz. Eine Grafikkarte ist nicht zwingend nötig – kleine Modelle laufen auch rein auf der CPU, nur eben langsamer.

Hier eine Orientierungstabelle für die gängige 4-Bit-Quantisierung (Q4_K_M), die für die allermeisten Nutzer der Sweet Spot ist:

Modellgröße	Benötigter Speicher (Q4)	Geeignet für	Typische Geschwindigkeit
1–3B	2–4 GB	Schwache Laptops, schnelle Hilfsaufgaben	sehr schnell
7–8B	4–6 GB	Allrounder für 16-GB-Geräte	30–60 Token/s
13–14B	8–10 GB	Bessere Qualität, 16–24 GB Speicher	20–40 Token/s
32B	~20 GB	Anspruchsvolle Aufgaben, 24-GB-GPU oder 32-GB-Mac	langsamer, aber stark
70B	40 GB+	Profis, High-End-Workstations	nur mit viel VRAM/RAM

Apple Silicon vs. NVIDIA

Hier gibt es einen entscheidenden Unterschied, den viele unterschätzen:

Apple Silicon (M1 bis M4) hat einen großen Trumpf: den Unified Memory. CPU und GPU teilen sich denselben Speicher, das heißt, die kompletten 16, 32, 64 oder 128 GB deines Macs stehen potenziell dem Modell zur Verfügung. Ollama nutzt automatisch die Metal-Beschleunigung von Apple, ohne dass du irgendetwas konfigurieren musst. Ein MacBook mit 32 GB kann damit Modelle betreiben, für die du auf der PC-Seite eine teure Grafikkarte bräuchtest. Für lokale KI ist Apple Silicon deshalb ein erstaunlich attraktives Paket.

NVIDIA-Grafikkarten bleiben der Goldstandard für maximale Geschwindigkeit. Hier zählt der dedizierte VRAM: Eine RTX 4060 oder 3060 mit 8–12 GB läuft 7B- bis 14B-Modelle locker flüssig, eine 4090 oder 5090 mit 24–32 GB stemmt auch 32B-Modelle souverän. Vorausgesetzt wird eine CUDA-Compute-Capability von 5.0 oder höher, also alles ab der GTX-900-Serie. Wichtig: Sobald ein Modell vollständig in den VRAM passt, ist die Speicherbandbreite oft der eigentliche Flaschenhals – schnellerer Speicher bedeutet mehr Token pro Sekunde.

AMD-Karten werden ebenfalls unterstützt: unter Linux zuverlässig über ROCm, unter Windows mittlerweile über Vulkan (per Umgebungsvariable OLLAMA_VULKAN=1).

Ein praktischer Tipp zum Thema Quantisierung: Die Bezeichnung Q4_K_M bedeutet 4-Bit-Quantisierung. Sie verkleinert das Modell drastisch, kostet aber nur etwa 1–3 % Qualität – im Alltag praktisch nicht wahrnehmbar. Greif also ruhig zu den Q4-Varianten, statt die riesigen unquantisierten Versionen herunterzuladen.

Schritt 1: Ollama installieren

Genug Theorie, jetzt wird gebaut. Ollama lässt sich auf allen drei großen Betriebssystemen in wenigen Sekunden installieren.

Auf macOS lädst du am einfachsten die App von ollama.com/download herunter und ziehst sie in den Programme-Ordner. Wer Homebrew nutzt, geht über das Terminal:

brew install ollama

Auf Linux genügt ein einziger Befehl, der das offizielle Installationsskript ausführt:

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

Auf Windows lädst du den Installer von der Website herunter oder nutzt winget in der PowerShell:

winget install Ollama.Ollama

Nach der Installation läuft Ollama als Hintergrunddienst. Du kannst das überprüfen, indem du im Terminal die Versionsnummer abfragst und die (noch leere) Modellliste anzeigst:

ollama --version
ollama list

Falls der Dienst nicht automatisch läuft, startest du ihn manuell mit ollama serve. Ollama lauscht standardmäßig auf Port 11434 – diese Nummer brauchen wir gleich wieder.

Schritt 2: Dein erstes Modell ziehen und testen

Jetzt holen wir uns ein Sprachmodell. Modelle werden mit ollama pull heruntergeladen und mit ollama run direkt gestartet. Fangen wir mit einem soliden, kompakten Allrounder an, der auf nahezu jeder Maschine läuft:

ollama pull llama3.3
ollama run llama3.3

Der run-Befehl lädt das Modell und öffnet sofort eine Chat-Eingabe direkt im Terminal. Tippe eine Frage ein, drücke Enter, und du siehst, wie die Antwort erscheint. Mit /bye verlässt du den Chat wieder.

Du kannst die Modellgröße auch gezielt über das sogenannte Tag wählen. Hängst du nach einem Doppelpunkt eine Größe an, bekommst du genau diese Variante:

# Ein größeres Modell für bessere Qualität
ollama pull qwen3:14b

# Ein winziges Modell für schwache Hardware
ollama pull gemma3:4b

# Ein Reasoning-Modell, das "nachdenkt"
ollama pull deepseek-r1:8b

Mit ollama list siehst du jederzeit, welche Modelle du lokal liegen hast, und mit ollama rm <modellname> räumst du wieder auf, wenn der Speicher knapp wird. Probier ruhig ein paar verschiedene Modelle aus – das Herunterladen ist der einzige Schritt, der Internet braucht. Danach läuft alles offline.

Schritt 3: Open WebUI per Docker installieren

Das Chatten im Terminal ist nett zum Testen, aber wir wollen ja die schöne ChatGPT-Oberfläche. Open WebUI installierst du am saubersten per Docker. Falls du Docker noch nicht hast, installiere zuerst Docker Desktop (Mac/Windows) bzw. die Docker Engine (Linux).

Der folgende Befehl lädt Open WebUI herunter, startet es und sorgt dafür, dass es sich mit deinem bereits laufenden Ollama verbindet:

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

Kurz übersetzt, was hier passiert:

-d startet den Container im Hintergrund
-p 3000:8080 macht die Oberfläche unter Port 3000 erreichbar
--add-host=host.docker.internal:host-gateway erlaubt dem Container, das Ollama auf deinem Host zu finden
-v open-webui:/app/backend/data speichert deine Chats, Nutzer und Einstellungen dauerhaft (ganz wichtig, sonst sind die Daten nach einem Neustart weg!)
--restart always startet Open WebUI nach einem Reboot automatisch wieder

Sobald der Container läuft, öffnest du im Browser http://localhost:3000. Beim ersten Aufruf legst du ein Administrator-Konto an – dieses bleibt komplett lokal, es ist keine Online-Registrierung. Danach wählst du oben links dein heruntergeladenes Modell aus und kannst loschatten. Fertig ist deine eigene ChatGPT-Alternative.

Falls du eine NVIDIA-Grafikkarte hast und Open WebUI auch deren GPU-Funktionen (etwa für die Dokumentenverarbeitung) nutzen soll, gibt es ein eigenes Image:

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

Das vollständige Docker-Compose-Beispiel

Für einen sauberen, reproduzierbaren Aufbau empfehle ich Docker Compose. Damit definierst du beide Komponenten – Ollama und Open WebUI – in einer einzigen Datei und startest alles mit einem Befehl. Das ist besonders praktisch, wenn du das Setup auf einem Server oder einer Workstation dauerhaft betreiben willst.

Lege eine Datei namens docker-compose.yml an:

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama:/root/.ollama
    restart: always
    # Folgende Zeilen nur bei NVIDIA-GPU aktivieren:
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]

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

volumes:
  ollama:
  open-webui:

Starten tust du das Ganze dann mit:

docker compose up -d

Hier laufen beide Dienste in eigenen Containern und finden sich über den internen Docker-Netzwerknamen ollama. Modelle ziehst du in diesem Setup entweder über die Open-WebUI-Oberfläche (im Modellverwaltungs-Menü) oder direkt im Ollama-Container:

docker exec -it ollama ollama pull qwen3:8b

Mit docker compose down fährst du alles wieder herunter, die Daten bleiben dank der Volumes erhalten.

Modellauswahl 2026: Welches Modell für welchen Zweck?

Die Modelllandschaft hat sich 2026 rasant weiterentwickelt, und die offenen Modelle sind erstaunlich nah an die kommerziellen Spitzenmodelle herangerückt. Hier ein Überblick über die wichtigsten Familien und wofür sie sich eignen:

Modellfamilie	Herkunft	Stärken	Lizenz
Qwen 3 / 3.5	Alibaba	Bester Allrounder, top bei Reasoning, Coding und über 100 Sprachen	Apache 2.0
Llama 4	Meta	Riesige Kontextfenster, breites Ökosystem, gut für lange Dokumente	Community-Lizenz
Gemma 3	Google	Extrem speichereffizient, ideal für schwache Hardware und Edge-Geräte	Gemma-Lizenz
Mistral (Small/Large)	Mistral AI	Schnell, schlank, stark im Europäischen, gute Mehrsprachigkeit	Apache 2.0 (Small)
DeepSeek R1 / V3	DeepSeek	Herausragendes Reasoning, vergleichbar mit kommerziellen Denk-Modellen	MIT

Meine praktischen Empfehlungen:

Für den Einstieg und 16-GB-Geräte: qwen3:8b oder llama3.3 – guter Allrounder, läuft flüssig.
Für schwache Hardware (8 GB): gemma3:4b – erstaunlich fähig bei minimalem Speicherbedarf.
Fürs Programmieren: Ein größeres Qwen-Coder-Modell oder DeepSeek glänzt bei Code-Aufgaben.
Für kniffliges Nachdenken und Mathematik: deepseek-r1 – ein Reasoning-Modell, das seine Gedankengänge sichtbar durcharbeitet, bevor es antwortet.
Für maximale Qualität auf starker Hardware: die großen Qwen-3- oder Llama-4-Varianten ab 32B aufwärts.

Ein Wort zu Mixture-of-Experts-Modellen (MoE), die 2026 sehr verbreitet sind: Sie aktivieren pro Token nur einen Bruchteil ihrer Parameter und laufen deshalb schneller als ein dichtes Modell gleicher Größe. Der Haken: Du brauchst trotzdem genug Speicher, um alle Gewichte gleichzeitig vorzuhalten. Ein MoE mit 30B Gesamtparametern und 3B aktiven läuft also flott, belegt aber so viel Speicher wie ein 30B-Modell.

Die Features von Open WebUI im Überblick

Open WebUI ist weit mehr als nur ein Chatfenster. Es hat sich zu einer vollwertigen KI-Plattform gemausert, und viele Funktionen findest du nicht einmal beim kommerziellen ChatGPT in dieser Tiefe.

Chat mit allem Drum und Dran: Mehrere parallele Unterhaltungen, Verläufe, Bearbeiten und erneutes Generieren von Antworten, Markdown- und Code-Darstellung mit Syntax-Highlighting.
RAG – mit eigenen Dokumenten chatten: Du lädst PDFs, Word-Dateien oder Textdokumente hoch, und das Modell beantwortet Fragen auf Basis ihres Inhalts. Im Chat referenzierst du ein Dokument einfach mit dem #-Symbol. Du kannst zwischen Focused Retrieval (das Modell sucht gezielt die relevanten Stellen in großen Sammlungen) und Full Context (das komplette Dokument wird wortwörtlich übergeben) wählen. Unter der Haube kombiniert die hybride Suche klassische Stichwortsuche (BM25) mit semantischer Vektorsuche plus Reranking für höhere Treffsicherheit.
Websuche: Du kannst eine Websuche-Integration aktivieren, damit dein lokales Modell aktuelle Informationen aus dem Netz ziehen kann – falls du das möchtest. Für den komplett offline-Betrieb lässt du das einfach aus.
Wissensdatenbanken und Workspace: Über den Workspace legst du persistente Wissenssammlungen an, die unabhängig von einzelnen Chats existieren, inklusive verschachtelter Ordner für größere Dokumentenbestände. Open WebUI unterstützt im Hintergrund diverse Vektordatenbanken wie ChromaDB (Standard), PGVector, Qdrant, Milvus und mehr.
Mehrbenutzerbetrieb und Rechteverwaltung: Open WebUI ist von Grund auf für mehrere Nutzer ausgelegt. Du definierst Rollen und Gruppen, vergibst Modellzugriffe pro Nutzer und kannst es im Unternehmensumfeld sogar an LDAP/Active Directory oder über SCIM an Identity-Provider wie Okta oder Azure AD anbinden.
Modellverwaltung: Modelle herunterladen, löschen und konfigurieren geht direkt über die Oberfläche. Du kannst eigene „Modelle“ mit angepassten Systemprompts und Parametern anlegen – ähnlich den Custom GPTs, nur eben lokal.

Lokal vs. Cloud-ChatGPT: Der ehrliche Vergleich

Damit du eine fundierte Entscheidung treffen kannst, hier die Gegenüberstellung ohne Schönfärberei:

Kriterium	Lokal (Ollama + Open WebUI)	Cloud-ChatGPT
Datenschutz	? Daten bleiben bei dir, DSGVO-konform	? Daten gehen an externen Anbieter
Kosten	? Einmalige Hardware, dann kostenlos	? Laufendes Abo oder Token-Abrechnung
Offline-Fähigkeit	? Funktioniert ohne Internet	? Braucht ständige Verbindung
Unabhängigkeit	? Modell bleibt für immer verfügbar	? Anbieter kann ändern/abschalten
Anpassbarkeit	? Volle Kontrolle über Modelle & Setup	?? Eingeschränkt
Maximale Leistung	?? Sehr gut, aber Spitzenmodelle der Cloud sind voraus	? Größte und stärkste Modelle
Einrichtungsaufwand	?? Einmalige Installation nötig	? Sofort nutzbar
Multimodalität (Bild, Audio)	?? Möglich, aber begrenzter	? Sehr ausgereift

Die Quintessenz: Wenn dir Datenschutz, Kosten oder Unabhängigkeit wichtig sind, ist die lokale Lösung 2026 absolut alltagstauglich. Wenn du dagegen kompromisslos die allerstärkste Modellleistung oder ausgefeilte multimodale Funktionen brauchst und Datenschutz keine Rolle spielt, hat die Cloud noch die Nase vorn. Viele Profis fahren übrigens zweigleisig – lokal für Sensibles und Alltägliches, Cloud für die seltenen Schwerstaufgaben. Und das Schöne: Open WebUI kann beide Welten unter einer Oberfläche vereinen.

Performance-Tipps und typische Fehler

Zum Abschluss noch die Erfahrungswerte, die dir viel Frust ersparen.

Performance-Tipps:

Wähle die richtige Modellgröße. Das ist der wichtigste Hebel. Lieber ein 8B-Modell, das komplett in den Speicher passt und flott läuft, als ein 32B-Modell, das ständig auf die SSD auslagert und zäh wird.
Bleib bei Q4-Quantisierung. Sie ist der beste Kompromiss aus Qualität und Geschwindigkeit. Die unquantisierten Modelle bringen kaum spürbar mehr Qualität, kosten aber das Vielfache an Speicher.
Halte das Modell warm. Ollama lädt ein Modell beim ersten Aufruf in den Speicher. Lässt du es geladen, antworten Folgeanfragen sofort.
Achte auf die Speicherbandbreite. Bei GPUs, die das Modell ohnehin fassen, bestimmt die Bandbreite das Tempo – nicht die reine Rechenleistung.

Typische Fehler und ihre Lösung:

Open WebUI findet Ollama nicht. Der häufigste Stolperstein. Beim Docker-Setup brauchst du --add-host=host.docker.internal:host-gateway, und im Docker-Compose-Setup muss OLLAMA_BASE_URL korrekt auf den Ollama-Container zeigen.
Chats sind nach dem Neustart weg. Du hast das Volume -v open-webui:/app/backend/data vergessen. Ohne dieses Volume werden alle Daten beim Containerneustart gelöscht.
Alles läuft quälend langsam. Fast immer passt das Modell nicht in den Speicher und lagert aus. Wechsle zu einer kleineren Variante oder einer stärkeren Quantisierung.
Modell antwortet nicht oder bricht ab. Prüfe mit ollama list, ob das Modell wirklich vollständig heruntergeladen wurde, und schau mit ollama ps, ob es geladen ist.
GPU wird nicht genutzt. Unter Docker brauchst du --gpus all und auf der NVIDIA-Seite das korrekt installierte Container-Toolkit. Bei Apple Silicon läuft Ollama am besten nativ installiert statt im Docker-Container, weil Docker auf dem Mac keinen direkten GPU-Zugriff hat.

Zusammenfassung und praktische Tipps

Du hast jetzt alles in der Hand, um deine eigene, komplett lokale ChatGPT-Alternative zu betreiben. Fassen wir das Wichtigste zusammen:

Die Architektur besteht aus Ollama (dem Modell-Motor) und Open WebUI (dem komfortablen Cockpit). Beide sind quelloffen, kostenlos und arbeiten Hand in Hand.
Die Hardware ist genügsamer, als viele denken: 16 GB RAM reichen für einen flüssigen Allrounder. Apple Silicon punktet mit Unified Memory, NVIDIA mit roher Geschwindigkeit.
Die Installation ist eine Sache von Minuten: Ollama mit einem Befehl installieren, ein Modell ziehen, Open WebUI per Docker starten – fertig.
Die Modelle sind 2026 ausgereift. Qwen 3, Llama 4, Gemma 3, Mistral und DeepSeek decken jeden Anwendungsfall ab, vom sparsamen Edge-Modell bis zum starken Reasoning-Spezialisten.
Der größte Gewinn ist die Datenhoheit: Nichts verlässt deinen Rechner, keine laufenden Kosten, volle Unabhängigkeit.

Mein konkreter Einstiegstipp: Installiere Ollama, zieh dir qwen3:8b oder llama3.3, starte Open WebUI per Docker und chatte einfach mal eine Stunde lang drauflos. Wenn dich das Tempo überzeugt, probier ein größeres Modell. Wenn dir der Speicher ausgeht, geh eine Größe runter. Dieses Ausprobieren kostet dich nichts außer ein bisschen Downloadzeit – und am Ende hast du eine KI, die ganz allein dir gehört.

Eine lokale ChatGPT-Alternative selbst hosten: Komplett offline mit Open WebUI und Ollama

Eine lokale ChatGPT-Alternative selbst hosten: Komplett offline mit Open WebUI und Ollama

Artikel-Übersicht

Einleitung: Dein eigenes ChatGPT im Keller

Warum überhaupt lokal? Datenschutz, Kosten und Unabhängigkeit

Die Architektur: Ollama als Motor, Open WebUI als Cockpit

Hardware-Anforderungen: Was läuft auf welcher Maschine?

Apple Silicon vs. NVIDIA

Schritt 1: Ollama installieren

Schritt 2: Dein erstes Modell ziehen und testen

Schritt 3: Open WebUI per Docker installieren

Das vollständige Docker-Compose-Beispiel

Modellauswahl 2026: Welches Modell für welchen Zweck?

Die Features von Open WebUI im Überblick

Lokal vs. Cloud-ChatGPT: Der ehrliche Vergleich

Performance-Tipps und typische Fehler

Zusammenfassung und praktische Tipps

Ressourcen