Warum LLMs lokal betreiben?

  • Privatsphäre: Deine Daten verlassen deinen Rechner nie.
  • Kosten: Keine Kosten pro Token nach der Einrichtung.
  • Geschwindigkeit: Keine Netzwerklatenz für Inferenz.
  • Offline: Funktioniert ohne Internetverbindung.

Ollama installieren

  • Download von ollama.com — verfügbar für macOS, Linux und Windows.
  • Führe 'ollama pull gemma3' aus, um ein Modell herunterzuladen.
  • Lauf 'ollama run gemma3', um mit dem Chatten anzufangen.

Beliebte Modelle

  • Qwen3 8B: Ausgewogene Standardwahl, 5,2 GB Download, 40K Kontext.
  • Gemma 3 12B: Googles multimodales Modell, 8,2 GB, 128K Kontext.
  • DeepSeek-R1 8B: Auf Schlussfolgern ausgerichtetes Destillat, 5,2 GB, 128K Kontext.
  • Qwen3-Coder 30B: Codemodell mit Mixture-of-Experts, 19 GB, will eine 24-GB-GPU.
  • Phi-4 14B: Microsofts kompaktes Schlussfolgerungsmodell, 9,1 GB, 16K Kontext.

Größen und Kontextfenster sind die von Ollama je Tag veröffentlichten Werte (geprüft am 2026-11-10).

Nutzung der API

Ollama stellt unter 'http://localhost:11434' eine lokale REST-API bereit.

  • 'POST /api/generate' — Textgenerierung.
  • 'POST /api/chat' — Chat-Abschlüsse.
  • Kompatibel mit dem OpenAI SDK über Basis-URL-Überschreibung.

Beide Endpunkte verlangen ein Feld 'model' mit einem bereits geladenen Tag ('ollama list' zeigt sie); die API-Referenz führt es als erforderlich. Der minimale Body einer Chat-Anfrage ist `{"model": "gemma3", "messages": [{"role": "user", "content": "hello"}]}`; an '/api/chat' gesendet, liefert Ollama JSON-Objekte als Stream.

Mit "stream": false kommt ein einzelnes Objekt mit der vollständigen Antwort und den Zeitstatistiken zurück.

Integrationstipps

  • Verwendung mit LangChain über die 'OllamaLLM'-Klasse.
  • Verwendung mit Open WebUI für eine ChatGPT-ähnliche Oberfläche.
  • GPU-Beschleunigung: Funktioniert mit NVIDIA (CUDA) und Apple Silicon (Metal).

Leistungserwartungen

  • 7B-Modell auf dem M2 MacBook: ~30 Token/Sekunde.
  • 7B-Modell auf RTX 4090: ~60 Token/Sekunde.
  • 70B-Modell mit 48GB RAM (CPU): ~3 Token/Sekunde. Die 43 GB Download lassen kaum Spielraum für einen langen Kontext.

Das richtige lokale Modell wählen

Deine Wahl hängt von Hardware und Anwendungsfall ab. Zum Programmieren auf einem Laptop funktionieren Qwen2.5-Coder 7B (4,7 GB) oder Llama 3.1 8B (4,9 GB) mit 4-Bit-Quantisierung sehr gut. Für allgemeine Konversation bieten Qwen3 8B (5,2 GB) oder Gemma 3 12B (8,2 GB) eine gute Balance. Eine 24-GB-GPU nimmt Qwen3-30B-A3B mit seinen 19 GB auf; Llama 3.1 70B sind 43 GB Download, brauchen also 48 GB Arbeitsspeicher oder mehr, nicht 24 GB.

Leistungsoptimierung

  • Quantisierung: Q4_K_M bietet das beste Verhältnis von Qualität zu Größe. Q5_K_M ist etwas besser, aber 20 % größer. Meide Q2/Q3, außer wenn unbedingt nötig – die Qualität fällt stark ab.
  • Kontextlänge: Standard sind meist 2048 oder 4096 Token. Erhöhe sie nur bei Bedarf – längere Kontexte brauchen mehr RAM.
  • GPU-Offloading: Nutze --n-gpu-layers, um so viele Schichten auszulagern, wie der VRAM erlaubt. Mehr auf der GPU bedeutet mehr Geschwindigkeit.
  • Batch-Größe: Erhöhe --batch-size für schnellere Prompt-Verarbeitung, wenn der VRAM es zulässt.

Häufige Fallstricke

Der Fehler Nummer eins ist, Modelle laufen zu lassen, die für die eigene Hardware zu groß sind. Ein 70B-Modell mit 16 GB RAM wird schmerzhaft langsam sein (1-2 Token pro Sekunde). Besser ist ein 7B-Modell mit 30 oder mehr Token pro Sekunde. Der Fehler Nummer zwei ist, den System-Prompt zu ignorieren – lokale Modelle reagieren sehr empfindlich darauf. Ein gut formulierter System-Prompt kann aus einem mittelmäßigen Modell einen nützlichen Assistenten machen.

Miss Tokens pro Sekunde, bevor du ein Modell wählst

Die veröffentlichte Parameterzahl sagt fast nichts darüber, ob ein Modell auf deiner Maschine nutzbar ist. Entscheidend ist die Generierungsgeschwindigkeit in Tokens pro Sekunde auf deiner Hardware, und diese Zahl hängt weit mehr von der Speicherbandbreite ab als von roher Rechenleistung. Ein Modell, das in den Speicher passt, aber kaum schneller generiert, als du liest, ist frustrierend; eines mit dreißig Tokens pro Sekunde fühlt sich wie ein Gespräch an. Stoppe es selbst mit einem festen Prompt bekannter Ausgabelänge, bevor du dich auf eine Größe festlegst.

Passt ein Modell nicht in den Speicher, läuft es nicht langsamer, sondern auf der CPU – typischerweise eine Größenordnung schlechter. Die Passfrage ist also binär und kommt zuerst: Prüfe den Speicherbedarf bei deiner gewählten Quantisierung gegen den verfügbaren Speicher und lass Platz für Betriebssystem und Kontext.

Quantisierung ist der Haupthebel

Von sechzehn auf acht oder vier Bit zu gehen halbiert und viertelt den Speicherbedarf ungefähr, und für viele Aufgaben ist der Qualitätsunterschied klein genug, um in deiner eigenen Evaluation unsichtbar zu sein. Umsonst ist es nicht: rechenintensive Aufgaben und Retrieval über langen Kontext degradieren stärker als flüssige Konversation. Teste mit der Quantisierung, die du ausliefern willst, statt anzunehmen, die Variante oben in der Datei sei das, was deine Nutzer sehen.

Wo lokale Modelle wirklich gewinnen

Datenschutz, Offline-Betrieb, planbare Kosten und Freiheit von Rate Limits. Ein lokales Modell, das eine Klassifizierungsaufgabe mit fünf Tokens pro Sekunde erledigt und nie deinen Laptop verlässt, ist für Arbeit, die du nirgendwohin senden kannst, besser als ein gehostetes. Sei auch beim Umgekehrten ehrlich: Bei offenem Reasoning und Codegenerierung liegt die gehostete Frontier weiterhin deutlich vorn, und das Gegenteil vorzugeben kostet deine Nutzer Qualität.