Claude Code & Ollama: Lokale LLMs installieren, verstehen und integrieren

Wer mit Claude Code arbeitet, kennt die Frage schnell: Was passiert mit sensiblen Daten, die ich ins Modell schicke? Oder: Kann ich auch offline arbeiten? Oder einfach: Kostet jeder API-Call Geld — gibt es eine Alternative? Ollama ist die Antwort auf alle drei Fragen gleichzeitig. Es läuft lokal, kostet nach dem Download nichts mehr pro Anfrage, und die Daten verlassen die eigene Maschine nicht.

Dieser Artikel erklärt, was Ollama ist, wie man es installiert und bedient, welche Modelle für welche Aufgaben geeignet sind — und wie man Claude Code nutzt, um Modelfiles zu schreiben, API-Integrationen zu generieren und den richtigen Kompromiss zwischen lokaler und Cloud-Inferenz zu finden.

1. Was ist Ollama?

Ollama ist ein Open-Source-Tool, das es ermöglicht, Large Language Models lokal auszuführen — auf dem eigenen Laptop oder Server, ohne Cloud-Abhängigkeit. Es lädt Modelle aus einer zentralen Registry, verwaltet sie in einem einheitlichen Format und stellt sie über eine REST-API bereit.

Technisch basiert Ollama auf GGUF (GPT-Generated Unified Format), einem Dateiformat für quantisierte Modelle, das von llama.cpp entwickelt wurde. GGUF-Modelle können auf normaler CPU-Hardware laufen — wenn auch langsamer als auf einer GPU. Mit einer NVIDIA- oder Apple-Silicon-GPU (M1/M2/M3/M4) läuft Ollama signifikant schneller, weil es automatisch CUDA bzw. Metal nutzt.

Was Ollama von anderen lokalen Inferenz-Lösungen unterscheidet: die Einfachheit. Kein Python-Setup, keine CUDA-Konfiguration von Hand, keine Bibliothekskonflikte. Ein Befehl, und das Modell läuft.

2. Installation und grundlegende CLI-Befehle

Die Installation ist bewusst einfach gehalten. Unter macOS und Linux reicht ein Befehl:

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

Unter Windows steht ein Installer auf ollama.com bereit. Nach der Installation läuft Ollama als Hintergrunddienst auf Port 11434.

Die wichtigsten CLI-Befehle

# Modell direkt starten (wird automatisch heruntergeladen falls nicht vorhanden)
ollama run llama3.2

# Modell vorab herunterladen ohne sofort zu starten
ollama pull mistral

# Alle lokal installierten Modelle anzeigen
ollama list

# Ollama-Server explizit starten (läuft normalerweise automatisch)
ollama serve

# Modelinformationen anzeigen
ollama show llama3.2

# Modell entfernen
ollama rm mistral

ollama run öffnet eine interaktive Chat-Session im Terminal. Mit /bye beendet man sie. Alternativ kann man einen einzelnen Prompt direkt übergeben:

ollama run llama3.2 "Erkläre den Unterschied zwischen TCP und UDP in zwei Sätzen."

3. Modelle auswählen: Llama, Mistral, Qwen, Gemma

Die Modellwahl hängt primär vom verfügbaren RAM bzw. VRAM ab. Eine Faustregel: Ein 7B-Modell in 4-Bit-Quantisierung benötigt etwa 4–5 GB RAM; ein 13B-Modell etwa 8–10 GB; ein 70B-Modell etwa 40 GB.

• Llama 3.2 (3B/11B): Metas aktuelles Open-Source-Modell. Die 3B-Variante läuft auf fast jeder Hardware mit 8 GB RAM flüssig. Gut für allgemeine Aufgaben, Code-Erläuterungen und kurze Texte.
• Mistral 7B: Sehr effizient für seine Größe, besonders stark bei Instruktions-Following und strukturierten Outputs. Empfehlenswert als Standardmodell für 8 GB RAM.
• Qwen 2.5 (7B/14B/72B): Alibabas Modellreihe mit besonderer Stärke bei Code-Generierung und mehrsprachigen Aufgaben. Die 14B-Variante übertrifft in Benchmarks häufig deutlich größere Modelle anderer Anbieter.
• Gemma 2 (9B/27B): Googles kompakte Modelle, optimiert für Reasoning und mathematische Aufgaben. Die 9B-Variante mit 16 GB RAM ist eine starke Wahl für analytische Anwendungsfälle.

4. Modelfile: Eigene Modelle konfigurieren

Ein Modelfile ist eine Konfigurationsdatei, mit der man ein bestehendes Basismodell anpassen und als neues Modell speichern kann. Das Konzept ist ähnlich wie ein Dockerfile für Container.

# Modelfile für einen deutschen Code-Assistenten
FROM qwen2.5-coder:7b

PARAMETER temperature 0.2
PARAMETER top_p 0.9
PARAMETER num_ctx 8192

SYSTEM """
Du bist ein erfahrener Software-Entwickler und Code-Assistent.
Antworte immer auf Deutsch, es sei denn, der Code selbst erfordert Englisch.
Erkläre komplexe Konzepte klar und gib immer funktionierende Beispiele.
Bei Fehlern: zeige zuerst die Ursache, dann den Fix.
"""

Die wichtigsten Modelfile-Direktiven:

• FROM: Das Basismodell (lokal oder aus der Registry)
• PARAMETER temperature: Kreativität (0.0–1.0; für Code 0.1–0.3 empfohlen)
• PARAMETER num_ctx: Kontextfenster in Tokens (Standard: 2048)
• SYSTEM: System-Prompt, der immer am Anfang jeder Unterhaltung steht

Modell aus dem Modelfile erstellen und verwenden:

ollama create mein-code-assistent -f Modelfile
ollama run mein-code-assistent

5. REST-API: localhost:11434

Ollama stellt automatisch eine REST-API bereit, sobald der Dienst läuft. Zwei Endpunkte sind zentral:

/api/generate — Einzelner Completion-Request

curl http://localhost:11434/api/generate \
  -d '{
    "model": "llama3.2",
    "prompt": "Was ist der Unterschied zwischen var, let und const in JavaScript?",
    "stream": false
  }'

Mit "stream": true (Standard) liefert die API die Antwort als Server-Sent Events — Token für Token, wie man es von ChatGPT kennt. Mit "stream": false wartet die API, bis die Antwort vollständig ist.

/api/chat — Multi-Turn Konversation

curl http://localhost:11434/api/chat \
  -d '{
    "model": "mistral",
    "stream": false,
    "messages": [
      {"role": "system", "content": "Antworte immer auf Deutsch."},
      {"role": "user", "content": "Erkläre Promises in JavaScript."},
      {"role": "assistant", "content": "Promises sind..."},
      {"role": "user", "content": "Und wie unterscheiden sich diese von async/await?"}
    ]
  }'

6. Python-Integration und OpenAI-kompatible API

Ollama bietet eine OpenAI-kompatible API unter /v1/ — was bedeutet, dass jeder Code, der das OpenAI Python SDK verwendet, mit einer einzigen Änderung gegen Ollama laufen kann:

from openai import OpenAI

# Statt api.openai.com einfach localhost:11434/v1 verwenden
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Kann ein beliebiger Wert sein, wird ignoriert
)

response = client.chat.completions.create(
    model="qwen2.5-coder:7b",
    messages=[
        {"role": "user", "content": "Schreibe eine Python-Funktion zum Parsen von CSV-Dateien."}
    ]
)

print(response.choices[0].message.content)

Das ist besonders wertvoll, wenn man bestehende Projekte testen möchte: einfach base_url ändern, und der gesamte Code läuft lokal. Keine API-Kosten, kein Datenschutzproblem, kein Rate-Limiting.

7. Claude Code & Ollama: Praxistipps

Claude Code und Ollama ergänzen sich — nicht als Konkurrenten, sondern als Werkzeuge für unterschiedliche Aufgaben. Hier sind die vier Anwendungsfälle, die im Alltag den größten Unterschied machen:

Modelfiles schreiben lassen

Ein gutes Modelfile zu schreiben ist nicht trivial — die richtigen Parameter-Werte für den eigenen Anwendungsfall zu finden erfordert Erfahrung. Claude Code kann das übernehmen:

claude "Schreibe ein Ollama Modelfile für einen deutschen Kundensupport-Agenten
basierend auf mistral. Ich brauche: niedrige Temperatur für deterministische Antworten,
Kontext von mindestens 4096 Tokens, und einen System-Prompt der freundlich aber präzise ist."

API-Integration generieren

Statt die Ollama-API-Dokumentation manuell durchzulesen, kann Claude Code fertige Integration für den eigenen Stack generieren:

claude "Erstelle eine TypeScript-Klasse OllamaClient mit Methoden für
generate() und chat(). Nutze die Ollama REST-API auf localhost:11434.
Implementiere Streaming mit AsyncIterator und ordentlichem Error-Handling."

Lokale vs. Cloud-Abwägung

Nicht jede Aufgabe braucht Cloud-Inferenz. Als Faustregel: einfache, repetitive Aufgaben (Zusammenfassungen, Klassifizierungen, einfache Code-Erläuterungen) läuft gut lokal mit einem 7B-Modell. Komplexe Reasoning-Aufgaben, Code-Generierung für kritische Systeme oder mehrsprachige Nuancen — da lohnt sich Claude oder GPT-4-Klasse.

Claude Code kann helfen, diese Grenze zu ziehen:

claude "Analysiere diese Pipeline: [Beschreibung]. Welche Schritte können
lokal mit einem 7B-Ollama-Modell laufen, welche brauchen ein stärkeres Modell?"

Quantisierung verstehen

Bei Ollama-Modellen sieht man oft Suffixe wie :q4_0, :q4_K_M, :q8_0. Das sind Quantisierungsstufen — vereinfacht: wie viele Bits pro Modell-Gewicht gespeichert werden.

• q4_K_M: 4-Bit-Quantisierung mit mittlerer Kalibrierung — guter Kompromiss aus Qualität und Geschwindigkeit, empfohlen für die meisten Anwendungsfälle
• q8_0: 8-Bit — bessere Qualität, doppelt so viel RAM-Bedarf
• fp16: Volle Präzision — maximale Qualität, braucht viel VRAM, meist nur für High-End-GPUs sinnvoll

Für die meisten Anwendungsfälle ist q4_K_M der Sweet Spot: Die Qualitätseinbuße gegenüber dem vollen Modell ist bei gut designten Modellen gering — der Geschwindigkeits- und RAM-Vorteil dagegen erheblich.

Zwei verwandte Artikel, die auf diesem Thema aufbauen:

• Claude Code für Python-Projekte — wie du Claude Code in Python-Workflows einsetzt
• Claude Code Debugging — Stack Traces, Log-Analyse und Root-Cause-Finden