Qwen3 lokal betreiben: 4B bis 32B per Ollama und vLLM mit Thinking-Mode

Alibabas Qwen3-Modellfamilie (veröffentlicht April 2025) hat einen schaltbaren Thinking-Mode: Dasselbe Modell arbeitet wahlweise mit ausführlichem Reasoning (langsamer, gründlicher) oder antwortet direkt (schneller). Diese Anleitung zeigt den Betrieb per Ollama und vLLM auf Consumer-GPUs ab einer RTX 3060 und wie Sie den Thinking-Mode pro Anfrage oder dauerhaft steuern.

Voraussetzungen

• GPU (NVIDIA empfohlen): Mindestens 6 GB VRAM für das 8B-Modell; 12 GB für 14B; 24 GB für 32B. CPU-Betrieb ist möglich, aber 10 bis 50× langsamer und damit für produktiven Einsatz ungeeignet.
• RAM: Mindestens 16 GB Arbeitsspeicher, 32 GB empfohlen für größere Modelle.
• Speicherplatz: Mindestens 10 GB für 8B, mindestens 25 GB für 32B (plus Ollama-Cache-Ordner).
• Betriebssystem: Linux empfohlen (insbesondere für vLLM); Ollama läuft auch unter Windows und macOS.
• Ollama-Weg: Ollama ab Version 0.9 (Thinking-Steuerung per think); keine Python-Kenntnisse erforderlich.
• vLLM-Weg: Linux mit NVIDIA-GPU, Python 3.10 oder neuer, aktuelle vLLM-Version (--reasoning-parser qwen3 ab 0.9.0). Die pip-Pakete bringen die passende CUDA-Laufzeit mit, ein separates CUDA-Toolkit ist nicht nötig.
• Internetverbindung: Für den initialen Modell-Download erforderlich; danach vollständig offline nutzbar.
• NVIDIA-Treiber: aktuell; nvidia-smi muss die GPU anzeigen.

Schritt 1: VRAM-Bedarf und Modellwahl

Wählen Sie das Modell nach Ihrem VRAM. Die Werte gelten für das Ollama-Standardformat GGUF Q4_K_M ohne Kontext-Cache. Bei langen Gesprächen steigt der VRAM-Bedarf deutlich; planen Sie Puffer ein.

Empfehlung für den KMU-Einstieg: Das 8B-Modell ist der Sweet Spot: Es passt in eine RTX 3060 (12 GB), liefert im Thinking-Mode brauchbare Reasoning-Qualität und belegt 5,2 GB. Das 14B-Modell ist die nächste Stufe für anspruchsvollere Aufgaben, die 32B-Variante braucht eine GPU mit 24 GB VRAM.

Hinweis zu 4B und 30B: In der Ollama-Bibliothek zeigen qwen3:4b und qwen3:30b inzwischen auf die überarbeiteten Varianten von Juli 2025 (Qwen3-2507, 256K Kontext). Diese gibt es getrennt als -thinking und -instruct; der Standard-Tag ist die Thinking-Variante. Für direkte Antworten ohne Reasoning wählen Sie dort qwen3:4b-instruct bzw. qwen3:30b-instruct, der Thinking-Schalter gilt nur für 8B, 14B und 32B.

MoE-Modell: Der 30B-A3B-Typ aktiviert pro Token nur 3B Parameter, braucht aber rund 20 GB VRAM für alle Gewichte. Er spart keinen Speicher, antwortet aber schneller als das dichte 32B-Modell.

Schritt 2: Ollama installieren und Modell laden

Ollama braucht keine Python-Umgebung und keine CUDA-Konfiguration. Der Dienst läuft im Hintergrund und stellt eine lokale REST-API auf Port 11434 bereit.

# Ollama installieren (Linux/macOS)
curl -fsSL https://ollama.com/install.sh | sh

# Unter Windows: Installer von https://ollama.com/download herunterladen

Laden Sie danach das passende Modell herunter:

# Modell herunterladen (passend zum VRAM)
ollama pull qwen3:4b    # 2,5 GB, für schwache GPUs / CPU-Fallback
ollama pull qwen3:8b    # 5,2 GB, Empfehlung für RTX 3060 12 GB
ollama pull qwen3:14b   # 9,3 GB, für RTX 4070 / RTX 3080
ollama pull qwen3:32b   # 20 GB,  für RTX 4090 / RTX 3090

$ ollama list

NAME            ID              SIZE    MODIFIED
qwen3:8b        500a1f067a9f    5.2 GB  2 minutes ago

Schritt 3: Qwen3 per Ollama starten und den Thinking-Mode nutzen

Mit ollama run starten Sie einen Chat im Terminal. Der Thinking-Mode ist standardmäßig aktiv: Ollama zeigt vor der Antwort den Denkprozess an. Für einfache Aufgaben verlangsamt das die Antwort unnötig.

# Chat starten
ollama run qwen3:8b

# Im Chat: Thinking-Mode ausschalten
>>> /set nothink
>>> Erkläre DSGVO-Grundlagen in drei Sätzen.

# Wieder einschalten für komplexe Aufgaben
>>> /set think

# Direkt ohne Thinking starten
ollama run qwen3:8b --think=false

Zusätzlich versteht Qwen3 den Soft Switch /think bzw. /no_think im Prompt. Er gilt nicht nur für eine Nachricht: Das Modell folgt in einem Gespräch der jeweils letzten Anweisung, bis Sie erneut umschalten.

Thinking-Mode dauerhaft deaktivieren per API

Anwendungen, die Ollama über die REST-API ansprechen, setzen das Feld think pro Anfrage. Die Antwort trennt Denkprozess (message.thinking) und Antwort (message.content):

curl http://localhost:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{"role": "user", "content": "Was ist VRAM?"}],
  "think": false,
  "stream": false
}'

Diese Schalter sind offiziell dokumentiert; der früher verbreitete Umweg über ein Modelfile mit SYSTEM "/no_think" ist nicht mehr nötig.

Schritt 4: vLLM als produktiver API-Server

Ollama eignet sich für einzelne Benutzer. Für mehrere gleichzeitige Anfragen und die Anbindung bestehender Anwendungen über die OpenAI-kompatible API ist vLLM die bessere Wahl. vLLM lädt die Originalgewichte von Hugging Face (BF16), nicht die Q4-Dateien von Ollama: Qwen3-8B braucht damit rund 16 GB VRAM für die Gewichte plus Kontext-Cache, für kleinere GPUs nutzen Sie die offiziellen AWQ- oder FP8-Varianten (zum Beispiel Qwen/Qwen3-8B-AWQ).

# vLLM in einer virtuellen Umgebung installieren
python3 -m venv ~/vllm-env && source ~/vllm-env/bin/activate
pip install vllm
# API-Server starten, Thinking-Mode aktiv (Standard)
vllm serve Qwen/Qwen3-8B \
  --port 8000 \
  --reasoning-parser qwen3
# Thinking-Mode serverseitig deaktivieren (für alle Anfragen)
vllm serve Qwen/Qwen3-8B \
  --port 8000 \
  --reasoning-parser qwen3 \
  --default-chat-template-kwargs '{"enable_thinking": false}'
# 32B-Modell mit erweitertem Kontext (131K Token via YaRN-Scaling)
vllm serve Qwen/Qwen3-32B \
  --port 8000 \
  --reasoning-parser qwen3 \
  --hf-overrides '{"rope_parameters": {"rope_type": "yarn", "factor": 4.0, "original_max_position_embeddings": 32768, "rope_theta": 1000000}}' \
  --max-model-len 131072

--enable-reasoning und --rope-scaling aus älteren Anleitungen hat vLLM entfernt; aktuelle Versionen brechen damit den Start ab.

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-8B",
    "messages": [{"role": "user", "content": "Was ist VRAM?"}],
    "chat_template_kwargs": {"enable_thinking": false}
  }'

Die Antwort ist ein JSON-Objekt mit einem choices-Array. Bei deaktiviertem Thinking ist das Feld reasoning leer, bei aktivem Thinking enthält es den Denkprozess. Ältere vLLM-Versionen nannten das Feld reasoning_content; passen Sie Client-Code beim Update an, sonst liest er ein leeres Feld.

Schritt 5: Thinking-Mode per Python-Client steuern

Im Produktivbetrieb steuern Sie den Thinking-Mode pro Anfrage über den Python-Client (Installation mit pip install openai). Damit nutzt Ihre Anwendung Thinking nur für komplexe Anfragen, ohne den Server neu zu starten.

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="EMPTY"  # beliebiger Wert, solange vLLM ohne --api-key läuft
)

# Thinking-Mode per Request aktivieren
response = client.chat.completions.create(
    model="Qwen/Qwen3-8B",
    messages=[{"role": "user", "content": "Erkläre GAN-Netze."}],
    extra_body={"chat_template_kwargs": {"enable_thinking": True}}
)

# Thinking-Mode per Request deaktivieren
response_schnell = client.chat.completions.create(
    model="Qwen/Qwen3-8B",
    messages=[{"role": "user", "content": "Was ist der Hauptsitz von Alibaba?"}],
    extra_body={"chat_template_kwargs": {"enable_thinking": False}}
)
print(response.choices[0].message.reasoning)
print(response_schnell.choices[0].message.content)

Qwen empfiehlt im Thinking-Mode temperature=0.6, top_p=0.95, top_k=20, im Non-Thinking-Mode temperature=0.7, top_p=0.8, top_k=20. Greedy Decoding (temperature=0) führt im Thinking-Mode zu Endlosschleifen.

Schritt 6: Übersicht aller Thinking-Mode-Schalter

Troubleshooting / Typische Fehler

Thinking-Mode erzeugt endlose Ausgabe

Fast immer ein Sampling-Problem. Setzen Sie temperature=0.6 statt 0. Hilft das nicht, erhöhen Sie presence_penalty (0 bis 2).

unrecognized arguments: --enable-reasoning oder --rope-scaling

Diese Optionen gibt es in aktuellen vLLM-Versionen nicht mehr. Lassen Sie --enable-reasoning weg und nutzen Sie für YaRN --hf-overrides wie in Schritt 4.

Modell wird nicht vollständig in die GPU geladen (CPU-Fallback)

Der VRAM reicht nicht aus. ollama ps zeigt in der Spalte PROCESSOR den Anteil auf CPU und GPU, nvidia-smi den belegten VRAM. Wechseln Sie zu einem kleineren Modell.

Zu wenig Speicherplatz beim Download

Ollama legt das Modell standardmäßig unter ~/.ollama/models ab. Bei 32B sind das 20 GB. Unter Linux liegt der Speicher des Systemdiensts in /usr/share/ollama/.ollama/models. Setzen Sie OLLAMA_MODELS=/pfad/mit/platz per sudo systemctl edit ollama (Environment=) und starten Sie den Dienst neu.

Kontextlänge bleibt bei 32K

Ohne YaRN-Override begrenzt vLLM Qwen3-8B/14B/32B auf 32.768 Token. Setzen Sie --hf-overrides und --max-model-len 131072 wie in Schritt 4. Statisches YaRN kann die Qualität bei kurzen Texten mindern; aktivieren Sie es nur bei Bedarf.

/no_think wirkt nicht

Bei qwen3:4b und qwen3:30b lädt Ollama die reine Thinking-Variante 2507. Nutzen Sie qwen3:4b-instruct bzw. qwen3:30b-instruct. In vLLM greift der Soft Switch nicht, wenn enable_thinking auf false steht.

Häufige Fragen

Darf ich Qwen3 kommerziell nutzen?

Ja. Alle sechs dichten Modelle (0,6B bis 32B) und die MoE-Varianten sind unter der Apache-2.0-Lizenz veröffentlicht. Kommerzielle Nutzung ist ohne Rückfrage bei Alibaba erlaubt, anders als bei Modellen mit Community-Lizenzen.

Wann aktiviere ich den Thinking-Mode, wann nicht?

Aktivieren Sie Thinking für Aufgaben mit mehrstufigem Schlussfolgern: Mathematik, Code-Debugging, technische Analyse, Planung. Deaktivieren Sie es für Faktenfragen, Zusammenfassungen und Übersetzungen, bei denen die Antwortzeit zählt.

Welches Modell passt zu einer RTX 3080 (10 GB VRAM)?

Das 14B-Modell (Q4, 9,3 GB) passt knapp in den VRAM, lässt aber wenig Platz für den Kontext-Cache. Das 8B-Modell läuft komfortabler und lässt mehr Puffer für den Kontext-Cache. Das 32B-Modell passt ohne CPU-Offloading nicht vollständig in 10 GB VRAM.

Was ist der Unterschied zwischen Ollama und vLLM?

Ollama ist für den einfachen lokalen Betrieb optimiert: ein Benutzer, Desktop-Verwendung, keine Python-Kenntnisse nötig. vLLM ist für den Produktivbetrieb gedacht: mehrere gleichzeitige Anfragen, Batch-Verarbeitung, OpenAI-kompatibler Endpunkt für bestehende Anwendungen. vLLM erfordert Linux und Python-Kenntnisse und lädt unquantisierte oder AWQ/FP8-Gewichte statt GGUF.

Kann ich den Kontext auf 131K Token erweitern?

Bei 8B, 14B und 32B ja, über YaRN: in vLLM mit --hf-overrides wie in Schritt 4, in llama.cpp mit --rope-scaling yarn --rope-scale 4 --yarn-orig-ctx 32768. Die Varianten 4B und 30B (2507) unterstützen nativ 256K Token. Ein voller 131K-Kontext erhöht den VRAM-Bedarf weit über die Tabellenwerte.

Fazit

Mit dem schaltbaren Thinking-Mode deckt eine Qwen3-Instanz schnelle Chat-Antworten und gründliche Analysen ab. Die Apache-2.0-Lizenz erlaubt den kommerziellen Einsatz.

Für den Einstieg eignet sich qwen3:8b per Ollama. Für einen internen API-Server mit mehreren Nutzern nutzen Sie vLLM mit --reasoning-parser qwen3 und steuern den Thinking-Mode pro Anfrage.

Weiterführende Anleitungen und Quellen

1. Qwen3: Think Deeper, Act Faster (offizieller Qwen-Blog von Alibaba)
2. vLLM Reasoning Outputs (offizielle Dokumentation)
3. Qwen3 Ollama Library: Modell-Tags und Größen
4. Ollama Thinking (offizielle Dokumentation)
5. Qwen-Dokumentation: Deployment mit vLLM
6. vLLM Context Extension (YaRN per --hf-overrides)

Passende Anleitungen auf S-EDV

1. DeepSeek R1 lokal betreiben: Modellwahl, Quantisierung und VRAM-Bedarf
2. Ollama-Modelle 2026 richtig auswählen: VRAM, Quantisierung und Modellvergleich für KMU
3. Offene LLMs selbst serven mit vLLM (Llama, Mistral, Hermes)
4. GGUF, AWQ und GPTQ erklärt: Welches Quantisierungsformat für welchen Zweck