Zum Hauptinhalt springen

KI-Modelle lokal ausführen mit Ollama

Fortgeschritten

Die Frontier-Modelle leben in der Cloud, aber eine ganze Klasse von Open-Weight-Modellen — Llama, Mistral, Qwen, DeepSeek, Gemma — kannst du herunterladen und auf deinem eigenen Laptop oder Server ausführen. Ollama ist der einfachste Weg dafür: eine Installation, ein Befehl, und ein Modell läuft lokal. Diese Seite bringt dich von null bis zu einem laufenden Modell, dem Aufruf aus dem Code und dem Verständnis der Kompromisse — damit du nicht erwartest, dass sich ein lokales 7B-Modell wie ein Frontier-Modell verhält.

What you'll learn
  • Verstehen, WARUM du ein Modell lokal ausführen würdest — und die ehrlichen Kompromisse gegenüber Frontier-Cloud-Modellen
  • Ollama installieren und dein erstes Modell in zwei Befehlen ausführen
  • Die Kern-CLI nutzen: pull, run, list, ps, rm, stop
  • Dein lokales Modell aus dem Code über Ollamas OpenAI-kompatible API aufrufen
  • RAM-Bedarf, Modellgrößen und Quantisierung verstehen — damit du ein Modell wählst, das deine Maschine tatsächlich ausführen kann
  • Wissen, wann LM Studio (eine GUI) der bessere Ausgangspunkt ist

Warum ein Modell lokal ausführen (und wann nicht)​

Ein Modell auf deiner eigenen Hardware auszuführen, bringt dir vier Dinge:

  • Datenschutz — deine Prompts und Daten verlassen niemals deine Maschine. Der Grund, warum Teams in regulierten oder sensiblen Bereichen zu lokalen Modellen greifen. (Siehe die Datenschutz-/Self-Host-Verzweigung in Ein Modell auswählen.)
  • Offline — kein Internet, keine API, keine Abhängigkeit von Ausfällen. Das Modell ist eine Datei auf deiner Festplatte.
  • Kosten — keine Rechnung pro Token. Einmal heruntergeladen, ist die Ausführung „kostenlos" (du zahlst in Strom und Hardware, nicht in API-Ausgaben). Wenn Token-Ausgaben bei großem Maßstab deine Einschränkung sind, kann lokal gewinnen.
  • Kontrolle — eine exakte Version fixieren, das Verhalten anpassen und ohne Rate-Limits oder Überraschungen bei den Nutzungsbedingungen integrieren.

Die ehrlichen Kompromisse:

  • Fähigkeitslücke. Ein Modell, das du auf einem Laptop ausführen kannst (1B–14B Parameter), spielt bei schwierigem Reasoning, langem Kontext oder agentischen Aufgaben nicht in derselben Liga wie ein Frontier-Cloud-Modell. Bei vielen Alltagsaufgaben ist die Lücke klein; bei den schwierigsten ist sie groß.
  • Hardware. Größere, fähigere Modelle brauchen mehr RAM/VRAM, als eine typische Maschine hat. Oft wählst du das größte Modell, das deine Hardware ausführen kann, nicht das beste Modell, das existiert.
  • Du betreibst es. Kein verwaltetes Skalieren, keine automatischen Upgrades — das ist der Preis der Kontrolle.

Ein verbreitetes, dauerhaftes Muster: Prototyp erstellen und auswählen mit einem winzigen Eval (gleiche Methode wie bei Cloud-Modellen — siehe Ein Modell auswählen), lokal für private/offline/günstig-im-großen-Maßstab-Arbeit nutzen und zu einer Frontier-API greifen, wenn die Aufgabe wirklich die zusätzliche Fähigkeit braucht.

Ollama installieren und dein erstes Modell ausführen​

Guided walkthrough1 of 4
  1. macOS und Windows: Lade das Installationsprogramm von ollama.com/download herunter und führe es aus. Linux: Nutze das offizielle Installationsskript (unten). Dies installiert den Befehl ollama und einen lokalen Hintergrunddienst.

Linux-Installation (macOS/Windows nutzen stattdessen das heruntergeladene Installationsprogramm):

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

Ein kleines Modell herunterladen und ausführen (gute erste Wahl)

ollama run llama3.2

Dieser eine Befehl lädt sowohl llama3.2 herunter (ein kleines Modell der 1B/3B-Klasse, das auf bescheidener Hardware läuft) als auch startet einen interaktiven Chat. Um herunterzuladen, ohne schon zu chatten, nutze stattdessen ollama pull.

Die Kern-CLI​

Eine Handvoll Befehle deckt fast alles ab. Führe ollama --help aus, um die vollständige Liste zu sehen.

# Ein Modell herunterladen, ohne einen Chat zu starten
ollama pull qwen3

# Einen interaktiven Chat starten (lädt bei Bedarf zuerst herunter)
ollama run qwen3

# Einmalig: den Prompt inline übergeben, die Antwort erhalten, beenden
ollama run qwen3 "Summarize the CAP theorem in two sentences."

# Heruntergeladene Modelle auflisten
ollama list

# Aktuell im Speicher geladene Modelle anzeigen
ollama ps

# Ein laufendes/geladenes Modell stoppen (gibt Speicher frei)
ollama stop qwen3

# Ein heruntergeladenes Modell löschen, um Speicherplatz zurückzugewinnen
ollama rm qwen3

Tippe innerhalb einer interaktiven ollama run-Sitzung /bye, um zu beenden, und /?, um die Befehle innerhalb der Sitzung zu sehen. Der Hintergrunddienst, der die Modelle tatsächlich bereitstellt, wird von ollama serve gestartet (die Desktop-App startet ihn automatisch für dich).

Aus dem Code aufrufen (OpenAI-kompatible API)​

Das ist der Teil, der lokale Modelle in Apps wirklich nützlich macht. Der Ollama-Hintergrunddienst stellt eine lokale HTTP-API unter http://localhost:11434 bereit, auf dem Standardport 11434. Er hat eigene native Endpunkte (/api/generate, /api/chat) und eine OpenAI-kompatible Schicht unter /v1 — sodass der meiste für das OpenAI-SDK geschriebene Code mit deinem lokalen Modell funktioniert, indem du zwei Zeilen änderst.

Rohes HTTP mit curl (nativer Endpunkt):

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

Aus Python mit dem offiziellen OpenAI-SDK — richte einfach base_url auf Ollama und übergib einen beliebigen nicht-leeren api_key (Ollama verlangt das Feld, ignoriert aber dessen Wert):

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # required by the SDK, ignored by Ollama
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain gradient descent in two sentences."},
    ],
)

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

Da es OpenAI-kompatibel ist, übertragen sich dieselben Muster, die du gegen eine gehostete API nutzen würdest — einschließlich Streaming und Tool Use / Function Calling, die lokal genauso funktionieren wie in der Cloud (vorausgesetzt, das Modell ist tatsächlich gut darin). Ollamas /v1-Schicht deckt unter anderem /v1/chat/completions, /v1/completions, /v1/models und /v1/embeddings ab.

Hardware, Modellgrößen und Quantisierung​

Die Zahl, die du an einem Modell siehst — 1B, 7B, 8B, 70B — ist seine Parameteranzahl (in Milliarden). Mehr Parameter bedeutet im Allgemeinen fähiger und speicherhungriger. Die praktische Grenze für das, was du ausführen kannst, ist RAM (und bei einer GPU VRAM).

Quantisierung ist der Schlüsseltrick, der dies auf normalen Maschinen möglich macht. Die Gewichte des Modells werden ursprünglich in hoher Präzision gespeichert (z. B. 16-Bit), können aber auf ~4-Bit komprimiert werden, mit geringen, oft kaum spürbaren Qualitätseinbußen. Ollama liefert die meisten Modelle standardmäßig quantisiert aus — deshalb passt ein Modell mit Milliarden von Parametern in wenige GB. Eine grobe Faustregel (gegen die Seite des spezifischen Modells überprüfen):

  • ~1B–3B-Modelle: laufen bequem auf den meisten modernen Laptops (ein paar GB RAM).
  • ~7B–8B-Modelle: der Sweet Spot für fähig-und-doch-ausführbar; rechne mit mehreren GB freiem RAM.
  • ~13B–14B-Modelle: brauchen eine recht gut ausgestattete Maschine.
  • ~70B+-Modelle: brauchen eine Workstation/einen Server mit viel RAM oder einer starken GPU — kein typisches Laptop-Terrain.

Ein praktisches Rezept: Beginne mit einem kleinen Modell (llama3.2), bestätige den Workflow von Anfang bis Ende und skaliere dann hinauf zum größten Modell, das auf deiner Hardware noch flüssig läuft — nicht zum größten, das existiert.

Vokabular für lokale Modelle
Drücke Enter oder die Leertaste, um die Karte umzudrehen. Nutze die Pfeiltasten links und rechts, um zwischen den Karten zu wechseln.Begriff angezeigt.
1 / 6

LM Studio: eine GUI-Alternative​

Wenn die Kommandozeile nicht dein Ding ist, ist LM Studio eine Desktop-App (macOS, Windows, Linux), die dieselbe Aufgabe über eine grafische Oberfläche erledigt: offene Modelle durchsuchen und herunterladen, mit ihnen in einer eingebauten UI chatten und — wie Ollama — einen lokalen OpenAI-kompatiblen Server ausführen, damit dein Code mit ihm sprechen kann. Es ist der einfachere Einstieg für Nicht-Entwickler oder alle, die Point-and-Click einem Terminal vorziehen; Ollama tendiert dazu zu gewinnen, wenn du eine skriptbare CLI und einen leichtgewichtigen Hintergrunddienst möchtest. Beide führen dieselben Arten von Open-Weight-Modellen aus, sodass sich die Konzepte auf dieser Seite direkt übertragen.

Überprüfe dich selbst

0/4
  1. Was ist der einzelne größte ehrliche Kompromiss, ein Modell lokal auszuführen statt ein Frontier-Cloud-Modell?
  2. Welcher Befehl lädt sowohl ein Modell herunter (falls nötig) ALS AUCH startet einen Chat damit?
  3. Um dein lokales Modell aus OpenAI-SDK-Code aufzurufen, was setzt du?
  4. Warum kann ein Modell mit Milliarden von Parametern in nur wenige GB RAM passen?
Key takeaways
  • Lokal = Datenschutz + offline + keine Kosten pro Token + Kontrolle; der Kompromiss ist eine echte Fähigkeitslücke und Hardware-Grenzen.
  • Zwei Befehle bringen dich zum Laufen: Ollama installieren, dann ollama run llama3.2.
  • Kern-CLI: pull (herunterladen), run (chatten), list, ps, stop, rm — das ist das meiste davon.
  • Aus dem Code über den OpenAI-kompatiblen Endpunkt aufrufen: base_url http://localhost:11434/v1, beliebiger nicht-leerer api_key.
  • Parameteranzahl + Quantisierung entscheiden, ob deine Maschine ein Modell ausführen kann — klein anfangen, hochskalieren auf das, was flüssig läuft.
  • Lieber eine GUI? LM Studio erledigt dieselbe Aufgabe per Point-and-Click und stellt ebenfalls einen lokalen OpenAI-kompatiblen Server bereit.

Quellen & weiterführende Literatur​

Weiter​