Qwen3.8-27B (Dense VLM, eine Karte)

Deploye Qwen3.8-27B auf Clore.ai — Alibabas dichtes 27B Vision-Language-Modell, das auf einer einzelnen RTX 4090 mit Q4 und einer einzelnen RTX 5090 mit FP8 läuft

Stand (August 2026): Qwen veröffentlichte Qwen3.8-27B am 14. August 2026 unter Apache 2.0, mit einem offiziellen FP8-Checkpoint einen Tag später. Gewichte: Qwen/Qwen3.8-27B und Qwen/Qwen3.8-27B-FP8. Dichtes 27B, native Bildsprache, Kontext mit 262.144 Token erweiterbar auf 1 Mio. mit YaRN, Unterstützung ab dem ersten Tag in vLLM, SGLang und llama.cpp.

Die meisten der Modelle, die diesen Sommer veröffentlicht wurden, lassen sich nicht mieten. GLM-5.2 ist 756 GB in FP8. MiniMax M3 ist 854 GB. Kimi K3 ist 1,5 TB und passt bei keiner Quantisierung auf eine der auf Clore.ai gelisteten Maschinen. Qwen3.8-27B ist das Gegengewicht: 27B dichte Parameter, 15,4 GB bei Q4, eine Karte, ein Container, fertig. Es ist das Modell, für das dieser Marktplatz tatsächlich gemacht ist — beim letzten Snapshot gab es 677 Server mit einer freien Karte mit 24 GB oder mehr.

Es ist auch kein abgespecktes Modell. Es verarbeitet Bilder und Video nativ und bietet einen reasoning_effort Regler, und sein hybrider Attention-Stack hält den KV-Cache klein genug, dass langer Kontext auf einer Consumer-Karte realistisch statt theoretisch ist.

Wichtige Spezifikationen

Eigenschaft

Wert

Parameter

27B (dicht)

Architektur

64 Schichten, hybrides Gated DeltaNet + Gated Attention, MTP

Modalität

Text, Bild, Video rein → Text raus

Nativer Kontext

262.144 Token

Erweiterter Kontext

1.000.000 Token (YaRN)

Lizenz

Apache 2.0

Veröffentlichungsdatum

14. August 2026

Gewichte

BF16 55,6 GB · FP8 30,9 GB · Q4_K_S GGUF 15,4 GB

Primäre Tools

vLLM, SGLang, llama.cpp, Ollama

Warum dieses

Es passt. Q4 auf einer einzelnen RTX 3090 oder 4090 bei $0.07–0.42/Std.; FP8 auf einer RTX PRO 6000 oder 2× 24-GB-Karten
Apache 2.0 — kommerzielle Nutzung, Feinabstimmung und Weiterverbreitung ohne Umsatzklausel, anders als Kimi K3 (benutzerdefinierte Lizenz mit Umsatzschranke) oder MiniMax M3 (Community-Lizenz)
Hybride Attention — 3 von je 4 Schichtblöcken sind Gated DeltaNet (lineare Attention), daher wächst der KV-Cache mit dem Kontext viel langsamer als bei einem Standard-Transformer. Das macht 100K+ Kontext auf 24 GB nutzbar
Integrierte Vision — Diagramme, Dokumente, Screenshots und Video in Stundenlänge, kein separates VLM bereitzustellen
Denksteuerung — reasoning_effort bei niedrig / mittel / xhigh, plus preserve_thinking um das Schlussfolgern für Agenten über Turns hinweg beizubehalten

Anforderungen

Eine Karte ist der ganze Sinn der Sache. Eine einzelne RTX 4090 bei Q4 liefert dir ein Vision-Language-Modell der Spitzenklasse für ungefähr den Preis einer Tasse Kaffee pro Tag. Steig nur dann auf eine RTX 5090 oder eine RTX PRO 6000 um, wenn du FP8-Qualität oder einen sehr langen Kontext willst.

Q4_K_S GGUF

Q8 / FP8

BF16

Gewichte

15,4 GB

~31 GB

55,6 GB

GPU

1× RTX 3090/4090 24 GB

1× RTX PRO 6000 96 GB oder 2× RTX 5090

2× RTX PRO 6000 oder 4× RTX 5090

Praktischer Kontext

~64K

~200K

volle 262K

System-RAM

32 GB

64 GB

96GB

Festplatte

25 GB

45 GB

80 GB

CUDA

12.8+

Eine einzelne RTX 5090 (32 GB) reicht für FP8 nicht aus. Allein die Gewichte sind 30,9 GB. Du brauchst Spielraum für den KV-Cache und die Aktivierungen, daher braucht FP8 entweder eine 96-GB-Karte oder zwei GPUs. Auf einer einzelnen 5090 verwende Q6 oder Q4 — siehe CUDA- & PyTorch-Kompatibilität für das richtige Base-Image auf Blackwell.

Option A — Ollama (schnellster Weg)

ollama pull qwen3.8:27b
ollama run qwen3.8:27b

# OpenAI-kompatibler Endpunkt
ollama serve &
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "qwen3.8:27b",
    "messages": [{"role": "user", "content": "Refaktoriere diesen Handler, um context.Context zu verwenden, und füge Wiederholungsversuche hinzu."}],
    "temperature": 0.7
  }'

Das Standard-Tag ist Q4_K_M (~16 GB). Verwende qwen3.8:27b-q8_0 wenn du eine 96-GB-Karte gemietet hast.

Option B — vLLM (Produktion)

Eine einzelne 24-GB-Karte, Community-INT4-AWQ-Checkpoint:

# docker-compose.yml
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports: ["8000:8000"]
    volumes: [hf_cache:/root/.cache/huggingface]
    command: >
      --model cyankiwi/Qwen3.8-27B-AWQ-INT4
      --max-model-len 65536
      --gpu-memory-utilization 0.92
      --served-model-name qwen3.8-27b
      --enable-auto-tool-choice
      --tool-call-parser hermes
    deploy:
      resources:
        reservations:
          devices: [{driver: nvidia, count: 1, capabilities: [gpu]}]
    shm_size: "8gb"
volumes:
  hf_cache:

Qwen liefert offiziell nur BF16 und FP8. Die 4-Bit-Checkpoints sind Community-Builds — cyankiwi/Qwen3.8-27B-AWQ-INT4 und RedHatAI/Qwen3.8-27B-INT4 sind die am häufigsten heruntergeladenen, und unsloth/Qwen3.8-27B-NVFP4 zielt speziell auf Blackwell-Karten ab.

FP8 über zwei GPUs:

vllm serve Qwen/Qwen3.8-27B-FP8 \
  --tensor-parallel-size 2 \
  --max-model-len 262144 \
  --gpu-memory-utilization 0.90 \\
  --enable-chunked-prefill

Für Videoeingabe ist ein zusätzlicher Schalter erforderlich:

vllm serve Qwen/Qwen3.8-27B --media-io-kwargs '{"video": {"num_frames": -1}}'

Über das native Fenster hinaus mit YaRN:

VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve Qwen/Qwen3.8-27B \
  --hf-overrides '{"text_config": {"rope_parameters": {"rope_type": "yarn", "factor": 4.0, "original_max_position_embeddings": 262144}}}' \
  --max-model-len 1000000

Option C — llama.cpp / GGUF (24-GB-Karten)

# Q4_K_S — 15,4 GB, problemlos auf einer 24-GB-Karte
huggingface-cli download unsloth/Qwen3.8-27B-GGUF \
  --include "*UD-Q4_K_S*" --local-dir /workspace/qwen38

llama-server -m /workspace/qwen38/*UD-Q4_K_S*.gguf \
  --host 0.0.0.0 --port 8080 \\
  -ngl 999 -c 65536 --flash-attn

Kleinere Quantis aus demselben Repo, für knappere Karten: UD-Q3_K_XL 13,1 GB, UD-Q2_K_XL 9,8 GB, UD-IQ2_S 8,4 GB.

Schlussfolgerungsaufwand

from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")

resp = client.chat.completions.create(
    model="qwen3.8-27b",
    messages=[{"role": "user", "content": "Plane die Migration schrittweise."}],
    extra_body={"reasoning_effort": "xhigh"},   # xhigh (Standard) | mittel | niedrig
)

Reduziere auf niedrig für Klassifizierung, Extraktion und Routing — dort ist der Qualitätsunterschied gering und die Token-Rechnung nur ein Bruchteil. Verwende xhigh für Agenten und mehrschrittige Code-Arbeit.

GPU-Empfehlungen für Clore.ai

Einrichtung

VRAM

Modus

Kontext

Clore.ai-Kosten

1× RTX 3090

24 GB

Q4 GGUF

~64K

ca. 0,07–0,21 $/h

1× RTX 4090

24 GB

Q4 AWQ

~64K

ca. 0,14–0,42 $/h

1× RTX 5090

32 GB

Q6 GGUF

~96K

0,25–0,77 $/Std.

2× RTX 5090

64 GB

FP8, TP=2

~200K

$0.50–1.54/Std.

1× RTX PRO 6000

96GB

FP8

volle 262K

$0.92–1.38/hr

4× RTX 5090

128GB

BF16, TP=4

volle 262K

$1.00–3.08/hr

Bestes Preis-Leistungs-Verhältnis: eine einzelne RTX 4090 ab $0.14/Std. bei Q4. Wenn der Preis für das gesamte Rig hoch erscheint, denke daran, dass die meisten Multi-GPU-Rigs Teilvermietung — du kannst eine Karte aus einem Acht-Karten-System herausnehmen.

Benchmarks

Die Zahlen unten stammen direkt von Qwen, aus der Modellkarte vom 14. August 2026. Unabhängige Reproduktionen trafen zum Zeitpunkt des Schreibens noch ein.

Qwen bewertet das 27B gegen deutlich größere Modelle bei Code- und Agenten-Suites (SWE-bench Pro, DeepSWE, QwenSWEBench) unter Verwendung des Claude-Code-Harness mit 256K Kontext. Die für die Bereitstellung wichtige Aussage ist nicht eine einzelne Punktzahl: Es ist, dass ein dichtes 27B, das auf einer einzigen Consumer-Karte läuft, in derselben Liga wie MoE-Modelle spielt, die ein Rack benötigen. Betrachte die Tabelle des Anbieters als Ausgangshypothese und benchmarke auf deinem eigenen Aufgabensatz — das ist hier günstig, denn eine Stunde 4090-Zeit kostet etwa zwanzig Cent.

Anwendungsfälle

Codierassistent auf einer einzelnen GPU — ein Container, eine Karte, ein OpenAI-kompatibler Endpunkt
Verstehen von Dokumenten und Screenshots — native Vision, keine separate Pipeline
Videoanalyse — Video in Stundenlänge in einem einzigen Durchgang mit dem Frame-Flag von vLLM
RAG mit langem Kontext — 262K nativ, und die hybride Attention hält den KV-Cache erschwinglich
Agenten-Worker — preserve_thinking hält das Schlussfolgern über Tool-Aufrufe hinweg kohärent
On-Prem und air-gapped — Apache 2.0, nichts telefoniert nach Hause
LoRA-Feinabstimmung — dichtes 27B ist geeignet für Unsloth und LLaMA-Factory auf einer einzelnen 24-GB-Karte

Fehlerbehebung

Problem

Fix

kein Kernel-Image verfügbar ist auf einer 5090

Alte CUDA-Build — verwende ein cu128-Image, siehe Kompatibilität

OOM bei FP8 auf einer einzelnen RTX 5090

Erwartet: 30,9 GB Gewichte auf einer 32-GB-Karte. Verwende Q6/Q4 oder TP=2

OOM bei langem Kontext auf 24 GB

Niedriger --max-model-len auf 32768 oder reduziere auf UD-Q3_K_XL

YaRN abgelehnt

Benötigt ein aktuelles vLLM/SGLang; gib es durch --hf-overrides, nicht als eigenständigen Schalter

Videoeingabe ignoriert

Fügen Sie --media-io-kwargs '{"video": {"num_frames": -1}}' (nur vLLM)

Tool-Aufrufe verworfen

--enable-auto-tool-choice --tool-call-parser hermes

Die Qualität sinkt jenseits von ~600K

YaRN erweitert Positionen, nicht das Verständnis — halte kritischen Inhalt nahe am Ende des Prompts

Nächste Schritte

Vorgänger: Qwen3.6-27B — das dichte 27B-Modell vom April, das es ersetzt
Multimodaler Verwandter: Qwen3.5-Omni — fügt Audioeingabe und Sprachausgabe hinzu
Aufsteigen: GLM-5.2 oder Mistral Small 4 wenn 27B nicht ausreicht
Bereitstellung: vLLM · SGLang · Ollama
Feinabstimmen: Unsloth

Wichtige Spezifikationen

Warum dieses

Anforderungen

Option A — Ollama (schnellster Weg)

Option B — vLLM (Produktion)

Option C — llama.cpp / GGUF (24-GB-Karten)

Schlussfolgerungsaufwand

GPU-Empfehlungen für Clore.ai

Benchmarks

Anwendungsfälle

Fehlerbehebung

Nächste Schritte

Links