Ollama Komplettanleitung: Lokale LLMs einfach starten [2026]

Ollama ist ein kostenloses Open-Source-Tool, mit dem du offene LLMs (große Sprachmodelle) auf deinem eigenen Rechner ausführst. Es läuft unter Windows, macOS und Linux, und eine einzige Zeile, ollama run modellname, erledigt alles vom Herunterladen des Modells bis zum Chat. Solange es läuft, lauscht ein API-Server auf localhost:11434 – deine eigenen Apps und Tools wie Claude Code können es also ebenfalls aufrufen. Neben Modellen, die auf deinem Rechner laufen, nutzt du mit denselben Befehlen inzwischen auch Cloud-Modelle, deren Name auf :cloud endet.

Diese Anleitung konzentriert sich darauf, wie man Ollama selbst benutzt, abgeglichen mit dem Originaltext des offiziellen GitHub-Repositorys (einschließlich des Quellcodes), der offiziellen Dokumentation und der Preisseite (Stand: 12. November 2026). Zu lokalen LLMs allgemein siehe wie du mit einem lokalen LLM startest, zur Modellwahl unseren großen Vergleich der besten lokalen LLM-Modelle, zur Berechnung des nötigen VRAM den Artikel zu den Hardware-Anforderungen und zur Anbindung an deinen Editor den Artikel zu Ollama + Cline.

1. Was ist Ollama? Zwei Wege: lokal und in der Cloud

Ollama ist ein kostenloses Open-Source-Tool, mit dem du offene Modelle (Gemma, Qwen, gpt-oss und andere) ganz einfach auf deinem eigenen PC betreibst. Es erledigt den mühsamen Teil – das Herunterladen von Modellen, den Umgang mit Quantisierungsformaten, die Konfiguration der GPU-Nutzung – im Hintergrund, sodass du nur noch „ein Modell benennen und ausführen“ musst. Die Inferenz baut auf llama.cpp auf; auf Macs mit Apple Silicon gibt es manche Modelle zusätzlich in Versionen, die auf Apples MLX laufen.

Es gibt zwei Arten, ein Modell auszuführen – und je nachdem, welche du wählst, ändern sich der nötige Rechner und die Kosten grundlegend.

Ein ähnliches Werkzeug ist LM Studio. Grob gesagt: Ollama = rund um Befehle und API gebaut, für Entwickler, Automatisierung und die Anbindung von Agenten; LM Studio = rund um eine Oberfläche gebaut, für alle, die von der Modellsuche bis zum Chat im selben Fenster bleiben wollen. Beide sind kostenlos. Die Unterschiede zwischen lokal und Cloud selbst (Kosten, Leistung, Datenschutz) behandelt unser Vergleich lokaler und Cloud-LLMs.

2. Ollama installieren (Windows / macOS / Linux / Docker)

Die offizielle Download-Seite und das README auf GitHub bieten für jedes Betriebssystem zwei Wege: einen Einzeiler, den du ins Terminal kopierst, oder ein manuelles Installationsprogramm. Beide führen zum selben Ergebnis.

Windows

Wenn du lieber ohne Befehl arbeitest, lade OllamaSetup.exe von der Download-Seite und starte es. Laut der offiziellen Windows-Seite landet die Installation standardmäßig in deinem Benutzerordner, und die Modelle können Dutzende bis Hunderte GB dazu belegen. Ist auf Laufwerk C: wenig Platz, änderst du den Installationsort mit OllamaSetup.exe /DIR="d:\some\location" und den Speicherort der Modelle mit der Umgebungsvariablen OLLAMA_MODELS (Abschnitt 9). Nach der Installation läuft Ollama im Hintergrund, und der Befehl ollama funktioniert in cmd ebenso wie in der PowerShell.

macOS

Für die manuelle Installation öffnest du Ollama.dmg und ziehst die App in den Ordner „Programme“. Beim ersten Start fragt die App um Erlaubnis, einen Link in /usr/local/bin anzulegen, falls der Befehl ollama nicht im PATH ist (offizielle macOS-Seite).

Linux

Die manuelle Installation ohne Skript und das Zusatzpaket für AMD-GPUs beschreibt die offizielle Linux-Seite. Unter Linux gibt es keine App wie unter Windows und macOS; du nutzt Ollama über Befehle und die API.

Docker

Das offizielle Image ollama/ollama liegt auf Docker Hub. So sieht der minimale Start nur mit CPU aus. Für NVIDIA-GPUs installierst du das NVIDIA Container Toolkit und ergänzt --gpus=all, für AMD-GPUs nimmst du das Image ollama/ollama:rocm (offizielle Docker-Seite). Docker Desktop unter macOS kann die GPU nicht nutzen (offizielle FAQ) – auf dem Mac ist die direkt installierte App schneller.

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
docker exec -it ollama ollama run gemma4:e2b

3. Läuft es schnell auf deiner GPU? (unterstützte GPUs im Überblick)

Kann Ollama deine GPU nicht nutzen, weicht es auf die CPU aus. Du siehst also keinen Fehler, aber es wird um ein Vielfaches langsamer. Prüfe vor der Installation, ob deine GPU auf der offiziellen Seite Hardware support steht. Hier das Wichtigste.

Ob ein Modell tatsächlich auf der GPU gelandet ist, zeigt ollama ps, während es geladen ist. Steht in der Spalte PROCESSOR 100% GPU, liegt es komplett auf der GPU; eine Aufteilung wie 48%/52% CPU/GPU bedeutet, dass es nicht in den VRAM gepasst hat (offizielle FAQ). Was du bei einer Aufteilung zurückdrehst, steht in der Tabelle in Abschnitt 9. VRAM-Richtwerte pro GPU findest du im Artikel zu den Hardware-Anforderungen.

4. Ollama-Befehle im Überblick

Diese Tabelle enthält die Befehle aus der offiziellen CLI-Referenz und die im Quellcode (cmd/cmd.go) definierten. Im Alltag brauchst du vor allem die ersten sechs.

ollama run hat einige praktische Optionen. Mit --verbose erscheinen nach jeder Antwort die Laufzeit und die Tokens pro Sekunde (eval rate) – so vergleichst du die Geschwindigkeit in Zahlen, wenn du Modell oder Tag wechselst. --think=false unterdrückt bei Modellen, die ihren Denkprozess ausgeben, diesen Prozess, --format json lässt die Antwort als JSON zurückkommen, und --keepalive 30m ändert, wie lange das Modell im Speicher bleibt. Bei Modellen, die Bilder lesen können, schreibst du einfach den Dateipfad in den Prompt, etwa ollama run gemma4 "Was ist auf diesem Bild? ./photo.png".

Im Chat (nach der Eingabeaufforderung >>>) gibt es eigene Befehle, die mit / beginnen. /bye beendet den Chat, /? listet alle auf, /clear löscht den Gesprächskontext, und /set parameter num_ctx 8192 ändert die Kontextlänge sofort. Mehrere Zeilen auf einmal gibst du ein, indem du sie in """ einschließt.

5. Modelle laden und Tags lesen

Ein Modell wird über Name + Tag angegeben. Lässt du den Tag weg, wird latest verwendet – aber auf welche Größe latest zeigt, unterscheidet sich von Modell zu Modell. Installierst du ohne nachzusehen, landet womöglich eine viel größere Version auf der Platte als gedacht. Am Beispiel der offiziellen Tag-Liste von gemma4 zeigt die Tabelle, wie man Tags liest (Anzeige vom 12. November 2026).

Die Größen sind als Spanne angegeben, weil ein Tag mehrere Formate enthält und das passende für deinen Rechner gewählt wird. Bei gemma4 latest entspricht die Untergrenze von 6,6 GB e4b-it-q4_K_M und die Obergrenze von 9,5 GB e4b-mlx. Im Zweifel nimmst du einen Tag ohne Zusatz (etwa gemma4:e4b), und Ollama wählt das passende Format für deinen Rechner. Die Quantisierungsformate selbst (wie man Q4_K_M bei GGUF liest usw.) behandelt unser Artikel zu Quantisierungsformaten.

Die VRAM-Angaben sind Richtwerte: Modellgröße plus Reserve für das Gespräch (den Kontext). Auch der offizielle Quickstart empfiehlt für gemma4:e2b (im standardmäßig installierten Format etwa 7,2 GB) „8 GB VRAM (bzw. gemeinsamen Speicher auf dem Mac)“. Nach der Installation zeigt ollama show gemma4 Parameterzahl, Quantisierung und Kontextlänge.

6. Mit einer Oberfläche nutzen (Ollama-App, Open WebUI und mehr)

Kein Fan des Terminals? Dann öffne zuerst die App von Ollama selbst. Die Versionen für Windows und macOS enthalten ein Fenster, in dem du ein Modell auswählst und chattest (offizieller Blogbeitrag „Ollama's new app“). Unter Linux gibt es keine App – nimm dort eine der anderen Oberflächen unten.

7. Cloud-Modelle und Preise

Wenn deine GPU ein großes Modell nicht schafft, nutzt du mit denselben Abläufen Cloud-Modelle, die auf den Servern von Ollama laufen. Melde dich mit ollama signin bei ollama.com an und gib einen Namen mit :cloud an, etwa ollama run gemma4:cloud. Ein Download ist nicht nötig (offizielle Cloud-Seite). Die Pläne sehen so aus (Preisseite, Stand: 12. November 2026).

Die Nutzung wird nach dem Preis des jeweiligen Modells pro Million Tokens abgerechnet. Die Cloud-Version von gemma4 kostet zum Beispiel $0,14 für die Eingabe und $0,40 für die Ausgabe. Für 1 Million Eingabe- und 200.000 Ausgabe-Tokens ergibt das 0,14 + 0,40 × 0,2 = etwa $0,22. In diesem Verhältnis reichen die $60 von Pro für rund 270 solcher Durchgänge im Monat (60 ÷ 0,22). Nicht genutztes Guthaben verfällt zum Monatswechsel. Modelle auf deinem eigenen Rechner sind in jedem Plan unbegrenzt und kostenlos.

8. Die API nutzen (OpenAI- und Anthropic-kompatibel)

Die eigentliche Stärke von Ollama ist die lokale API. Standardmäßig lauscht der Server auf 127.0.0.1:11434; schickst du Anfragen dorthin, können deine Apps, Skripte und Tools ein lokales LLM nutzen. Es gibt drei Formate.

/api/chat (den Gesprächsverlauf mitschicken)

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4",
  "messages": [{
    "role": "user",
    "content": "Why is the sky blue?"
  }],
  "stream": false
}'

Die Antwort steht in message.content. Lässt du "stream": false weg, kommt die Antwort Stück für Stück als JSON-Zeilen zurück (Streaming ist der Standard). Für eine einzelne Antwort kannst du auch einen "prompt" an /api/generate schicken. Das Beispiel oben ist für die Shells von macOS und Linux geschrieben; die Windows-PowerShell behandelt Anführungszeichen anders, nimm dort diese Form von der offiziellen Windows-Seite (nur der Modellname ist geändert).

(Invoke-WebRequest -method POST -Body '{"model":"gemma4", "prompt":"Why is the sky blue?", "stream": false}' -uri http://localhost:11434/api/generate ).Content | ConvertFrom-json

OpenAI-kompatibel (/v1)

Mit der offiziellen OpenAI-Bibliothek genügt es, base_url auf Ollama zu richten. Laut der offiziellen Dokumentation ist der API-Schlüssel auf einem lokalen Server „erforderlich, wird aber ignoriert“ – eine beliebige Zeichenfolge reicht also.

from openai import OpenAI

client = OpenAI(
    base_url='http://localhost:11434/v1/',
    api_key='ollama',  # required but ignored
)

chat_completion = client.chat.completions.create(
    messages=[{'role': 'user', 'content': 'Say this is a test'}],
    model='gemma4',
)
print(chat_completion.choices[0].message.content)

Anthropic-kompatibel (Claude Code anbinden)

Laut der offiziellen Seite zur Anthropic-Kompatibilität setzt du für Tools, die auf die API von Anthropic ausgelegt sind, diese zwei Umgebungsvariablen. Auch ohne sie selbst zu setzen, startet ollama launch claude Claude Code direkt verbunden.

export ANTHROPIC_AUTH_TOKEN=ollama  # required but ignored
export ANTHROPIC_BASE_URL=http://localhost:11434

Beide Kompatibilitätsschichten unterstützen nur einen Teil der Original-APIs. Das Responses-Format etwa ist zustandslos, du musst den Gesprächsverlauf also jedes Mal mitschicken. Nutzt du ein lokales Modell mit einem Coding-Agenten, ist die Kontextlänge aus dem nächsten Abschnitt entscheidend.

9. Anpassen (Modelfile, Umgebungsvariablen, Speicher-Tuning)

Modelfile: ein eigenes Modell bauen

Ein Modelfile ist eine Konfigurationsdatei ähnlich einem Dockerfile. Du gehst von einem Basismodell aus (FROM, Pflicht), ergänzt Parameter (PARAMETER) und einen System-Prompt (SYSTEM) und erhältst „dein eigenes Modell“, das sich immer gleich verhält. Ein minimales Beispiel:

FROM gemma4
PARAMETER temperature 0.7
PARAMETER num_ctx 16384
SYSTEM """Du bist ein knapper Assistent. Beginne mit dem Wichtigsten und antworte auf Deutsch."""

Speichere das als Datei namens Modelfile und führe im selben Ordner Folgendes aus. Steht num_ctx im Modelfile, verlängerst du die Kontextlänge nur für dieses Modell, ohne den Standard des ganzen Servers zu ändern.

ollama create my-assistant -f Modelfile
ollama run my-assistant

Das Modelfile eines vorhandenen Modells zeigt ollama show --modelfile gemma4. Es zu kopieren und anzupassen ist der schnellste Einstieg.

Wichtige Umgebungsvariablen

Das Verhalten des Servers steuerst du über Umgebungsvariablen. ollama serve --help gibt die vollständige Liste aus. Hier die gängigsten, mit den Standardwerten aus dem Quellcode (envconfig/config.go) und der offiziellen FAQ.

Wie du sie setzt, hängt vom Betriebssystem ab (offizielle FAQ). Unter Windows beendest du Ollama über die Taskleiste, legst in den Einstellungen für Umgebungsvariablen eine Benutzervariable an und startest Ollama über das Startmenü neu. Unter macOS setzt du sie etwa mit launchctl setenv OLLAMA_HOST "0.0.0.0:11434" und startest die App neu. Unter Linux (mit systemd) gehst du so vor:

systemctl edit ollama.service
# unter [Service] je Variable eine Zeile ergänzen
# Environment="OLLAMA_HOST=0.0.0.0:11434"
systemctl daemon-reload
systemctl restart ollama

Tuning bei wenig Speicher oder langem Kontext

Mit weniger als 24 GiB VRAM beträgt die Standard-Kontextlänge nur 4k (etwa 4.000 Tokens). Die offizielle Seite Context length empfiehlt für Websuche, Agenten und Coding-Tools mindestens 64.000 Tokens. Ist der Kontext zu kurz, vergisst das Modell Früheres, ohne einen Fehler anzuzeigen. Die Tabelle nennt deshalb die Einstellung je Ziel, damit du vom Symptom aus rückwärts suchen kannst.

Prüfe nach einer Änderung mit ollama ps, dass die Spalte CONTEXT die gewünschte Länge zeigt und PROCESSOR weiter 100% GPU meldet. Wie sich die Kontextlänge in Speicher umrechnet, steht im Artikel zu den Hardware-Anforderungen; die Symptome eines Agenten, dem der Kontext ausgeht, beschreibt der Artikel zu Ollama + Cline.

10. Fehlerbehebung

Häufige Stolpersteine und die Lösungen aus der offiziellen FAQ und der Seite Troubleshooting.

Fazit

Ollama führt offene Modelle auf deinem eigenen Rechner oder in der Cloud mit denselben Abläufen aus. Vier Punkte zum Mitnehmen:

• Vor der Installation die GPU prüfen: NVIDIA braucht Compute Capability 5.0 oder höher, AMD die ROCm-v7-Liste oder Vulkan, Macs einen Apple-M-Chip. Läuft es, kontrolliere in ollama ps, ob 100% GPU dasteht.
• Erst den Tag lesen, dann wählen: Was latest enthält, unterscheidet sich je Modell. Achte auf die Größenangabe (e2b, 12b, 31b) und nimm im Zweifel einen Tag ohne Zusatz.
• Die Kontextlänge selbst festlegen: Unter 24 GiB VRAM liegt der Standard bei 4k. Für Agenten werden mindestens 64k empfohlen; Speicher gewinnst du durch Quantisierung des K/V-Caches zurück.
• Tools über API und launch anbinden: Die OpenAI- und Anthropic-kompatiblen APIs und ollama launch machen es für eigene Apps und Claude Code nutzbar. Schwere Modelle laufen mit :cloud.

Öffne als Erstes die App oder tippe ollama run gemma4:e2b. Am besten lernst du es, indem du es laufen lässt und dabei die Unterschiede zur Cloud und die Modellauswahl nachvollziehst. Willst du ein Modell in deinen Editor einbinden, damit es Code schreibt, behandelt Programmieren mit einem lokalen LLM die Einrichtung von Cline und Continue.

FAQ