Ollama: ein LLM lokal self-hosten – Quickstart per Docker und REST-API

Ein Sprachmodell auf eigener Hardware zu betreiben klingt nach GPU-Cluster und Wochenendprojekt. Für den Einstieg sind es ein Container und ein curl-Aufruf. Ollama bündelt Modell-Download, Speicherverwaltung und eine HTTP-Schnittstelle in einer einzigen Binary: Sie ziehen ein Modell wie ein Container-Image und sprechen es danach über REST an. Dieser Beitrag macht genau das – Container starten, Modell ziehen, zwei Endpunkte bedienen – und ordnet ein, wann dieser Weg trägt und wann nicht. Kein Deep Dive, sondern das Minimum, mit dem Sie in einer Viertelstunde eine funktionierende lokale LLM-API haben.

Was Ollama macht – und wann Sie es nehmen

Ollama ist ein lokaler Inferenz-Server. Die Kernidee ist die Paketierung: Modellgewichte, Prompt-Template und Standardparameter liegen zusammen unter einem Namen im Format model:tag, etwa llama3.2:3b. Fehlt der Tag, gilt latest. Ein Pull lädt das Paket in ein lokales Verzeichnis, ein Request lädt es in den Speicher, und nach einer Leerlaufzeit (keep_alive, standardmäßig 5 Minuten) gibt Ollama den Speicher wieder frei. Sie verwalten keine Python-Umgebung, keine Tokenizer-Konfiguration und keine Quantisierung von Hand.

Genau daraus folgt die Abgrenzung. Ollama passt für lokale Entwicklung, interne Werkzeuge, Prototypen und kleine Teams – überall dort, wo Bequemlichkeit und ein geringer Grundverbrauch wichtiger sind als maximaler Durchsatz. Sobald viele Anfragen parallel laufen und Sie Batching, Tensor-Parallelismus und ausgereiztes GPU-Sharing brauchen, ist ein Serving-Stack wie vLLM der bessere Weg. Wie das aussieht, habe ich im Beitrag Hermes selbst hosten mit vLLM beschrieben. Kurzfassung: Ollama zum Anfangen und für den Einzelplatz, vLLM für die Produktionslast.

Ollama per Docker starten

Eine compose.yaml genügt. Wichtig sind zwei Dinge: ein Volume für die Modelle, sonst laden Sie mehrere Gigabyte nach jedem Neustart erneut, und eine Bindung an 127.0.0.1 – dazu gleich mehr bei den Stolperfallen.

services:
  ollama:
    image: ollama/ollama:0.32.6
    ports:
      - "127.0.0.1:11434:11434"
    volumes:
      - ollama_models:/root/.ollama
    environment:
      OLLAMA_CONTEXT_LENGTH: 8192
    restart: unless-stopped
    # Fuer NVIDIA-GPUs zusaetzlich (NVIDIA Container Toolkit vorausgesetzt):
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]

volumes:
  ollama_models:

Starten und prüfen:

docker compose up -d
curl -s http://localhost:11434/api/version

Auf einem Entwicklungsrechner geht es auch ohne Docker: Unter Linux installiert curl -fsSL https://ollama.com/install.sh | sh den Dienst nativ, unter macOS und Windows gibt es Installer. Die API ist in allen Fällen dieselbe.

Ein Modell ziehen

Modelle kommen aus der Ollama-Bibliothek. Für den ersten Test ist llama3.2:3b ein guter Kompromiss: 2,0 GB Download, 128K Kontextfenster laut Modellkarte, läuft notfalls auch auf CPU (dann langsam).

docker compose exec ollama ollama pull llama3.2:3b
docker compose exec ollama ollama list

Dasselbe geht über die API, was für Automatisierung praktischer ist:

curl -s http://localhost:11434/api/pull -d '{ "model": "llama3.2:3b", "stream": false }'
curl -s http://localhost:11434/api/tags

Das Minimalbeispiel: generate und chat

Ollama bietet zwei Endpunkte, die Sie kennen müssen. /api/generate nimmt einen einzelnen prompt – ideal für Klassifikation, Extraktion oder Zusammenfassungen ohne Gesprächsverlauf:

curl -s http://localhost:11434/api/generate -d '{
  "model": "llama3.2:3b",
  "prompt": "Fasse in einem Satz zusammen: Self-Hosting von LLMs.",
  "stream": false,
  "options": { "temperature": 0.2 }
}'

Die Antwort ist ein JSON-Objekt; der Text steht in response. Zusätzlich liefert Ollama Kennzahlen, alle Dauern in Nanosekunden: total_duration, load_duration, prompt_eval_count (Tokens im Prompt) und eval_count (erzeugte Tokens). Die Tokens pro Sekunde berechnen Sie als eval_count / eval_duration * 10^9 – die einfachste Art, verschiedene Modelle auf Ihrer Hardware zu vergleichen.

/api/chat nimmt stattdessen ein messages-Array mit den Rollen system, user, assistant und tool. Den Gesprächsverlauf hält Ihre Anwendung; Ollama ist zustandslos und erwartet ihn bei jedem Aufruf komplett:

curl -s http://localhost:11434/api/chat -d '{
  "model": "llama3.2:3b",
  "messages": [
    { "role": "system", "content": "Du antwortest knapp und auf Deutsch." },
    { "role": "user", "content": "Nenne drei Vorteile von Self-Hosting." }
  ],
  "stream": false
}'

Hier steckt der Text in message.content. Das ist bereits das komplette Fundament: Ein weiteres {"role": "assistant", ...} plus die nächste Nutzerfrage an das Array angehängt, und Sie haben einen Chat.

Der Ablauf in der Übersicht:

   +--------------+   ollama pull llama3.2:3b   +-------------------+
   |  Bibliothek  | --------------------------> |  Volume           |
   |  ollama.com  |      Gewichte + Template    |  /root/.ollama    |
   +--------------+                             +---------+---------+
                                                          | laedt bei Bedarf
   +--------------+   POST /api/chat                      v
   |   Ihre App   | --------------------------> +-------------------+
   |  (curl, SDK, |                             |  ollama serve     |
   |   Backend)   | <-------------------------- |  Port 11434       |
   +--------------+   JSON: message.content     +-------------------+
                                                  entlaedt nach keep_alive (5m)

Drei typische Stolperfallen

1. Die API kennt keine Authentifizierung. Lokal ist für den Zugriff auf http://localhost:11434 kein Token nötig – das ist bewusst so und der Grund, warum der Dienst nativ installiert nur an 127.0.0.1 lauscht. Das offizielle Container-Image setzt dagegen OLLAMA_HOST=0.0.0.0:11434, damit das Port-Mapping überhaupt funktioniert. Ihre einzige Grenze ist damit die linke Seite des Mappings. Schreiben Sie "11434:11434" statt "127.0.0.1:11434:11434", hängt Ihr Modell offen im Netz – und Docker publiziert an gängigen Host-Firewalls vorbei. Wer den Dienst wirklich exponieren muss, stellt einen Reverse Proxy mit Authentifizierung und TLS davor.

2. Streaming ist der Standard. Ohne "stream": false antworten /api/generate und /api/chat mit einer Folge von JSON-Objekten, eines pro Zeile, mit jeweils einem Textfragment. Wer diese Ausgabe naiv durch einen JSON-Parser schickt, bekommt einen Syntaxfehler oder nur das erste Token. Für Skripte und Batch-Jobs setzen Sie stream konsequent auf false; für eine Oberfläche mit Tipp-Effekt lassen Sie den Standard und lesen zeilenweise. Dasselbe gilt für /api/pull, das den Download-Fortschritt streamt.

3. Das Kontextfenster ist kleiner, als Sie denken. Ollama arbeitet standardmäßig mit 4096 Token – unabhängig davon, dass die Modellkarte 128K ausweist. Längere Prompts werden stillschweigend abgeschnitten, was sich als „das Modell ignoriert die Hälfte meines Dokuments" äußert. Setzen Sie OLLAMA_CONTEXT_LENGTH serverseitig (siehe compose.yaml oben) oder num_ctx in options pro Request. Rechnen Sie mit dem Preis: Der Speicherbedarf skaliert mit OLLAMA_NUM_PARALLEL mal Kontextlänge, ein großzügiges Fenster plus Parallelität sprengt schnell den verfügbaren VRAM.

Wie es weitergeht

Damit steht ein lokaler LLM-Dienst mit persistenten Modellen und zwei belastbaren Endpunkten. Der naheliegende nächste Schritt ist POST /api/embed mit einem Embedding-Modell wie nomic-embed-text: Der Endpunkt nimmt model und input und liefert unter embeddings ein Array von Vektoren, einen pro Eingabe – prüfen Sie die Länge des ersten Vektors (embeddings[0]), denn genau diese Zahl ist die Dimension, die Ihre Vektordatenbank braucht. Wie es von dort weitergeht, steht im Beitrag Qdrant self-hosten für RAG. Bestehende Anwendungen binden Sie oft ohne Umbau an: Ollama stellt zusätzlich eine OpenAI-kompatible Schicht unter http://localhost:11434/v1/ bereit, inklusive /v1/chat/completions.

Ein Hinweis zum Versions-Pinning: Zum Redaktionsschluss ist 0.32.6 der jüngste versionierte Tag des Standard-Images auf Docker Hub, während die GitHub-Releases bereits bei v0.32.9 stehen – die Image-Tags laufen der Release-Liste einige Tage hinterher. Pinnen Sie trotzdem eine feste Version statt :latest, sonst ändert ein docker compose pull Ihr Setup unbemerkt. Weiter geht es im Ollama-Quickstart, in der API-Referenz und in der FAQ, die die Speicher- und Nebenläufigkeitsparameter im Detail erklärt.

Hinweis zur Veröffentlichung: Dieser Beitrag war für den 16. Juli 2026 geplant. Wegen einer technischen Störung der automatischen Veröffentlichung ist er erst am 11. August 2026 online gegangen. Alle Angaben wurden vor der Veröffentlichung erneut auf Aktualität geprüft.