TL;DR — Was du nach diesem Artikel hast
- Drei Wege, ein lokales LLM zu installieren — Ollama, LM Studio, llama.cpp.
- Realistische Hardware-Tabelle: was läuft auf 16 GB RAM, was braucht 24+ GB VRAM.
- In 30 Minuten erstes Modell lauffähig — getestet auf Windows, Mac, Linux.
- Ollama als Agent-Backend: wie du lokale LLMs in deine Agent-Pipeline einbindest.
- Performance-Tipps speziell für AMD-GPUs und CPU-only-Setups.
Wenn du KI-Agents baust, die personenbezogene Daten verarbeiten — Kundenmails sortieren, Bewerbungen vorfiltern, interne Dokumente zusammenfassen — hast du ein Problem: Cloud-APIs bedeuten, dass Daten dein Netzwerk verlassen. Ein lokales LLM löst das. DSGVO-konforme Agent-Setups, keine API-Kosten bei hohem Durchsatz, volle Kontrolle über Modell und Daten. Das ist die Grundlage für privacy-sensitive Agents, die du produktiv einsetzen kannst, ohne juristische Bauchschmerzen.
In diesem Artikel zeige ich dir, wie du ein lokales LLM aufsetzen kannst — mit Fokus darauf, wie Ollama als Backend für Agent-Pipelines funktioniert. Wenn du stattdessen (oder zusätzlich) eine Cloud-API nutzen willst, schau dir Erster KI-Agent mit der Claude API an — das ist das API-Gegenstück zu diesem Setup.
Welche LLMs lohnen sich 2026 lokal?
Die Open-Weight-Modelle haben in den letzten 18 Monaten massiv aufgeholt. Vier Modelle, die ich aktuell empfehle:
Llama 3.3 70B (Meta) — der aktuelle Standard für lokale Allzweck-Anwendungen. Quantisiert auf 4-bit läuft es auf 40 GB VRAM oder via CPU+RAM-Mix.
Mistral Small 3 (Mistral AI) — ~22B Parameter, hervorragendes Englisch und Französisch, brauchbares Deutsch. Effizienter als Llama bei vergleichbarer Qualität.
Qwen 2.5 (Alibaba) — 7B-, 14B-, 32B-, 72B-Varianten verfügbar. Stark bei Code und Reasoning, hat in Benchmarks Llama oft eingeholt.
Phi-4 (Microsoft) — 14B Parameter, kompakt, reasoning-stark. Ideal für CPU-Setups oder GPUs mit begrenztem VRAM.
Quantisierungs-Erklärung in einem Satz: Quantisierung komprimiert ein Modell — statt 16-bit-Gleitkommazahlen werden Gewichte in 8-bit oder 4-bit gespeichert. Faustformel: Q4_K_M (4-bit, K-Quant) ist der Sweet-Spot zwischen Speicherbedarf und Qualität für die meisten Use-Cases.
Meine aktuelle Modell-Wahl (alle auf Ollama, RX 7900 XTX 24 GB):
- Llama 3.3 70B Q4_K_M — Allzweck-Schreiben, Brainstorming, lange Texte. Gefühlt mein „Claude-Ersatz” für DSGVO-kritische Inhalte.
- Qwen 2.5 32B — Code-Reviews und Refactoring-Vorschläge. Bei TypeScript/Python-Tasks merklich besser als Llama 3.3.
- Mistral Small 3 (22B) — schnelle Klassifizierung, Auto-Tagging, Email-Sortierung. Wenn ich Speed über Tiefe brauche.
- Phi-4 (14B) — wenn ein Gast-Laptop ohne 24 GB GPU mitspielen muss. Erstaunlich gut für so klein.
Hardware-Anforderungen ehrlich
Diese Tabelle ist die wichtigste in diesem Artikel. Wer hier die falschen Erwartungen hat, ist nach dem Setup frustriert.
| Modell-Größe | RAM (CPU-Mode) | VRAM (GPU-Mode) | Realistische Speed |
|---|---|---|---|
| 7B (Q4) | 8 GB | 5 GB | 30+ tok/s GPU, 6 tok/s CPU |
| 13–14B (Q4) | 12 GB | 9 GB | 20 tok/s GPU, 3 tok/s CPU |
| 32B (Q4) | 24 GB | 20 GB | 12 tok/s GPU, kaum CPU-tauglich |
| 70B (Q4) | 48 GB | 40 GB | 5–8 tok/s GPU, nicht CPU-tauglich |
„Tokens pro Sekunde” kannst du grob als „Wörter pro Sekunde” lesen — ChatGPT antwortet mit ~30 Tokens/s, also ungefähr Lesegeschwindigkeit. Alles unter 5 tok/s wirkt zäh.
Für Agent-Pipelines wichtig: Agents senden viele kurze Anfragen hintereinander. Hier zählt nicht nur tok/s, sondern auch die Latenz bis zum ersten Token (Time-to-First-Token). Kleinere Modelle wie Qwen 2.5 14B oder Mistral Small 3 sind für Agent-Loops oft praktischer als ein 70B-Modell, das pro Anfrage 2 Sekunden Anlaufzeit braucht.
Meine konkreten Speeds auf der RX 7900 XTX 24 GB unter Linux mit ROCm 7.1:
| Modell | Quantisierung | Speed |
|---|---|---|
| Llama 3.3 70B | Q4_K_M | ~7 tok/s (knapp am VRAM-Limit) |
| Qwen 2.5 32B | Q4_K_M | ~15 tok/s |
| Mistral Small 3 (22B) | Q4_K_M | ~25 tok/s |
| Llama 3.2 8B | Q4_K_M | ~80 tok/s |
Auf Windows mit DirectML-Backend wären das etwa Faktor 1.5 langsamer — Linux + ROCm ist für AMD-GPUs deutlich performanter.
Weg 1 — Ollama (einfachster Einstieg)
Ollama ist der pragmatischste Einstieg. Ein Tool, ein Befehl, läuft.
Installation Windows / Mac / Linux
# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh
# Windows: Installer von ollama.com runterladen, ausführenNach Install läuft Ollama als Hintergrund-Service auf Port 11434.
Erste Modelle laden
ollama pull llama3.3:70b
ollama pull qwen2.5:14b
ollama pull mistral-small
# Testen
ollama run llama3.3:70bBeim ersten pull lädt das Modell — bei 70B-Modellen sind das ~40 GB Download. Plan ein.
Als API-Server nutzen
Ollama bietet eine OpenAI-kompatible API auf http://localhost:11434/v1/. Heißt: Tools, die ChatGPT-API erwarten, kannst du oft mit minimalem Aufwand auf Ollama umstellen — nur die Base-URL austauschen.
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "llama3.3:70b",
"messages": [{"role": "user", "content": "Hi"}]
}'Mein typischer Ollama-Workflow (Claude-API-Drop-In für DSGVO-kritische Tasks):
# Modell pullen falls noch nicht da
ollama pull qwen2.5:32b
# Quick-Test im Terminal
ollama run qwen2.5:32b "Was sind die DSGVO-Pflichten bei einem Newsletter mit Brevo?"
# REST-API von Skript aus aufrufen
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "qwen2.5:32b",
"messages": [
{"role": "system", "content": "Du antwortest auf Deutsch, sachlich, ohne Disclaimer."},
{"role": "user", "content": "Erklaere mir Quantisierung in 3 Saetzen."}
]
}'OpenAI-kompatible API auf Port 11434 — heißt: jedes Tool, das die OpenAI-API spricht, kannst du mit Base-URL-Tausch auf Ollama umstellen.
Ollama als Agent-Backend
Wenn du einen KI-Agent baust, brauchst du im Kern drei Dinge: eine Steuerungslogik (Orchestrator), Tools (APIs, Dateizugriff, Datenbanken) und ein LLM als „Denkschicht”. Ollama übernimmt die dritte Rolle — es stellt das LLM bereit, das dein Agent für Reasoning, Klassifizierung und Textgenerierung nutzt.
Warum lokale LLMs für Agents?
Kosten bei hohem Volumen. Ein Agent, der 500 Kundenanfragen pro Tag klassifiziert, produziert bei der Claude API schnell dreistellige Monatskosten. Lokal: einmalig Hardware, danach 0 Euro pro Request.
DSGVO ohne Auftragsverarbeitung. Wenn dein Agent Bewerbungsdaten, Patientenakten oder interne Strategiedokumente verarbeitet, ist ein lokales Setup der sauberste Weg — keine Datenübertragung an Dritte, keine AVV nötig.
Latenz-Kontrolle. Dein Agent wartet nicht auf Netzwerk-Roundtrips. Bei einem Multi-Step-Agent mit 5 LLM-Aufrufen pro Task summiert sich das.
Architektur: Ollama in der Agent-Pipeline
┌─────────────────────────────────────────────┐
│ Orchestrator (Python / Node.js / n8n) │
│ ┌─────────┐ ┌──────────┐ ┌───────────┐ │
│ │ Schritt 1│→│ Schritt 2 │→│ Schritt 3 │ │
│ └────┬─────┘ └────┬─────┘ └────┬──────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ Ollama API Ollama API Ollama API │
│ (localhost:11434) │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ qwen2.5:14b mistral-small llama3.3:70b │
└─────────────────────────────────────────────┘Du kannst pro Agent-Schritt ein anderes Modell wählen: ein kleines, schnelles Modell für Klassifizierung (Mistral Small), ein mittleres für Zusammenfassungen (Qwen 2.5 14B), ein großes für komplexes Reasoning (Llama 3.3 70B). Ollama handhabt das Modell-Laden automatisch.
Praktisches Beispiel: Agent-Call via Python
import requests
def agent_llm_call(prompt: str, model: str = "qwen2.5:14b") -> str:
"""Ein LLM-Aufruf in deiner Agent-Pipeline via Ollama."""
response = requests.post(
"http://localhost:11434/v1/chat/completions",
json={
"model": model,
"messages": [
{"role": "system", "content": "Du bist ein hilfreicher Assistent. Antworte präzise."},
{"role": "user", "content": prompt}
],
"temperature": 0.3 # niedriger für deterministischere Agent-Outputs
}
)
return response.json()["choices"][0]["message"]["content"]
# Klassifizierungs-Schritt
kategorie = agent_llm_call(
"Klassifiziere diese Kundenanfrage in eine Kategorie (Reklamation, Frage, Lob): "
"'Mein Paket ist seit 5 Tagen nicht angekommen.'",
model="mistral-small"
)
# Antwort-Generierung
antwort = agent_llm_call(
f"Erstelle eine freundliche Antwort auf diese {kategorie}: ...",
model="qwen2.5:32b"
)Wenn du stattdessen die Claude API als LLM-Backend nutzen willst — etwa weil du mehr Reasoning-Tiefe brauchst oder keine lokale GPU hast — findest du das Setup unter Erster KI-Agent mit der Claude API.
Weg 2 — LM Studio (mit GUI, einsteigerfreundlich)
LM Studio ist die GUI-Variante. Wer sich am Terminal nicht wohl fühlt: hier richtige Click-Through-Erfahrung.
Installation: Installer von der Website runterladen, ausführen, fertig.
Modelle finden: Eingebauter Browser für Hugging Face — du suchst „Llama 3.3” oder „Qwen 2.5”, siehst alle verfügbaren Quantisierungs-Varianten mit Größenangabe und Hardware-Empfehlung.
Chat-Interface: Einfacher Chat eingebaut, plus den lokalen API-Server (auch OpenAI-kompatibel).
LM Studio ist Closed-Source, hat aber einen sehr klaren UX-Vorteil für Einsteiger. Wenn du dich später auskennst und Skript-Workflows baust, ist Ollama meistens praktischer.
Weg 3 — llama.cpp (für Fortgeschrittene)
llama.cpp ist die C++-Engine, auf der Ollama und LM Studio aufbauen. Wer maximal Performance und Kontrolle will, kompiliert llama.cpp selbst.
Wann sinnvoll: Custom-Quantisierungen, exotische Hardware-Setups (Multi-GPU, AMD-spezifische Optimierungen), oder wenn du Ollama-Wrapper-Overhead vermeiden willst.
Wann nicht: wenn du einfach nur ein lokales LLM nutzen willst — der Setup-Aufwand lohnt nicht.
Quick-Start:
git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp
make GGML_CUDA=1 # NVIDIA
make GGML_HIPBLAS=1 # AMD
make GGML_METAL=1 # Apple SiliconDann Modell als GGUF-Datei holen (von Hugging Face) und mit ./llama-cli starten.
Performance-Optimierung
GPU-Offloading
Wenn dein Modell größer als VRAM ist, kannst du Layer auf GPU und Rest in RAM verteilen. Bei Ollama:
OLLAMA_NUM_GPU=35 ollama run llama3.3:70b35 heißt: 35 Layer auf GPU, Rest in RAM. Trial and Error — bei deinem Setup variiert die optimale Zahl.
Context-Length-Management
Längerer Context kostet mehr VRAM. Bei Ollama: OLLAMA_CONTEXT_LENGTH=8192 für 8k Context (Standard ist meistens 4k oder 8k). Wer nicht braucht: niedriger setzen, spart RAM.
AMD-spezifische Tipps
Auf AMD-GPUs Linux mit ROCm: Faktor 2–3 schneller als Windows mit DirectML. Wer Linux betreiben kann (Dual-Boot oder WSL2 mit ROCm-Support seit 2025), holt deutlich mehr aus der Hardware.
AMD-spezifische Setup-Tipps aus meiner Praxis (RX 7900 XTX):
- Linux statt Windows: Auf Ubuntu 22.04 LTS mit ROCm 7.1 läuft alles deutlich stabiler als unter Windows. Wenn du Dual-Boot machen kannst — mach es.
- Treiber-Version pinnen:
amdgpu-install --usecase=rocm,hiplibsdkmit der aktuellen ROCm-LTS-Version (zum Zeitpunkt: 7.1). Bleeding-Edge hat öfter Regressions als Bug-Fixes. HSA_OVERRIDE_GFX_VERSION=11.0.0als Environment-Variable, falls Ollama/llama.cpp die GPU nicht direkt erkennt — RDNA3-Karten brauchen den Override manchmal.- VRAM-Allocation reservieren: Bei 24-GB-Karten den Compute-Slice auf 22 GB begrenzen (
HIP_VISIBLE_DEVICES+OLLAMA_GPU_OVERHEAD=2147483648), sonst spilled das System bei Spitzenlast in den shared GPU memory und friert ein. - Ein-Modell-pro-Run: Auf AMD ist das Hot-Swapping zwischen Modellen langsamer als bei NVIDIA. Wenn ich ein Skript mit 3 Modell-Aufrufen habe, lade ich sie in derselben Reihenfolge wie zuletzt — spart das Re-Compile.
FAQ — Häufige Fragen zu lokalen LLMs
Welches Modell für Anfänger?
Mistral Small 3 oder Qwen 2.5 14B. Beide laufen auf 16 GB VRAM (RTX 4070, RX 7800 XT) komfortabel mit ~20 tok/s und liefern für die meisten Alltagstasks Antworten auf Niveau eines guten Cloud-Modells.
Wieviel Speicherplatz brauche ich?
Pro Modell 5–40 GB je nach Größe und Quantisierung. Wer mit Ollama startet und 3–4 Modelle parallel hält, sollte 100 GB einplanen. SSD ist Pflicht — auf HDD ist das Laden eines 70B-Modells in den RAM unzumutbar langsam.
Wie schnell ist „schnell genug”?
Persönlicher Cutoff: alles unter 8 tok/s wirkt zäh, ab 15 tok/s flüssig. ChatGPT als Referenz hat ~30 tok/s. Wenn dein lokales Setup unter 5 tok/s liegt, lohnt es sich oft, ein kleineres Modell zu nehmen — Qwen 2.5 14B mit 25 tok/s ist meistens nützlicher als Llama 3.3 70B mit 4 tok/s.
Kann ich lokale LLMs als Agent-Backend nutzen?
Ja — und genau dafür ist dieses Setup gedacht. Ollama, LM Studio und llama-cpp bieten alle OpenAI-kompatible APIs auf localhost. Dein Agent-Orchestrator (Python-Skript, n8n, LangChain) ruft http://localhost:11434/v1/chat/completions auf, statt die OpenAI- oder Claude-API. Kein Code-Umbau nötig, nur Base-URL tauschen. Für das Cloud-Gegenstück siehe Erster KI-Agent mit der Claude API.
Wartungsaufwand?
Gering. Ollama updatet sich selbst, neue Modelle holst du via ollama pull, alte löscht du via ollama rm. Custom-Tweaks an Hardware-Setup brauchen Zeit (besonders AMD-Linux), aber sind einmalig.
Sind lokale LLMs sicher?
Sicherer als Cloud-LLMs in puncto Datenschutz — deine Daten verlassen den Rechner nicht. Modell-Output ist nicht zensiert (kein RLHF auf „nicht-hilfreich-zu-bestimmten-Themen”-Niveau wie ChatGPT/Claude), heißt: Du bist selbst dafür verantwortlich, was du mit dem Output machst.
Meine Einschätzung
Ich betreibe seit Monaten Ollama parallel zu Cloud-APIs und meine ehrliche Einschätzung ist: Lokale LLMs sind für Routine-Tasks wie Klassifikation, Zusammenfassung und einfache Extraktion absolut produktionsreif. Für alles, was echtes Reasoning oder kreatives Schreiben braucht, komme ich an Cloud-Modelle wie Claude nicht heran — und das sage ich als jemand, der gerne alles lokal hätte. In meiner Praxis nutze ich lokale Modelle als ersten Filter in Pipelines und schicke nur die komplexen Fälle an die API. Das spart 60–70 % der Cloud-Kosten bei fast gleicher Qualität im Endergebnis.
Fazit
Ein lokales LLM ist 2026 die pragmatischste Grundlage für Agents, die Datenschutz ernst nehmen. Mit Ollama bist du in 15–30 Minuten am ersten lauffähigen Modell — und hast gleichzeitig ein Agent-Backend, das du ohne API-Kosten und ohne Cloud-Abhängigkeit in deine Pipelines einbinden kannst. Fang mit einem 7B–14B-Modell an, bau deinen ersten Agent-Prototyp, und entscheide dann, ob du für komplexere Tasks auf 32B oder 70B hochskalierst.
Wer noch keine ausreichende Hardware hat: schau dir KI-PC selber bauen an — die Komponenten-Empfehlung dort ist auf lokale LLMs ausgelegt. Wer Stable Diffusion auf demselben Rechner betreiben will: Tools-Verzeichnis gibt den Walkthrough dafür. Im Tools-Verzeichnis findest du Ollama, LM Studio und verwandte Tools mit aktuellem DSGVO-Status.
