Ollama Anleitung 2026: Installieren, einrichten und die drei Fallen, die keiner erwähnt

Diese Ollama Anleitung bringt dich von null zu einem lokalen Sprachmodell, das du im Terminal, per API und aus deinen eigenen Skripten nutzen kannst. Ollama ist ein kostenloses Open-Source-Werkzeug (MIT-Lizenz), das Sprachmodelle auf deinem eigenen Rechner oder Server herunterlädt, startet und über eine lokale Schnittstelle bereitstellt. Ein Befehl zum Installieren, ein Befehl zum Starten, fertig. So weit die Werbung.

Die Werbung stimmt sogar. Was sie verschweigt: Ollama hat ein paar Voreinstellungen, die dir ohne jede Fehlermeldung falsche Antworten liefern. Wir haben am 29. Oktober 2026 Ollama in der damals frischen Version 0.40.13 (erschienen am Vorabend) auf unserem eigenen Server installiert und jeden Schritt dieser Anleitung selbst durchgespielt und gemessen. Dabei sind uns drei Dinge aufgefallen, die in fast keiner Anleitung stehen. Sie stehen hier, mit Zahlen.

Falls du erst wissen willst, ob sich lokale KI für dich überhaupt lohnt, welche Hardware du brauchst und wie Ollama im Vergleich zu LM Studio und llama.cpp abschneidet: Das haben wir ausführlich in unserem Artikel über lokale KI aufgeschrieben. Dieser Artikel hier ist die Werkbank dazu: Wie benutzt man Ollama richtig, wenn man sich einmal dafür entschieden hat?

Video: „KI ohne Cloud & Kosten: Ollama 2026 Komplett-Guide“ von KI-Wissen (Januar 2026), ein guter visueller Einstieg auf Deutsch. Die Versionsnummern im Video sind inzwischen älter, die Bedienung ist gleich geblieben.

Ollama Anleitung in Kürze: das Wichtigste vorab

• Installation: Unter Linux ein Einzeiler, bei uns in 8,9 Sekunden erledigt. Unter macOS und Windows ein normaler Installer.
• Erstes Modell: ollama run qwen3.5:4b lädt rund 3,3 GB und startet einen Chat. Der Download dauerte bei uns 25 Sekunden.
• Falle 1, Kontextlänge: Ollama arbeitet ab Werk mit 4.096 Tokens Kontext. Längere Eingaben werden ohne Warnung vorne abgeschnitten. In unserem Test hat das Modell dadurch eine Frage zu einem langen Text schlicht falsch beantwortet.
• Falle 2, Thinking: Viele aktuelle Modelle „denken“ ab Werk erst nach. Das macht sie bei kleinen Fragen über 100-mal langsamer, aber manchmal auch richtiger. Du solltest das bewusst steuern.
• Falle 3, Parallelität: Gleichzeitige Anfragen werden ab Werk nacheinander abgearbeitet. Vier parallele Anfragen dauerten bei uns 9,8 Sekunden statt 2,5.
• API: Läuft automatisch auf 127.0.0.1:11434, auch im OpenAI-Format. Vorhandene Skripte brauchen oft nur eine neue Basis-URL.
• Sicherheit: Die API hat keine Anmeldung. Öffne Port 11434 niemals ungeschützt ins Internet.

Was ist Ollama, und was passiert beim Start eigentlich?

Ollama ist im Kern eine Verpackung um eine Inferenz-Engine. Wenn du ollama ps aufrufst, siehst du in der Spalte RUNNER bei normalen GGUF-Modellen llamacpp: Die eigentliche Rechenarbeit erledigt also llama.cpp, Ollama kümmert sich um alles drumherum. Dazu gehören:

• Modellverwaltung wie ein Paketmanager: pull, list, rm, mit Versionen und geteilten Dateischichten.
• Ein Hintergrunddienst (ollama serve), der Modelle bei Bedarf in den Speicher lädt und nach einer Weile wieder entlädt.
• Eine HTTP-API in einem eigenen Format und zusätzlich im OpenAI-Format.
• Chat-Vorlagen, damit du dich nicht darum kümmern musst, welches Modell welche Sonderzeichen für „Nutzer“ und „Assistent“ erwartet.

Das Projekt ist ausgesprochen aktiv. Am Tag unseres Tests stand das GitHub-Repository bei rund 185.000 Sternen, die Bibliothek auf ollama.com/library listete 264 Modelle. Zum Vergleich: Am 1. August 2026, als wir den Artikel über lokale KI geschrieben haben, waren es 232 Modelle und Version 0.32.5. Acht Versionssprünge in drei Monaten. Das ist der Grund, warum diese Anleitung die stabilen Grundlagen erklärt und konkrete Modellnamen nur als Beispiel mit Datum nennt.

Ein Punkt gehört gleich an den Anfang, weil er für Datenschutz entscheidend ist: Ollama bietet inzwischen auch Cloud-Modelle an. Etwa 20 Einträge der Bibliothek sind so gekennzeichnet, sie tragen cloud im Namen und laufen nicht auf deinem Rechner, sondern bei Ollama. Wer Ollama wegen „meine Daten bleiben bei mir“ einsetzt, sollte genau hinschauen, welches Modell er startet.

Ollama installieren: Linux, macOS und Windows

Linux (auch Server)

Unter Linux genügt der offizielle Einzeiler:

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

Wer Skripte aus dem Internet nicht blind ausführen will (zu Recht), lädt sie erst herunter und schaut hinein. Das Skript hatte bei uns 455 Zeilen und macht im Wesentlichen vier Dinge: Es lädt das passende Archiv herunter, legt einen Systembenutzer ollama an, fügt ihn den Gruppen render und video hinzu (für Grafikkarten) und richtet einen systemd-Dienst ein.

curl -fsSL https://ollama.com/install.sh -o ollama-install.sh
less ollama-install.sh
sh ollama-install.sh

Auf unserem Server dauerte das komplett 8,9 Sekunden. Danach meldet das Skript:

>>> The Ollama API is now available at 127.0.0.1:11434.
>>> Install complete. Run "ollama" from the command line.
WARNING: No NVIDIA/AMD GPU detected. Ollama will run in CPU-only mode.

Die Warnung ist bei uns korrekt, unser Server hat keine Grafikkarte. Das ist ausdrücklich kein Hindernis, wie die Messwerte weiter unten zeigen.

Eine Beobachtung, die du kennen solltest: Wir hatten Ollama auf diesem Server schon einmal installiert und den Dienst danach bewusst deaktiviert. Das Installationsskript hat ihn beim Update wieder aktiviert und gestartet, ohne zu fragen. Wer den Dienst aus Gründen ausgeschaltet hatte (zum Beispiel, weil der Server RAM für anderes braucht), muss das nach jedem Update erneut tun. Ein Update ist übrigens genau derselbe Befehl wie die Installation.

Prüfen, ob alles läuft:

ollama --version
systemctl status ollama
ss -tlnp | grep 11434

Bei uns lauschte der Dienst danach auf 127.0.0.1:11434, also nur lokal. Das ist die richtige Voreinstellung.

Wenn du Linux noch nicht so gut kennst: Unser Artikel systemd Service erstellen erklärt, was hinter systemctl steckt, und hilft beim Verständnis der Konfiguration weiter unten.

macOS

Unter macOS lädst du die App von ollama.com/download, ziehst sie in den Programme-Ordner und startest sie. Sie legt den Befehl ollama im Terminal an und läuft als kleines Symbol in der Menüleiste. Auf Apple Silicon (M1 und neuer) nutzt Ollama automatisch den gemeinsamen Arbeitsspeicher als Grafikspeicher, Macs sind deshalb für lokale Modelle überraschend gut geeignet. Den macOS-Installer haben wir für diesen Artikel nicht selbst getestet.

Windows

Unter Windows gibt es ebenfalls einen Installer auf derselben Seite. Nach der Installation steht ollama in PowerShell und in der Eingabeaufforderung zur Verfügung, der Dienst läuft im Hintergrund. NVIDIA- und AMD-Grafikkarten werden erkannt, wenn aktuelle Treiber installiert sind. Auch den Windows-Installer haben wir für diesen Artikel nicht selbst getestet, die Bedienung danach ist aber identisch mit Linux.

Docker

Wer lieber alles in Containern betreibt, kann das offizielle Image ollama/ollama nutzen. Wichtig ist ein Volume für die Modelle, sonst lädst du sie nach jedem Neustart erneut:

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

Achte auf das 127.0.0.1: vor dem Port. Ohne diese Angabe veröffentlicht Docker den Port auf allen Netzwerkschnittstellen und umgeht dabei oft sogar die Firewall. Mehr dazu steht in unserem Docker-Compose-Beispiel.

Das erste Modell: herunterladen, starten, chatten

Modell herunterladen

ollama pull qwen3.5:4b

Der Teil vor dem Doppelpunkt ist die Modellfamilie, der Teil danach der „Tag“, meist die Größe in Milliarden Parametern. Bei uns dauerte der Download von 3,3 GB 25 Sekunden, an einer schnellen Server-Anbindung. Zu Hause mit 100 Mbit/s rechnest du eher mit fünf Minuten.

Was in einem Modell steckt, verrät ollama show:

$ ollama show qwen3.5:4b
  Model
    architecture        qwen35
    parameters          4.2B
    context length      262144
    quantization        Q4_K_M
  Capabilities
    completion
    vision
    tools
    thinking
        levels     false, true
        default    true

Zwei Zeilen darin sind wichtiger, als sie aussehen. context length 262144 heißt: Das Modell könnte über 260.000 Tokens Kontext verarbeiten. Ollama nutzt davon ab Werk aber nur einen Bruchteil, dazu gleich mehr. Und thinking default true heißt: Das Modell denkt ab Werk erst nach, bevor es antwortet. Auch das hat Folgen.

Chatten im Terminal

ollama run qwen3.5:4b

Es erscheint eine Eingabeaufforderung. Mit /bye beendest du den Chat, mit /? siehst du alle Befehle. Nützlich sind vor allem:

/set parameter num_ctx 16384   # mehr Kontext für diese Sitzung
/set think false               # Nachdenken ausschalten
/show info                     # Modellinfos

Wer Messwerte sehen will, startet mit ollama run qwen3.5:4b --verbose. Dann steht nach jeder Antwort, wie viele Tokens pro Sekunde das Modell erzeugt hat.

Welches Modell soll ich nehmen?

Die ehrliche Antwort: Das ändert sich monatlich. Ein paar Faustregeln bleiben aber stabil.

• Die Dateigröße ist ungefähr der RAM-Bedarf. Ein 3,3-GB-Modell belegte bei uns im Speicher 3,1 GB bei kleinem Kontext und 3,7 GB bei großem. Plane rund 20 bis 30 Prozent Reserve ein.
• Klein anfangen. Ein Modell mit 3 bis 5 Milliarden Parametern läuft auf fast jedem Rechner mit 8 GB RAM und zeigt dir, ob dir der Ansatz gefällt.
• Q4_K_M ist der Standard und für die meisten Zwecke der richtige Kompromiss aus Größe und Qualität. Ollama nimmt ihn bei den meisten Modellen automatisch.
• Spezialmodelle für Spezialaufgaben. Für Programmieren gibt es eigene Coder-Modelle, für Texte in Datenbanken und Suchen gibt es Embedding-Modelle (siehe unten).
• Sehr kleine Modelle erfinden gern. In unserem August-Test hat ein Modell mit 0,8 Milliarden Parametern eine Frage zu Quantisierung souverän falsch beantwortet. Schnell ist nicht gleich brauchbar.

Wie viel RAM ein Server grundsätzlich braucht, auch mit KI-Workloads, haben wir in Wie viel RAM braucht ein Server? genauer aufgeschlüsselt.

Wichtige Befehle im Überblick

ollama ps ist der wichtigste Befehl bei Problemen. So sah er bei uns aus:

NAME          SIZE      PROCESSOR    CONTEXT    RUNNER      UNTIL
qwen3.5:4b    3.1 GB    100% CPU     4096       llamacpp    4 minutes from now

Steht bei PROCESSOR unerwartet 100% CPU, obwohl du eine Grafikkarte hast, passt das Modell nicht in den Grafikspeicher. Steht dort etwas wie 40%/60% CPU/GPU, läuft es teilweise auf der CPU und entsprechend langsamer. Und die Spalte CONTEXT führt direkt zur ersten Falle.

Falle 1: Ollama schneidet lange Eingaben still ab

Das ist der wichtigste Abschnitt dieser Anleitung. Ollama arbeitet ab Werk mit einem Kontextfenster von 4.096 Tokens. Das steht so in der offiziellen FAQ und bei uns in ollama ps. Ein Token ist grob ein Wortteil, im Deutschen kommen auf ein Wort im Schnitt etwas mehr als ein Token. 4.096 Tokens sind also ungefähr sechs bis acht Seiten Text, Frage und Antwort zusammen.

Was passiert, wenn deine Eingabe länger ist? Wir haben es getestet. Unser Text begann mit dem Satz „GEHEIMWORT: Brombeere.“, danach folgten rund 12.600 Tokens Fülltext, am Ende die Frage: „Wie lautet das GEHEIMWORT vom Anfang?“

Mit der Standardeinstellung hat Ollama von über 12.000 Tokens nur 2.050 verarbeitet. Den Rest, inklusive des Geheimworts am Anfang, hat es weggeworfen. Es gab keine Fehlermeldung, keinen HTTP-Fehler, keine Warnung in der Antwort. Das Modell hat ehrlich geantwortet, dass es kein Geheimwort sieht, denn in dem Teil, den es bekommen hat, gab es keins. Erst in der Antwort steckt mit prompt_eval_count: 2050 ein Hinweis, und den liest niemand.

Für den Alltag heißt das: Wenn du Ollama Dokumente zusammenfassen, Logs auswerten oder lange E-Mails beantworten lässt, bekommst du mit den Standardwerten Antworten auf Texte, die das Modell nie vollständig gesehen hat. Das ist besonders tückisch, weil die Antworten plausibel klingen.

So stellst du den Kontext richtig ein

Es gibt vier Wege, je nachdem, wo du Ollama benutzt:

1. Pro Anfrage in der API:

{"model": "qwen3.5:4b", "prompt": "...", "options": {"num_ctx": 16384}}

2. Im interaktiven Chat: /set parameter num_ctx 16384

3. Dauerhaft für den ganzen Server über eine Umgebungsvariable (Linux mit systemd):

sudo systemctl edit ollama

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=16384"

sudo systemctl restart ollama

Danach zeigte ollama ps bei uns CONTEXT 16384, auch ohne Angabe in der Anfrage.

4. Fest in einer eigenen Modellvariante per Modelfile (siehe nächster Abschnitt).

Was mehr Kontext kostet

Mehr Kontext ist nicht gratis. Zwei Kosten haben wir gemessen:

• Arbeitsspeicher: Mit 4.096 Tokens belegte das Modell 3,1 GB, mit 16.384 Tokens 3,7 GB. Bei größeren Modellen wächst der Unterschied entsprechend.
• Zeit: Die 12.645 Tokens hat unser Server mit rund 160 Tokens pro Sekunde eingelesen, das dauerte 79 Sekunden, bevor das erste Wort der Antwort kam. Mit einer Grafikkarte geht das um ein Vielfaches schneller. Auf einer CPU ist es der eigentliche Flaschenhals, nicht die Antwortgeschwindigkeit.

Die vernünftige Regel: Stell den Kontext so groß ein, wie deine längsten echten Eingaben, plus Platz für die Antwort. Nicht pauschal auf das Maximum, das frisst nur Speicher.

Falle 2: Thinking macht Modelle langsam, aber manchmal richtig

Viele aktuelle Modelle sind sogenannte Reasoning-Modelle. Sie schreiben vor der eigentlichen Antwort einen inneren Gedankengang. Bei Ollama ist das für unterstützte Modelle ab Werk eingeschaltet, ollama show sagt dazu default true.

Wir haben eine klassische Fangfrage gestellt: „Wie viele r hat das Wort Erdbeerkuchen? Nur die Zahl.“ Die richtige Antwort ist 2 (Erdbeerkuchen).

Das ist ein schönes Beispiel dafür, warum es keine pauschale Empfehlung gibt. Mit Thinking hat das Modell über 1.100 Zeichen nachgedacht, dafür 120-mal länger gebraucht und die richtige Antwort gegeben. Ohne Thinking kam die Antwort sofort und war falsch.

Faustregel aus unserer Praxis:

• Thinking aus für Zusammenfassen, Umformulieren, Übersetzen, Klassifizieren, einfache Extraktion. Dort bringt Nachdenken wenig und kostet viel Zeit.
• Thinking an für Rechnen, Logik, mehrstufige Aufgaben und alles, wo ein falsches Ergebnis teuer ist.

So schaltest du es:

ollama run qwen3.5:4b --think=false        # Terminal
ollama run qwen3.5:4b --hidethinking       # denkt, zeigt es aber nicht an

{"model": "qwen3.5:4b", "prompt": "...", "think": false}

In der API landet der Gedankengang in einem eigenen Feld (thinking), getrennt von der Antwort (response). Wenn deine Anwendung plötzlich ewig auf Antworten wartet, nachdem du auf ein neues Modell umgestiegen bist, ist Thinking der erste Verdächtige.

Eigene Modellvarianten mit dem Modelfile

Ein Modelfile ist für Ollama das, was ein Dockerfile für Docker ist: eine kleine Textdatei, die aus einem vorhandenen Modell eine eigene Variante mit festen Einstellungen macht. Das ist der sauberste Weg, Falle 1 dauerhaft zu entschärfen und einem Modell eine feste Rolle zu geben.

FROM qwen3.5:4b
PARAMETER num_ctx 16384
PARAMETER temperature 0.3
SYSTEM """Du bist ein knapper Linux-Admin-Helfer. Antworte auf Deutsch, maximal 3 Sätze."""

ollama create admin-helfer -f Modelfile
ollama run admin-helfer

Das Anlegen dauerte bei uns 0,25 Sekunden und hat keinen zusätzlichen Speicherplatz belegt: Das Modellverzeichnis blieb bei 3,4 GB. Ollama speichert Modelle in Schichten wie Docker-Images, die eigene Variante verweist nur auf die schon vorhandenen Gewichte. Du kannst also beliebig viele Varianten für verschiedene Aufgaben anlegen.

Die wichtigsten Anweisungen:

Mit FROM ./mein-modell.gguf kannst du übrigens auch Modelle von Hugging Face einbinden, die es in der Ollama-Bibliothek nicht gibt.

Die Ollama API: aus Skripten und Programmen nutzen

Der eigentliche Wert von Ollama liegt nicht im Chat, sondern in der API, die ohnehin läuft. Es gibt zwei Formate.

Die native API

curl http://127.0.0.1:11434/api/generate -d '{
  "model": "qwen3.5:4b",
  "prompt": "Erkläre in drei Sätzen, was ein Reverse Proxy ist.",
  "stream": false,
  "think": false
}'

Für Gespräche mit Verlauf gibt es /api/chat mit einer Liste von Nachrichten. Die Antwort enthält neben dem Text Messwerte, die du für eigene Benchmarks nutzen kannst:

• load_duration: Zeit zum Laden des Modells (nur beim ersten Aufruf nennenswert, bei uns 5,1 Sekunden)
• prompt_eval_count: wie viele Tokens der Eingabe tatsächlich verarbeitet wurden (hier erkennst du Falle 1!)
• eval_count und eval_duration: erzeugte Tokens und Zeit in Nanosekunden

Bei uns lagen kurze Antworten zwischen 12 und 37 Tokens pro Sekunde, je nachdem, wie stark der Server gerade anderweitig ausgelastet war. Unter Last war es die Hälfte. Das ist der ehrliche Teil am CPU-Betrieb auf einem Server, der noch andere Aufgaben hat: Die Geschwindigkeit schwankt. Menschen lesen etwa 5 bis 8 Tokens pro Sekunde, für Chat reicht das trotzdem locker.

Unser Python-Skript für die Messung ist bewusst ohne Zusatzbibliotheken geschrieben:

import json, urllib.request

def frage(prompt, model="qwen3.5:4b", ctx=16384):
    body = {"model": model, "prompt": prompt, "stream": False,
            "think": False, "options": {"num_ctx": ctx}}
    req = urllib.request.Request("http://127.0.0.1:11434/api/generate",
          data=json.dumps(body).encode(), headers={"Content-Type": "application/json"})
    d = json.load(urllib.request.urlopen(req, timeout=600))
    return d["response"], d["prompt_eval_count"]

antwort, gelesen = frage("Fasse zusammen: ...")
print(antwort, f"({gelesen} Tokens gelesen)")

Die OpenAI-kompatible API

Ollama spricht unter /v1/ auch das Format der OpenAI-API. Das ist praktisch, weil fast jedes Werkzeug und jede Bibliothek dieses Format versteht:

from openai import OpenAI
client = OpenAI(base_url="http://127.0.0.1:11434/v1", api_key="ollama")
r = client.chat.completions.create(model="qwen3.5:4b",
        messages=[{"role": "user", "content": "Sag nur: Hallo"}])
print(r.choices[0].message.content)

Der API-Schlüssel ist dabei ein Platzhalter. Wir haben mit einem beliebigen Wert getestet, die Anfrage wurde problemlos beantwortet (4,7 Sekunden inklusive Modellstart). Das bedeutet auch: Die API prüft keinen Schlüssel. Wer den Port erreicht, darf alles. Dazu unten mehr.

Ollama mit Coding-Werkzeugen

Neu in den letzten Versionen ist ollama launch. Der Befehl startet Werkzeuge wie Claude Code, Codex, OpenCode, Cline oder VS Code direkt mit einem Ollama-Modell als Gehirn. Die Liste der unterstützten Integrationen war in Version 0.40.13 auf 18 angewachsen. Das ist bequem, aber erwarte von einem 4B-Modell auf einer CPU keine Wunder. Wie sich die großen Cloud-Werkzeuge schlagen, haben wir in Claude Code vs. Cursor gemessen. Für ernsthafte Programmieraufgaben brauchen lokale Modelle viel Grafikspeicher.

Video: „Lokale KI in VS Code: Ollama Guide & Modellwahl“ von Programmieren lernen (September 2026), zeigt die Einbindung in den Editor.

Embeddings mit Ollama: Suche und RAG

Neben Textmodellen kann Ollama auch Embedding-Modelle ausführen. Die erzeugen keinen Text, sondern verwandeln einen Text in eine Liste von Zahlen, einen Vektor. Ähnliche Texte bekommen ähnliche Vektoren. Darauf bauen semantische Suche und RAG auf (Retrieval Augmented Generation: Das Modell bekommt vor der Antwort die passenden Stellen aus deinen eigenen Dokumenten).

ollama pull nomic-embed-text
curl http://127.0.0.1:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["Wie setze ich mein Passwort zurück?", "Ich habe mein Kennwort vergessen"]
}'

Das Modell ist mit 274 MB winzig und war in 5,9 Sekunden heruntergeladen. Drei Sätze in Vektoren mit je 768 Zahlen zu verwandeln, dauerte 0,54 Sekunden. So weit, so gut. Dann haben wir gemessen, wie gut es Bedeutung erkennt. Je näher der Wert an 1, desto ähnlicher sieht das Modell zwei Sätze:

Auf Englisch trennt das Modell sauber: 0,79 gegen 0,34. Auf Deutsch liegen beide Werte fast gleichauf, das Modell kann ein passendes und ein völlig unpassendes Thema kaum unterscheiden. Auch die vom Hersteller empfohlenen Präfixe (search_query: und search_document:) haben daran nichts Wesentliches geändert (0,615 gegen 0,527).

Die Lehre: Das bekannteste Embedding-Modell in vielen Ollama-Anleitungen ist für deutsche Texte eine schlechte Wahl. Für deutsche oder gemischte Inhalte solltest du ein mehrsprachiges Modell wie bge-m3 (rund 1,2 GB) testen. Das haben wir für diesen Artikel nicht nachgemessen, mach also denselben Test mit deinen eigenen Beispielsätzen, bevor du eine Suche darauf baust. Drei Sätze reichen, um ein unbrauchbares Modell zu entlarven.

Ollama als Dienst auf einem Server betreiben

Auf einem Server ist Ollama ein ganz normaler systemd-Dienst. Alle Einstellungen laufen über Umgebungsvariablen, die du mit sudo systemctl edit ollama in einer Override-Datei setzt. So bleiben sie auch nach Updates erhalten, weil das Installationsskript nur die Hauptdatei überschreibt.

Die wichtigsten Einstellungen

Ein Beispiel für einen Server, der Dokumente verarbeitet und das Modell ständig bereithalten soll:

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=16384"
Environment="OLLAMA_KEEP_ALIVE=30m"
Environment="OLLAMA_MODELS=/srv/ollama/models"

Wenn du den Speicherort änderst, muss der Benutzer ollama dort schreiben dürfen (sudo chown -R ollama:ollama /srv/ollama).

Falle 3: Gleichzeitige Anfragen stehen Schlange

Wir haben vier gleiche Anfragen gleichzeitig abgeschickt. Ergebnis:

Die Einzeldauern verraten es: Die Anfragen wurden nacheinander abgearbeitet, die vierte musste fast zehn Sekunden warten. Jede einzelne lief mit normaler Geschwindigkeit (31 bis 37 Tokens pro Sekunde), sie standen nur in der Schlange. Das liegt an OLLAMA_NUM_PARALLEL=1.

Für einen persönlichen Assistenten ist das egal. Wenn du Ollama aber hinter eine Website, ein Team-Werkzeug oder eine Automatisierung hängst, die viele Anfragen gleichzeitig stellt, solltest du das wissen. Mehr Parallelität kostet Speicher: Laut Dokumentation wächst der RAM-Bedarf mit OLLAMA_NUM_PARALLEL × OLLAMA_CONTEXT_LENGTH. Vier parallele Anfragen mit 16.384 Tokens Kontext brauchen also deutlich mehr Speicher als eine. Auf einer CPU ohne Grafikkarte bringt mehr Parallelität außerdem wenig, weil sich die Anfragen die Rechenkerne teilen.

Sicherheit: Port 11434 gehört nicht ins Internet

Die Ollama-API hat keine Benutzerverwaltung und keine Passwörter. Wer sie erreicht, kann Modelle nutzen, herunterladen, löschen und deinen Server mit Rechenaufgaben auslasten. Sicherheitsforscher finden in Suchmaschinen für offene Dienste regelmäßig tausende Ollama-Server, die genau so offen im Netz stehen, meist weil jemand OLLAMA_HOST=0.0.0.0 gesetzt hat, um vom Laptop aus zuzugreifen.

Unsere Empfehlung, von bequem zu sicher:

1. Bei 127.0.0.1 lassen und vom eigenen Rechner per SSH-Tunnel zugreifen: ssh -L 11434:127.0.0.1:11434 user@server. Danach erreichst du Ollama auf deinem Laptop unter localhost:11434, verschlüsselt und ohne offenen Port. Wie SSH funktioniert, steht in Was ist SSH?.
2. Für mehrere Nutzer einen Reverse Proxy wie Caddy oder nginx davorsetzen, mit HTTPS und Anmeldung (Basic Auth oder ein vorgeschaltetes Login). Ollama selbst bleibt auf 127.0.0.1.
3. Im Heimnetz darf OLLAMA_HOST=0.0.0.0 vertretbar sein, aber nur, wenn dein Router den Port nicht nach außen weiterleitet und die Firewall ihn nur für dein lokales Netz öffnet.

Wichtig bei Docker: Ein -p 11434:11434 ohne 127.0.0.1: davor veröffentlicht den Port weltweit, auch wenn deine Firewall ihn eigentlich sperrt.

Häufige Probleme und ihre Lösung

„Error: could not connect to ollama server“. Der Dienst läuft nicht. Unter Linux mit sudo systemctl start ollama starten, unter macOS und Windows die App öffnen. Genau diese Meldung bekamen wir selbst, weil wir den Dienst vor Wochen deaktiviert hatten.

Antworten ignorieren den Anfang meines Textes. Falle 1: Kontext zu klein. num_ctx erhöhen und in der API-Antwort prompt_eval_count prüfen.

Das Modell braucht ewig für kurze Antworten. Falle 2: Thinking ist an. Mit think: false oder --think=false abschalten, wenn die Aufgabe es nicht braucht.

Die erste Antwort ist langsam, alle weiteren schnell. Normal. Beim ersten Aufruf lädt Ollama das Modell in den Speicher (bei uns 5,1 Sekunden). Nach fünf Minuten ohne Anfrage wird es wieder entladen. Mit OLLAMA_KEEP_ALIVE verlängern.

Trotz Grafikkarte läuft alles auf der CPU. In ollama ps nachsehen. Meist passt das Modell nicht vollständig in den Grafikspeicher, oder der Treiber fehlt. Kleineres Modell, kleinere Quantisierung oder weniger Kontext wählen.

Die Festplatte läuft voll. Modelle sind groß und bleiben, bis du sie löschst. ollama list zeigt die Größen, ollama rm räumt auf. Unter Linux liegen sie standardmäßig in /usr/share/ollama/.ollama/models.

Ollama aktualisieren und deinstallieren

Aktualisieren unter Linux: einfach das Installationsskript erneut ausführen. Bei uns ging das von 0.32.5 auf 0.40.13 in 8,9 Sekunden. Das Skript schreibt die Hauptdatei des Dienstes neu, deine Einstellungen gehören deshalb in die Override-Datei von systemctl edit. Denk daran, dass das Skript den Dienst dabei wieder aktiviert. Unter macOS und Windows meldet die App Updates selbst.

Modelle aktualisieren: ollama pull NAME erneut ausführen. Es werden nur geänderte Schichten geladen.

Deinstallieren unter Linux:

sudo systemctl disable --now ollama
sudo rm /etc/systemd/system/ollama.service
sudo rm -r /usr/local/lib/ollama /usr/local/bin/ollama
sudo rm -r /usr/share/ollama        # löscht auch alle Modelle
sudo userdel ollama && sudo groupdel ollama

Wir haben nach unseren Tests alle Modelle gelöscht und den Dienst wieder deaktiviert, damit er auf unserem Produktionsserver keinen Speicher belegt, wenn wir ihn nicht brauchen.

Häufige Fragen

Ist Ollama kostenlos?

Ja. Ollama selbst ist Open Source unter der MIT-Lizenz und kostet nichts, auch nicht für kommerzielle Nutzung. Die Lizenzen der einzelnen Modelle sind davon getrennt und unterschiedlich, manche erlauben kommerzielle Nutzung nur mit Einschränkungen. Kostenpflichtig sind nur die optionalen Cloud-Modelle.

Funktioniert Ollama ohne Internet?

Ja, sobald die Modelle heruntergeladen sind. Für Installation und pull brauchst du Internet, danach läuft alles offline. Ausnahme: Modelle mit cloud im Namen, die laufen immer bei Ollama.

Brauche ich für Ollama eine Grafikkarte?

Nein. Unser Testserver hat keine, kleine Modelle liefen trotzdem mit 12 bis 37 Tokens pro Sekunde, schneller als man liest. Eine Grafikkarte beschleunigt vor allem das Einlesen langer Texte enorm und erlaubt größere Modelle. Auf Apple-Silicon-Macs wird der normale Arbeitsspeicher als Grafikspeicher genutzt.

Wie viel RAM brauche ich für Ollama?

Etwa so viel, wie das Modell groß ist, plus 20 bis 30 Prozent Reserve plus dein Betriebssystem. Für ein 4B-Modell sind 8 GB RAM gesamt ein guter Startpunkt, für Modelle mit 12 bis 14 Milliarden Parametern eher 16 GB, für 27B und mehr 32 GB oder eine Grafikkarte mit viel Speicher. Mehr Kontext und mehr parallele Anfragen erhöhen den Bedarf.

Wo speichert Ollama die Modelle?

Unter Linux mit dem offiziellen Skript in /usr/share/ollama/.ollama/models, unter macOS und Windows im Benutzerverzeichnis unter .ollama/models. Mit der Variable OLLAMA_MODELS kannst du einen anderen Ort festlegen, etwa eine größere Festplatte.

Sind meine Daten bei Ollama privat?

Bei lokalen Modellen ja: Die Verarbeitung findet komplett auf deinem Gerät statt, es geht keine Anfrage an fremde Server. Das gilt nicht für Modelle mit cloud im Namen. Und es gilt nur, solange du die API nicht offen ins Netz stellst, denn sie hat keine Anmeldung.

Wie ändere ich die Kontextlänge in Ollama?

Pro Anfrage mit "options": {"num_ctx": 16384}, im Chat mit /set parameter num_ctx 16384, für den ganzen Server mit der Umgebungsvariable OLLAMA_CONTEXT_LENGTH oder fest in einem Modelfile mit PARAMETER num_ctx 16384. Prüfen kannst du die aktuelle Länge in der Spalte CONTEXT von ollama ps.

Kann ich Ollama mit der OpenAI-Bibliothek benutzen?

Ja. Setze die Basis-URL auf http://127.0.0.1:11434/v1 und einen beliebigen API-Schlüssel. Chat Completions, Embeddings und Modelllisten funktionieren, viele Werkzeuge, die eigentlich für OpenAI gebaut sind, laufen so direkt mit lokalen Modellen.

Was ist der Unterschied zwischen Ollama und LM Studio?

Ollama ist ein Kommandozeilen-Werkzeug mit Hintergrunddienst und API, ideal für Server und Automatisierung. LM Studio ist eine grafische Anwendung zum Ausprobieren und Vergleichen von Modellen. Beide nutzen intern llama.cpp. Den ausführlichen Vergleich findest du in unserem Artikel über lokale KI.

Wie greife ich von einem anderen Rechner auf Ollama zu?

Am sichersten per SSH-Tunnel (ssh -L 11434:127.0.0.1:11434 user@server), dann bleibt Ollama nur lokal erreichbar. Alternativ OLLAMA_HOST=0.0.0.0 setzen, aber nur im geschützten Heimnetz oder hinter einem Reverse Proxy mit Anmeldung. Niemals ungeschützt ins Internet.

Warum antwortet Ollama auf Deutsch schlechter als auf Englisch?

Die meisten Modelle wurden überwiegend mit englischen Texten trainiert. Größere Modelle gleichen das gut aus, kleine merklich schlechter. Besonders deutlich war es bei unserem Embedding-Test: Das beliebte nomic-embed-text trennte auf Englisch sauber, auf Deutsch kaum. Teste Modelle immer mit deinen eigenen deutschen Beispielen.

Fazit: Einfach zu starten, wichtig zu verstehen

Ollama hält sein Versprechen. In unter zehn Sekunden installiert, in einer halben Minute das erste Modell geladen, eine API, die sofort läuft und sogar das OpenAI-Format spricht. Für lokale KI gibt es kein bequemeres Werkzeug.

Die Bequemlichkeit hat einen Preis, und der heißt Voreinstellungen. Das Kontextfenster von 4.096 Tokens schneidet lange Texte ohne Warnung ab, und genau dort, wo lokale KI am meisten nutzt (eigene Dokumente, Logs, lange Texte), liefert sie dann plausible, falsche Antworten. Thinking kann eine Antwort richtig machen oder hundertmal langsamer, und du solltest entscheiden, welches von beidem du brauchst. Parallele Anfragen stehen Schlange, und die API vertraut jedem, der sie erreicht.

Nichts davon ist ein Grund gegen Ollama. Es ist ein Grund, diese fünf Minuten Konfiguration nicht zu überspringen: Kontextlänge passend setzen, Thinking bewusst wählen, prompt_eval_count im Blick behalten, Port lokal lassen. Dann ist Ollama genau das, was es sein will, ein Werkzeug, das einfach funktioniert.