Qwen3.8-27B på vLLM: Servera den i produktion på en eller två GPU:er

Ja — Qwen3.8 27B körs i produktion på vLLM idag, och på en enda GPU i de flesta fall. Den version som räknas är vLLM 0.17.0 eller nyare: den levererar det officiella receptet, hybrid-attention-kernelerna som den här modellen behöver, och en O​penAI-kompatibel /v1-endpoint. För ett Blackwell-GPU kör du NVFP4-kvantiseringen — vLLM:s eget recept mäter den till 24,6 GiB VRAM vid tensor-parallell storlek 1. För ett enda 48 GB-kort kör du FP8. Full BF16, en 51,7 GB-checkpoint, kräver ett 80 GB-GPU eller två 48 GB-kort i tensor-parallell. De exakta kommandona finns nedan; det första är en one-liner.

Allt här verifierades den 15 augusti 2026, den tredje dagen vikterna var live. Arkitektur, kontext och licens kommer från Qwen3.8 27B-modellkortet på Hugging Face; kontrollpunktsstorleken är summan av repots 18 safetensors-shards; vLLM-kommandona och siffran 24,6 GiB kommer från vLLM:s egen receptsida för den här modellen. Qwen3.8 27B är Alibabas täta multimodala modell med 27 miljarder parametrar — Apache 2.0-vikter, släppta 13–14 augusti — och eftersom vikterna är öppna kan du köra den själv istället för att hyra tokens. Det vägvalet är vad den här artikeln egentligen handlar om.

De fakta som räknas, med källor

• Arkitektur — 27B dense (27,8B inklusive visionstornet och det utfyllda ordförrådet), 64 lager, dold dimension 5 120, ordförråd 248 320. Officiellt modellkort, verifierat idag.

• Attention — hybrid: 16 full-attention-lager, 48 Gated DeltaNet-linjära lager i ett 3:1-blockmönster. Endast 16 lager behåller en växande nyckel-värde-cache; de övriga 48 behåller istället ett återkommande tillstånd med fast storlek.

• Kontext — 262,144 tokens inbyggt, utbyggbart till cirka 1M via YaRN RoPE-skalning. Modellkort, verifierat idag.

• Indata — inbyggd text, bild och video; textutdata. vLLM exponerar alla tre via standard-API:t för chat-completions, utan separat projektorfil.

• Licens — Apache 2.0. Detta enda faktum är anledningen till att frågan "servera det själv vs hyra tokens" överhuvudtaget finns.

• Vikter — BF16-checkpointen uppgår till 51,7 GB fördelat på 18 safetensors-shards (Hugging Face, verifierat idag). Qwe​n publicerar även FP8- och NVFP4-checkpoints byggda för vLLM.

• vLLM-krav — 0.17.0 eller nyare, med transformers ≥ 5.8.0. vLLM:s receptsida, verifierad idag. "Vilken vLLM som helst" är inte en säker instruktion; det är recurrent-layer-kärnorna som den nya versionen lägger till.

• Multi-token prediction — en draft-head för spekulativ avkodning ingår i checkpointen, så behöver du ingen separat draftmodell. vLLM dokumenterar flaggan; det finns ännu ingen oberoende siffra för hastighetsökning.

GPU-stegen — vilken kvantisering på vilket kort

Tre serveringsformat täcker det praktiska intervallet. Välj utifrån den VRAM du faktiskt har, inte efter "bästa kvant".

• NVFP4 — 24,6 GiB totalt (vikter plus en FP8 KV-cache), enligt vLLM:s recept vid TP1. Ryms på en enda GPU av Blackwell-klass — i praktiken en 32 GB RTX 5090 eller en B200. Detta är vägen med lägst latens och den som behåller mest kontext per kort: vLLM:s recept rapporterar 6,6M KV-tokenkapacitet även vid 1M-kontextförlängningen.

• FP8 — cirka 26 GB vikter. Ett 48 GB-kort (L40S, RTX A6000, RTX 6000 Ada) hanterar det med utrymme för kontext; två 48 GB-kort i tensor-parallellt läge ger dig utrymme för längre kontext eller högre samtidighet. vLLM:s eget recept kör FP8 med TP4 över en fyr-GPU GB300-bricka när du vill ha den största möjliga KV-cachen.

• BF16 — 51,7 GB vikter, så en enda 80 GB GPU (H100, A100 80GB, B200, GB300) eller två 48 GB-kort vid TP2. Detta är referensprecisionalternativet, och det är det som kommandot för 1M-kontextförlängning nedan faktiskt använder.

• MXFP4 — använd inte på NVIDIA. vLLM:s MXFP4-väg saknar för närvarande stöd för linear-metoden; samma vikter publiceras som NVFP4, vilket är det format som NVIDIA-receptet faktiskt använder.

Kör det — vLLM-kommandona

Standardinställningen för låg latens på en enda GPU (NVFP4, en Blackwell GPU), ordagrant från vLLM:s recept:

vllm serve Inferact/Qwen3.8-27B-NVFP4 --tensor-parallel-size 1 --max-model-len 262144 --kv-cache-dtype fp8 --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_coder

FP8-kommandot från samma recept (TP4, en GB300-bricka, största KV-cachen):

vllm serve Qwen/Qwen3.8-27B-FP8 --tensor-parallel-size 4 --max-model-len 262144 --kv-cache-dtype fp8 --reasoning-parser qwen3

För två 48GB-kort, behåll FP8-kommandot och sätt --tensor-parallel-size 2 istället för 4.

Lägg till detta i något av kommandona för att aktivera MTP spekulativ avkodning:

--speculative-config '{"method":"mtp","num_speculative_tokens":3}'

1M-kontextutökningen (även från vLLM:s recept):

vllm serve Qwen/Qwen3.8-27B --max-model-len 1010000 --hf-overrides '{"text_config": {"max_position_embeddings": 1010000}}'

Point any O​penAI client at http://localhost:8000/v1 — the endpoint is a drop-in replacement. Two runtime details matter once it is up: thinking is on by default at reasoning_effort xhigh, so turn it off per request with chat_template_kwargs {"enable_thinking": false} or drop it to {"reasoning_effort": "low"} for faster answers. And the checkpoint ships temperature 1.0, top_p 0.95, top_k 20 in its generation config — pass those unless your app already overrides sampling.

Vad vLLM:s egna sidor lovar och inte lovar

• Inga throughput-siffror för 27B ännu.Per den 15 augusti publicerar vLLM:s receptsida inga throughput- eller latensbenchmarks för Qwen3.8 27B. Siffran "4 000+ tokens per sekund per GPU" som cirkulerar hör till Qwen3.8 2.4T-A95B på ett GB300 NVL72-rack med 72 GPU:er, är leverantörsrapporterad och gäller inte den här modellen. Communityns siffror för tokens per sekund som du kommer att se cirkulera för GGUF med llama.cpp eller Ollama — en annan runtime och en annan arbetsbelastning än vLLM serving.

• Påståendet om den billiga KV-cachen är runtime-beroende. Modellkortet säger att endast 16 av 64 lager håller en cache, men det hjälper bara om servingmotorn faktiskt implementerar Gated DeltaNet-lagren. vLLM 0.17+ är den version som gör det; det är därför versionspinningen är det första i den här artikeln snarare än en fotnot.

• MTP är inbyggt men inte mätt här. Draft-huvudet finns i checkpointen och vLLM dokumenterar flaggan, men ingen har ännu publicerat en oberoende siffra för hastighetsökningen för den här 27B-modellen på vLLM. Planera att mäta det på din egen trafik.

• NVIDIA är den beprövade vägen. vLLM:s recept är skrivet för NVIDIA GPU:er (NVFP4 och FP8). Driftsättningar på AMD Instinct eller Intel Gaudi av denna hybrid-attention-modell är fortfarande mycket experimentella, och denna artikel låtsas inte något annat.

Servera det själv, eller hyr tokens

Det är här som Apache 2.0 gör sitt jobb. Det finns ingen licensavgift per token för Qwen3.8 27B, så den enda riktiga frågan är om du äger hårdvaran eller hyr token.

• Egen drift (denna artikel) — du betalar för GPU:n en gång, och varje token efter det är gratis. Ett RTX 5090 du redan äger gör NVFP4-kommandot till en slutpunkt med noll marginalkostnad, utan att data lämnar maskinen. Om du måste hyra GPU:n är ett molnbaserat 5090 eller ett par A6000:or den utgiftsposten, och hela argumentet vinner bara om du redan har kortet eller den varaktiga volymen.

• Hyr tokens — eftersom vikterna är öppna, körs den av flera värdar, och prisgolvet är hårdvarukostnaden. Qwen3.8 27B är live på OrcaRouter idag för $0,33 per miljon input-token och $2,40 per miljon output — inget leverantörspåslag att föra vidare, eftersom OrcaRouter kör de öppna vikterna på sin egen infrastruktur — och samma öppna vikter finansierar en rate-begränsad gratisnivå som tar $0 per förfrågan och returnerar HTTP 429 när du passerar dess tak. En representativ månad med 10 miljoner token vid 70% input kostar cirka $9,51 på den betalda nivån.

• Beslutsregeln — om du redan äger GPU:n, self-hosta. Om du skulle behöva köpa eller hyra en, går API:et snabbt jämnt upp vid sidoprojektvolymer, och samma O​penAI-kompatibla klient kan peka mot endera slutpunkten, så ändras inte koden när du flyttar.

När vLLM är fel svar

• Du är en person med en bärbar dator — vLLM är en servermotor, inte en skrivbordsapp. För en lokal körning för en enskild användare är llama.cpp eller Ollama med en Q4 GGUF enklare och kräver ett 24GB-kort, inte ett Blackwell GPU; vår guide how-to-run-Qwen3.8-27B-locally går igenom hela den vägen.

• Du behöver garanterad genomströmning med noll driftsarbete — självhostning innebär att du äger larmhanteringen, köhanteringen och failover. Om "API:et är nere" inte är en mening du vill ha i ditt ordförråd, hyr token istället och låt någon annan sköta serverflottan.

• Du behöver verkligen hela ~1M-kontexten med frontier-kvalitet — det är Qwen3.8 2.4T-A95B:s jobb, servad av vLLM eller SGLang över ett rack med 72 GB300 NVL72-GPU:er. Qwen3.8 27B på en eller två GPU:er kommer inte att mäta sig med det; vår serveringsartikel om 2.4T förklarar varför den modellen är en annan klass av problem.

• Du kör på ett äldre 24GB-kort — NVFP4 är ett Blackwell-format; på Ampere (RTX 3090) eller Ada (RTX 4090) 24GB-kort är FP8-vägen vLLM-alternativet, och utöver det är en GGUF-kvantisering under llama.cpp det pragmatiska stoppet. Samma modell på ett 24GB-kort är en annan sak.

• Du måste hantera maximal samtidighet på ett kort — standardvärdena för en enskild GPU ovan är utgångspunkten, inte produktionsformen. Justera --max-num-seqs, KV-cachen och MTP-konfigurationen utifrån din egen förfrågningsmix innan du anser det klart.

Slutsats

Qwen3.8 27B är den ovanliga täta 27B-modellen som vLLM serverar på en enda GPU i produktion. Uppdatera till vLLM 0.17.0+, hämta NVFP4-kvantiseringen för ett 32GB Blackwell-kort på 24,6 GiB, FP8-kvantiseringen för ett 48GB-kort eller två i tensor-parallell, och reservera BF16 för en 80GB GPU. Kommandona är enradare, slutpunkten är O​penAI-kompatibel, och eftersom vikterna är Apache 2.0 kan du servera den själv eller hyra den för $0,33/$2,40 per miljon tokens med en gratisnivå — samma klientkod oavsett. Det enda ingen ännu har är ett oberoende genomströmningsvärde för 27B på vLLM, så avsätt en timme för benchmarking efter att du har startat den, innan du lovar någon en latenssiffra.