Docker Ollama: LLMs lokal ausführen – für Datenschutz und null Kosten

Die meisten Entwickler wollen lokale LLMs ausprobieren, wissen aber nicht, wo sie anfangen sollen.

Der Aufstieg von Open-Source-Modellen wie Llama und Mistral macht lokale KI so zugänglich wie nie. Du musst kein Geld bei OpenAI oder Anthropic ausgeben und musst dir keine Sorgen machen, Daten an Dritte zu schicken. Die Herausforderung: Viele Set-up-Guides verlangen das Hantieren mit Python-Umgebungen, CUDA-Treibern und Abhängigkeiten, die beim Rechnerwechsel gern kaputtgehen.

Ollama löst das, indem es eine einfache Möglichkeit bietet, lokale LLMs mit minimalem Setup auszuführen. In Kombination mit Docker bekommst du eine saubere, portable Lösung, die auf unterschiedlichen Systemen gleich funktioniert.

In dieser Anleitung zeige ich dir, wie du Ollama in Docker einrichtest, dein erstes Modell lädst und lokale LLMs startest, auf die du aus jeder Anwendung zugreifen kannst.

Wenn Docker für dich neu ist, empfehlen wir dir unseren Introduction to Docker-Kurs, um die Grundlagen zu verstehen.

Was ist Ollama?

Denk an Ollama als den einfachsten Weg, große Sprachmodelle auf deiner eigenen Hardware auszuführen.

Es ist eine schlanke Laufzeitumgebung, die die Schwerarbeit für lokale LLMs übernimmt. Du musst keine Python-Umgebungen pflegen, keine CUDA-Treiber manuell installieren und dich nicht mit Modellgewichten oder Tokenizern herumschlagen. Ollama übernimmt Download, Laden und Bereitstellung von Modellen wie LLaMA, Mistral und Gemma mit einem einzigen Befehl.

Datenschutz ist eingebaut. Deine Unterhaltungen verlassen nie deinen Rechner. Keine API-Schlüssel, kein Nutzungstracking, keine Daten an externe Server. Perfekt für sensible Arbeit, bei der proprietärer Code oder persönliche Informationen nicht zu Dritten gelangen dürfen.

Das Tool ist zuerst für Entwickler gedacht. Es läuft nativ auf macOS und Linux, bietet eine einfache REST-API zur Integration und funktioniert jetzt auch in Docker-Containern. So kannst du lokal in der Entwicklung dieselbe Umgebung nutzen, die du überall dort ausrollst, wo Docker läuft.

Du bekommst einen produktionsreifen LLM-Server, der mit einem Befehl startet und offline funktioniert.

Ollama ist nicht die einzige LLM-Laufzeitumgebung – probiere auch n8n und Qdrant aus.

Warum Docker mit Ollama nutzen?

Die Antwort ist simpel – du bekommst alle Vorteile von Ollama und hältst dein System sauber.

Ollama direkt auf deinem Rechner auszuführen, funktioniert gut – es kommt als Installer (für Windows .exe, für Mac .dmg), der alles übernimmt. Aber Docker hat einen entscheidenden Vorteil: Isolation.

Mit Docker läuft Ollama in einem eigenen Container. Das hält dein Hostsystem sauber. Keine Installationsreste auf dem Hauptsystem, keine Dateien, die nach dem Testen übrig bleiben, und einfache Entfernung beim Versionswechsel oder wenn du komplett aufräumen willst.

Dank Reproduzierbarkeit funktioniert dasselbe Setup für alle im Team. Teile einen Docker-Befehl, und jede Person kann exakt dieselbe Ollama-Umgebung starten – egal ob auf macOS, Linux oder Windows.

Das Ausrollen wird dank plattformübergreifender Unterstützung einfach. Derselbe Container, der auf deinem Laptop läuft, funktioniert unverändert auf einem Cloud-Server, in der CI-Pipeline oder auf dem Rechner eines Kollegen.

Mit vereinfachtem Setup und Teardown startest du Ollama in Sekunden und entfernst es genauso schnell wieder. Keine Deinstallationsskripte, kein Suchen nach Config-Dateien, kein Systemputz.

Damit ist Docker ideal für:

• Modelle testen, ohne eine Vollinstallation fest zu übernehmen
• Apps bauen, die sich mit lokalen LLMs integrieren
• Entwicklungsumgebungen erstellen, die mehrere Teammitglieder teilen können
• Ollama auf Servern ausführen, deren Basissystem du nicht verändern willst

Kurz: Du bekommst alle Vorteile lokaler LLMs ohne Setup-Kopfschmerzen.

Suchst du nach weiteren praktischen Docker-Ressourcen? Diese 12 Docker-Container-Images für Machine Learning und KI bringen dich schnell voran.

Ollama in Docker einrichten

Mit genau drei Befehlen läuft Ollama in Docker.

Zuerst ziehst du das offizielle Ollama-Image von Docker Hub:

docker pull ollama/ollama

Ollama-Image ziehen

Als Nächstes startest du den Container mit den richtigen Port- und Volume-Mappings:

docker run -d --name my-ollama-docker -p 11434:11434 -v ollama:/root/.ollama ollama/ollama

Ollama läuft

Das bedeuten die Flags im Einzelnen:

• -d startet den Container im Hintergrund
• --name my-ollama.docker gibt deinem Container einen sprechenden Namen
• -p 11434:11434 mappt den Standardport von Ollama auf deinen Host
• -v ollama:/root/.ollama erstellt ein persistentes Volume für heruntergeladene Modelle

Der Container startet sofort und lauscht auf http://localhost:11434.

Ollama läuft lokal

Lade jetzt ein Modell herunter, um alles zu testen:

docker exec -it my-ollama-docker  ollama pull llama3.1

Llama3.1-Modell laden

Das lädt das Llama 3.1 8B-Modell in deinen Container. Das Modell ist etwa 5 GB groß, der Download dauert also ein paar Minuten.

Du kannst das Setup prüfen, indem du die verfügbaren Modelle auflistest:

docker exec -it my-ollama-docker ollama list

Verfügbare Modelle auflisten

Das Volume-Mapping ist wichtig. Ohne dieses gehen alle heruntergeladenen Modelle verloren, sobald der Container stoppt. Das Volume ollama:/root/.ollama hält deine Modelle über Neustarts und Updates hinweg vor.

Für Produktions-Setups willst du vielleicht eigene Images mit vorinstallierten Modellen bauen. Erstelle dazu eine Dockerfile, die Modelle bereits beim Build lädt:

FROM ollama/ollama
RUN ollama serve & sleep 5 && ollama pull llama3.1 && pkill ollama
CMD ["ollama", "serve"]

So backst du das Modell direkt ins Image, und neue Container starten sofort einsatzbereit.

Ollama über Docker nutzen

Sobald dein Container läuft, verhält sich Ollama wie jede andere REST-API.

Der Dienst lauscht auf http://localhost:11434 und akzeptiert Standard-HTTP-Requests. Du brauchst keine speziellen Clients oder SDKs — sende einfach JSON und erhalte Antworten zurück.

So erzeugst du Text mit einem einfachen curl-Befehl:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1",
  "prompt": "Why is the sky blue?",
  "stream": false
}'

Zugriff auf Ollama mit curl

Die API liefert eine JSON-Antwort mit dem generierten Text. Setze "stream": false, um die komplette Antwort auf einmal zu erhalten, oder "stream": true, um Tokens im Stream zu bekommen.

Python-Integration ist genauso simpel:

import requests

response = requests.post(
    "http://localhost:11434/api/generate",
    json={
        "model": "llama3.1",
        "prompt": "Explain Docker containers in one sentence.",
        "stream": False,
    },
)

print(response.json()["response"])

Zugriff auf Ollama mit Python

Damit eignet sich Ollama perfekt als Backend für lokale Anwendungen. Du kannst Chat-Oberflächen, Code-Completion-Tools oder Systeme zur Dokumentenanalyse bauen, die mit deinem containerisierten LLM sprechen, ohne Daten an externe Dienste zu senden.

Für komplexere Workflows funktioniert die LangChain-Integration out of the box:

from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.1", base_url="http://localhost:11434")
response = llm.invoke("Explain the benefits of containerization in 2 sentences")
print(response)

Zugriff auf Ollama mit LangChain

Du bekommst die volle Power lokaler LLMs mit der Einfachheit von HTTP-Requests.

Fragst du dich, wie LLM-Anwendungen ausgerollt werden? Lies unsere Schritt-für-Schritt-Anleitung zur Bereitstellung von LLM-Anwendungen mit Docker.

Performance-Aspekte

Lokale LLMs brauchen ernstzunehmende Hardware, und Docker bringt etwas Overhead mit.

CPU vs. GPU macht einen gewaltigen Unterschied. Ollama kann auf reinen CPU-Systemen laufen, aber die Inferenz ist langsam — rechne mit 30+ Sekunden für einfache Antworten. Mit einer modernen GPU ist dieselbe Abfrage in unter 5 Sekunden fertig. NVIDIA-GPUs funktionieren am besten, aber auch Apple-Silicon-Macs liefern starke Leistung und können beim Preis-Leistungs-Verhältnis punkten.

RAM-Anforderungen skalieren mit der Modellgröße. Kleine Modelle wie Llama3.1 8B benötigen mindestens 8 GB Systemspeicher, größere 70B-Varianten 64 GB oder mehr. Das Modell bleibt während der Nutzung im Speicher, du kannst also kein 13B-Modell auf einer Maschine mit 8 GB RAM betreiben.

Speicherplatz summiert sich schnell. Jeder Modell-Download belegt Gigabytes an Plattenplatz:

• 7B-Parameter-Modelle: 4–8 GB
• 13B-Parameter-Modelle: 8–16 GB  
• 70B-Parameter-Modelle: 40–80 GB

Mehrere Modellversionen und Quantisierungen lassen den Speicherbedarf schnell explodieren. Wenn der Platz knapp wird, kannst du Modelle auf ein externes Laufwerk auslagern.

Container-Overhead ist beim Rechnen minimal, bei Storage jedoch relevant. Das Basis-Image von Ollama liegt unter 1 GB, die Modelle liegen in Docker-Volumes. Wenn du eigene Images mit vorab geladenen Modellen baust, werden sie jeweils um mehrere Gigabyte größer als das Basisimage.

Allerdings braucht die Speicherzuweisung in Docker oft Feintuning. Docker Desktop begrenzt Container-RAM standardmäßig. Für größere Modelle musst du die Limits erhöhen oder den --memory-Parameter beim Start setzen.

Der Engpass ist meist der RAM, nicht CPU oder Plattendurchsatz.

Beliebte Anwendungsfälle

Docker + Ollama gibt dir KI-Fähigkeiten, die deine Daten privat halten und deine LLM-Inferenzkosten bei genau 0 $ liegen lassen (Strom- und Wartungskosten ausgenommen).

Lokale KI-Assistenten sind das Paradebeispiel. Du kannst Code-Completion-Tools, Doku-Generatoren oder Schreibassistenten erstellen, die komplett auf deinem Rechner laufen. Keine API-Kosten, keine Rate Limits, keine Daten außerhalb deines Netzwerks. Weise deinen Editor oder deine IDE einfach auf localhost:11434 und leg los.

Private RAG-Pipelines lassen sich damit ebenfalls deutlich einfacher bereitstellen. 

Du kannst Unternehmensdokumente in eine Vektordatenbank laden und Ollama nutzen, um Fragen dazu zu beantworten. Die gesamte Wissensbasis bleibt intern — entscheidend für juristische, finanzielle oder proprietäre Informationen, die keine externen APIs berühren dürfen.

Offline-Chatbot-Entwicklung ermöglicht Prototyping und Tests ohne Internetabhängigkeit. Ideal für Edge-Deployments, isolierte Umgebungen oder unzuverlässige Verbindungen. Dein Bot funktioniert identisch — ob online oder in 10.000 Metern Höhe.

Modellexperimente vor dem Cloud-Deployment sparen Zeit und Geld. Du testest lokal unterschiedliche Modelle, Prompts und Konfigurationen, bevor du teure Cloud-Inferenz buchst. So benchmarkst du Performance, justierst Parameter und validierst Ergebnisse, ohne API-Credits zu verbrennen.

Teams nutzen dieses Docker-und-Ollama-Setup außerdem für:

• Generierung von Trainingsdaten, wenn du große Mengen synthetischen Texts brauchst
• Content-Moderation, die sensibles Material intern verarbeitet  
• Forschungsumgebungen, in denen Reproduzierbarkeit und Isolation zählen
• Demo-Anwendungen, die ohne externe Abhängigkeiten funktionieren

Du bekommst Enterprise-KI – ohne Enterprise-Rechnung.

Tipps, Limits und Troubleshooting

Es gibt ein paar Stolpersteine, die Ollama in Docker ausbremsen können.

GPU-Support braucht zusätzliche Einrichtung. Das offizielle Ollama-Image unterstützt NVIDIA-GPUs, aber du musst zuerst das NVIDIA Container Toolkit installieren und beim Start --gpus all setzen:

docker run -d --gpus all --name ollama -p 11434:11434 -v ollama:/root/.ollama ollama/ollama

Ohne diese Konfiguration fällt Ollama auf CPU-Only zurück — das läuft, ist aber deutlich langsamer. Auf einem Apple-Silicon-MacBook betrifft dich das nicht.

Dateiberechtigungen können bei Docker-Volumes Ärger machen. Wenn du statt eines benannten Volumes ein Host-Verzeichnis mountest, kann Ollama wegen Berechtigungen ggf. keine Modelldateien schreiben. Benannte Volumes wie -v ollama:/root/.ollama vermeiden das komplett.

Model-Caching über Neustarts hinweg funktioniert automatisch mit korrekt gemounteten Volumes. Deine geladenen Modelle bleiben im Docker-Volume, sodass Stop/Start keinen erneuten Download erfordert. Löschst du das Volume versehentlich oder vergisst das -v-Flag, sind die Modelle weg.

Merke dir diese Quick-Fixes:

• Container startet nicht? Prüfe, ob Port 11434 schon belegt ist
• Modelle laden langsam? Internetverbindung und zugewiesene Docker-Ressourcen prüfen
• API-Requests laufen in Timeout? Docker-Speicherlimits für größere Modelle erhöhen
• GPU wird nicht erkannt? NVIDIA-Treiber und Container-Toolkit-Installation prüfen

Der häufigste Fehler: das Volume-Mount vergessen und sich wundern, warum Modelle verschwinden.

Fazit

Docker macht lokale LLMs einfach, portabel und sauber.

Du bekommst Privacy by Design, deine Daten bleiben auf deinem Rechner. Du bekommst planbare Kosten, keine überraschenden API-Rechnungen oder Rate-Limits. Und du bekommst volle Kontrolle über deinen KI-Stack — ohne Vendor-Lock-in und ohne Internetabhängigkeit.

Das Setup dauert Minuten. 

Image ziehen, Container starten, Modell laden – und du kannst bauen. Egal, ob du einen KI-Assistenten prototypisierst, private RAG-Pipelines betreibst oder mit verschiedenen Modellen experimentierst: Diese Kombination bringt Enterprise-Fähigkeiten auf deinen Laptop.

Probier es jetzt aus. Wähle ein Modell, das zu deiner Hardware passt, starte den Ollama-Container und baue etwas. Die Einstiegshürde existiert nicht.

Als nächsten Schritt empfehlen wir dir, DeepSeek R1 lokal mit Ollama einzurichten und auszuführen.