Bester lokaler LLM-Stack nach Anwendungsfall 2026: Schreiben, Coding, RAG, Agenten

Schnellentscheidung: Stack nach Hardware-Stufe (June 2026)

1. 1
   Für 24 GB VRAM: `ollama pull llama3.3:70b` — höchste Qualität, entspricht GPT-4 (2023) in Writing-Benchmarks.
2. 2
   Für 16 GB VRAM: `ollama pull mistral-small3.1` — 128K Kontext, beste Qualität unter 24 GB.
3. 3
   Für 8 GB VRAM: `ollama pull llama3.2:8b` — gute Schreibqualität, schnell auf Consumer-Hardware.
4. 4
   OpenWebUI per Docker installieren: `docker run -d -p 3000:8080 ghcr.io/open-webui/open-webui:latest`.
5. 5
   Kontextfenster (8K–32K Tokens) in den OpenWebUI-Einstellungen entsprechend der Dokumentlänge konfigurieren.

1. 1
   vLLM installieren: `pip install vllm`.
2. 2
   vLLM-Server mit Qwen3-Coder-7B starten: `python -m vllm.entrypoints.openai.api_server --model Qwen/Qwen3-Coder-7B-Instruct --port 8000`.
3. 3
   Für 16+ GB VRAM, 14B verwenden: `--model Qwen/Qwen3-Coder-14B-Instruct`.
4. 4
   IDE-Erweiterung (VS Code Continue.dev, Cursor etc.) mit `http://localhost:8000/v1` verbinden.
5. 5
   Batch-Verarbeitung für Code-Review aktivieren: 10 Dateien parallel über einen API-Aufruf verarbeiten (`vllm` unterstützt standardmäßig batch=10).

# Review 10 files in parallel using vLLM batch processing
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

code_files = [
    ("utils.py", open("utils.py").read()),
    ("models.py", open("models.py").read()),
    # ... up to 10 files
]

# vLLM processes all 10 in parallel (1 batch request)
reviews = []
for filename, code in code_files:
    prompt = f"Review this code for bugs, style, and performance:

{code}"
    response = client.chat.completions.create(
        model="Qwen3-Coder-7B-Instruct",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.2,  # Deterministic for review tasks
    )
    reviews.append((filename, response.choices[0].message.content))

for filename, review in reviews:
    print(f"=== {filename} ===
{review}
")

1. 1
   LlamaIndex installieren (`pip install llama-index`).
2. 2
   Dokumente (PDF, TXT, Markdown) in LlamaIndex laden.
3. 3
   Dokumente in Chunks aufteilen (Standard: 1024 Tokens), mit lokalem Modell oder OpenAI (Backup) einbetten.
4. 4
   Embeddings in Qdrant Vector DB speichern (läuft lokal via Docker).
5. 5
   Per LlamaIndex abfragen: Top-K ähnliche Dokumente abrufen, LLM mit Kontext prompten.
6. 6
   In FastAPI-Endpunkt für Web-UI oder IDE-Integration einbetten.

1. 1
   LangGraph installieren (`pip install langchain langgraph`).
2. 2
   Tools (Web-Suche, Rechner, Datei-I/O) als Funktionssignaturen definieren.
3. 3
   Agenten-Graph erstellen: LLM als Entscheidungsknoten, Tools als Aktionsknoten.
4. 4
   vLLM-Backend für latenzarme LLM-Aufrufe in engen Schleifen verwenden.
5. 5
   Agenten-Loop ausführen: LLM → Tool-Auswahl → Tool-Ausführung → wiederholen bis abgeschlossen.

1. 1
   vLLM mit `--served-model-name model-name` auf festem Port deployen.
2. 2
   Nginx konfigurieren, um 2+ vLLM-Instanzen lastverteilt anzusprechen (eine pro GPU bei Multi-GPU).
3. 3
   OpenAI-kompatiblen `/v1/chat/completions`-Endpunkt für Client-Kompatibilität verwenden.
4. 4
   Über Prometheus-Scrape-Endpunkt überwachen (vLLM exportiert Anfragelatenz und Durchsatz-Metriken).
5. 5
   Rate-Limiting pro Benutzer mit Token-Bucket-Algorithmus einrichten.

1. 1
   Mit der `peft`-Bibliothek (LoRA) fine-tunen, um den VRAM-Bedarf zu reduzieren.
2. 2
   Training: 4-facher Modell-VRAM erforderlich (Optimizer-Zustand, Gradienten). Separat von Inferenz ausführen.
3. 3
   LoRA-Adapter auf HuggingFace Hub oder im lokalen Dateisystem exportieren.
4. 4
   Fine-getunetes Modell in Ollama laden: `ollama create mymodel -f Modelfile`.
5. 5
   Oder HuggingFace TRL (Transformers Reinforcement Learning) für RLHF verwenden.

1. 1
   Ollama: `/api/generate` mit `stream: true` aufrufen. Tokens kommen als newline-delimited JSON an.
2. 2
   vLLM: `/v1/chat/completions` mit `stream: true` verwenden. Gibt OpenAI-kompatiblen SSE-Stream zurück.
3. 3
   Frontend: EventSource API (JavaScript) verwenden, um Stream zu konsumieren und UI pro Token zu aktualisieren.
4. 4
   Batch-Verarbeitung deaktivieren (batch=1) für niedrigste Latenz.

Weiterführende Artikel

• Beste KI-Coding-Assistenten für lokale LLM — IDE-Wahl für Ihren Coding-Stack (Cursor, Continue.dev, Cody).
• Beste lokale LLMs für Coding 2026 — Qwen3-Coder vs. DeepSeek-Coder HumanEval-Rankings.
• Lokales RAG einrichten 2026 — Vollständige Implementierungsanleitung: LlamaIndex + Qdrant + Ollama.
• Lokale LLM-Agenten mit LangGraph — Agenten-Workflow-Framework mit Schritt-für-Schritt-Beispielen.
• Ollama vs. LM Studio — Backend-Vergleich: CLI vs. GUI, Geschwindigkeit, Batch-Verarbeitung.
• Open WebUI vs. SillyTavern — Chat-UI-Vergleich: professionell vs. Rollenspiel.
• Wie viel VRAM brauchen lokale LLMs? — Hardware-Anforderungen nach Modellgröße und Anwendungsfall.

Häufige Fehler bei der Stack-Wahl

• Ollama für Produktions-API ohne vLLM verwenden: Ollama erreicht maximal <10 Anfragen/Sek. Für Produktionsumgebungen mit 10+ gleichzeitigen Benutzern ist vLLM obligatorisch. Throughput unter Last testen, bevor deployt wird.
• LangGraph ohne vLLM-Backend ausführen: LangGraph-Agenten führen 10+ sequentielle LLM-Aufrufe durch. Ollama verursacht Latenz-Engpässe. LangGraph immer mit vLLM für Sub-Sekunden-Round-Trip-Zeiten kombinieren.
• Ollama + vLLM ohne Speicherverwaltung auf derselben GPU ausführen: Beide Tools laden Gewichte in den VRAM. Zwei Instanzen eines 70B-Modells belegen 32 GB. Separate GPUs verwenden oder stark quantisieren (Q2), damit beide passen.
• Falsches Kontextfenster für das Schreiben wählen: Standard-4K-Kontext begrenzt Brainstorming-Sessions. Für langes Schreiben 16K–32K Kontext in OpenWebUI einstellen. Trade-off: langsamere Inferenz (2–3-fach langsamer pro Token).
• Davon ausgehen, dass alle Backends gleich schnell sind: vLLM und Ollama verwenden unterschiedliche Kernel. Auf gleicher Hardware ist vLLM 2–3-fach schneller für Inferenz. Der Geschwindigkeitsunterschied liegt am Backend, nicht am Frontend (OpenWebUI, LM Studio sind nur UIs).

Quellen

• Ollama GitHub — Offizielle Dokumentation, Streaming-API-Spezifikation und Modellbibliothek.
• vLLM GitHub — OpenAI-API-Kompatibilität, Batch-Verarbeitung und Continuous-Batching-Dokumentation.
• Qwen3-Coder Technical Report — Alibaba Qwen. 82% HumanEval-Score, spezialisiert für Coding-Aufgaben. Apache 2.0 lizenziert.
• LlamaIndex-Dokumentation — Dokument-Indexierung, Chunking und RAG-Retrieval-Framework.
• LangGraph-Dokumentation — Agenten-Workflow-Framework, Zustandsmaschinen, Tool-Use-Muster.
• Qdrant-Dokumentation — Vektordatenbank für lokale Embedding-Speicherung, Docker-ready, Apache 2.0.
• Continue.dev-Dokumentation — IDE-Erweiterung für VS Code und JetBrains mit lokalen LLM-Backends.