Qwen3.8-27B op vLLM: Serveer het in productie op één of twee GPU's

Ja — Qwen3.8 27B draait vandaag in productie op vLLM, en in de meeste gevallen op een enkele GPU. De versie die telt is vLLM 0.17.0 of nieuwer: deze bevat het officiële recept, de hybrid-attention-kernels die dit model nodig heeft, en een OpenAI-compatibel /v1-eindpunt. Voor één Blackwell-GPU gebruik je de NVFP4-quant — het eigen recept van vLLM meet dit op 24,6 GiB VRAM bij tensor-parallelle grootte 1. Voor een enkele 48GB-kaart gebruik je FP8. Volledige BF16, een checkpoint van 51,7 GB, vereist één 80GB-GPU of twee 48GB-kaarten in tensor-parallel. De exacte commando's staan hieronder; de eerste is een one-liner.

Alles hier is geverifieerd op 15 augustus 2026, de derde dag dat de gewichten live waren. Architectuur, context en licentie komen van de Qwen3.8 27B-modelkaart op Hugging Face; de checkpointgrootte is de som van de 18 safetensors-shards van de repo; de vLLM-commando's en het cijfer van 24,6 GiB komen van de eigen receptpagina van vLLM voor dit model. Qwen3.8 27B is Alibaba's dense multimodale model met 27 miljard parameters — Apache 2.0-gewichten, uitgebracht op 13–14 augustus — en omdat de gewichten open zijn, kun je het zelf serveren in plaats van tokens te huren. Die fork is waar dit artikel eigenlijk over gaat.

De feiten die ertoe doen, met bronnen

• Architectuur — 27B dense (27,8B inclusief de vision tower en het opgevulde vocabulaire), 64 lagen, hidden size 5.120, vocabulaire 248.320. Officiële modelkaart, vandaag geverifieerd.

• Attention — hybride: 16 volledige attention-lagen, 48 lineaire Gated DeltaNet-lagen in een 3:1-blokpatroon. Slechts 16 lagen behouden een groeiende key-value-cache; de andere 48 behouden in plaats daarvan een recurrente toestand van vaste grootte.

• Context — 262.144 tokens native, uitbreidbaar tot ongeveer 1M via YaRN RoPE-schaling. Modelkaart, vandaag geverifieerd.

• Input — native tekst, afbeelding en video; tekstuitvoer. vLLM biedt alle drie aan via de standaard chat-completions API, zonder apart projectorbestand.

• Licentie — Apache 2.0. Dit ene feit is de reden waarom de vraag 'zelf hosten versus tokens huren' überhaupt bestaat.

• Gewichten — het BF16-checkpoint bedraagt in totaal 51,7 GB verspreid over 18 safetensors-shards (Hugging Face, vandaag geverifieerd). Qwen publiceert ook FP8- en NVFP4-checkpoints die zijn gebouwd voor vLLM.

• vLLM-vereiste — 0.17.0 of nieuwer, met transformers ≥ 5.8.0. vLLM's receptpagina, vandaag geverifieerd. "Elke vLLM" is geen veilige instructie; de kernels voor de recurrente laag zijn wat de nieuwe versie toevoegt.

• Multi-tokenvoorspelling — een draftkop voor speculatieve decodering wordt in de checkpoint meegeleverd, dus je hebt geen apart draftmodel nodig. vLLM documenteert de flag; er is nog geen onafhankelijke snelheidswinstmeting.

De GPU-ladder — welke quant op welke kaart

Drie serveerformaten bestrijken het praktische bereik. Kies op basis van de VRAM die je daadwerkelijk hebt, niet op basis van 'best quant'.

• NVFP4 — 24,6 GiB totaal (gewichten plus een FP8 KV-cache), volgens vLLM's recept bij TP1. Past op één Blackwell-klasse GPU — in de praktijk een 32GB RTX 5090 of een B200. Dit is het pad met de laagste latentie en het pad dat de meeste context per kaart behoudt: vLLM's recept rapporteert 6,6M KV-token capaciteit, zelfs bij de 1M-contextuitbreiding.

• FP8 — ongeveer 26GB aan gewichten. Eén 48GB-kaart (L40S, RTX A6000, RTX 6000 Ada) kan dit aan met ruimte voor context; twee 48GB-kaarten in tensor-parallel geven je ruimte voor langere context of hogere gelijktijdigheid. vLLM's eigen recept draait FP8 op TP4 over een vier-GPU GB300-tray wanneer je de grootst mogelijke KV-cache wilt.

• BF16 — 51,7 GB aan gewichten, dus één 80GB-GPU (H100, A100 80GB, B200, GB300) of twee 48GB-kaarten op TP2. Dit is de referentieprecisie-optie, en deze wordt daadwerkelijk gebruikt door het onderstaande 1M-context-extensiecommando.

• MXFP4 — niet gebruiken op NVIDIA. Het MXFP4-pad van vLLM mist momenteel de ondersteuning voor de lineaire methode; dezelfde gewichten worden gepubliceerd als NVFP4, het formaat dat het NVIDIA-recept daadwerkelijk gebruikt.

Voer het uit — de vLLM-opdrachten

De standaardinstelling voor één GPU met lage latentie (NVFP4, één Blackwell-GPU), woordelijk uit 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

Het FP8-commando uit hetzelfde recept (TP4, één GB300-tray, grootste KV-cache):

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

Voor twee 48GB-kaarten behoud je het FP8-commando en stel je --tensor-parallel-size 2 in plaats van 4 in.

Voeg dit toe aan een van beide commando's om MTP speculatieve decodering in te schakelen:

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

De 1M-contextuitbreiding (ook uit 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.

Wat vLLM's eigen pagina's wel en niet beloven

• Nog geen 27B-throughputcijfers. Vanaf 15 augustus publiceert de receptenpagina van vLLM geen throughput- of latentiebenchmarks voor Qwen3.8 27B. Het cijfer van "4.000+ tokens per seconde per GPU" dat rondgaat, heeft betrekking op de Qwen3.8 2.4T-A95B op een 72-GPU GB300 NVL72-rack, is afkomstig van de leverancier en is niet dit model. Communitycijfers voor tokens per seconde die je zult zien circuleren voor GGUF onder llama.cpp of Ollama — een andere runtime en een andere workload dan vLLM-serving.

• De goedkope-KV-cache-claim is runtime-afhankelijk. De modelkaart zegt dat slechts 16 van de 64 lagen een cache bewaren, maar dat helpt alleen als de serving-engine de Gated DeltaNet-lagen daadwerkelijk implementeert. vLLM 0.17+ is de versie die dat doet; daarom staat de versie-pin als eerste in dit artikel in plaats van als voetnoot.

• MTP is ingebouwd, maar hier niet gemeten. De draft head zit in de checkpoint en vLLM documenteert de flag, maar niemand heeft nog een onafhankelijk cijfer voor de snelheidswinst voor deze 27B op vLLM gepubliceerd. Plan om het te meten op je eigen verkeer.

• NVIDIA is het geteste pad. Het recept van vLLM is geschreven voor NVIDIA-GPU's (NVFP4 en FP8). Implementaties van dit hybride-aandachtsmodel op AMD Instinct of Intel Gaudi zijn nog steeds bleeding-edge, en dit artikel beweert niet het tegendeel.

Serveer het zelf, of huur de tokens

Hier doet Apache 2.0 zijn werk. Er zijn geen licentiekosten per token voor Qwen3.8 27B, dus de enige echte vraag is of je de hardware bezit of de tokens huurt.

• Zelf hosten (dit artikel) — je betaalt eenmalig voor de GPU, en elk token daarna is gratis. Een RTX 5090 die je al bezit maakt het NVFP4-commando een eindpunt met nul marginale kosten, zonder dat er gegevens het systeem verlaten. Als je de GPU moet huren, is een cloud-5090 of een paar A6000's de kostenpost, en het hele argument wint alleen als je de kaart al hebt of het aanhoudende volume.

• Huur de tokens — omdat de gewichten open zijn, draaien meerdere hosts het, en de prijsvloer ligt op de hardwarekosten. Qwen3.8 27B is vandaag live op OrcaRouter voor $0,33 per miljoen inputtokens en $2,40 per miljoen output — geen leveranciersopslag om door te berekenen, want OrcaRouter draait de open gewichten op de eigen infrastructuur — en dankzij dezelfde open gewichten is er een gratis laag met een aanvraaglimiet die $0 per aanvraag rekent en HTTP 429 retourneert wanneer je de limiet overschrijdt. Een representatieve maand van 10 miljoen tokens met 70% input komt uit op ongeveer $9,51 op de betaalde laag.

• De beslissingsregel — als je de GPU al bezit, host je zelf. Als je er een zou moeten kopen of huren, dan is de API al snel quitte bij volumes van zijprojecten, en dezelfde O​penAI-compatibele client wijst naar beide eindpunten, dus de code verandert niet wanneer je verhuist.

Wanneer vLLM het verkeerde antwoord is

• Je bent één persoon op een laptop — vLLM is een serving engine, geen desktop-app. Voor een lokale run door één gebruiker is llama.cpp of Ollama met een Q4 GGUF eenvoudiger en vereist een 24GB-kaart, geen Blackwell GPU; onze handleiding 'how-to-run-Qwen3.8-27B-locally' doorloopt dat pad van begin tot eind.

• Je hebt gegarandeerde doorvoer nodig zonder operationeel beheer — self-hosting betekent dat je zelf verantwoordelijk bent voor de paging, de wachtrijen en de failover. Als "de API ligt eruit" geen zin is die je in je woordenschat wilt hebben, huur dan in plaats daarvan de tokens en laat iemand anders de vloot beheren.

• Je hebt echt de volledige ~1M context nodig met topkwaliteit — dat is de taak van de Qwen3.8 2.4T-A95B, bediend door vLLM of SGLang op een 72-GPU GB300 NVL72 rack. Qwen3.8 27B op één of twee GPU's zal dat niet evenaren; ons artikel over de 2.4T legt uit waarom dat model een andere klasse probleem is.

• Je gebruikt een oudere 24GB-kaart — NVFP4 is een Blackwell-formaat; op Ampere (RTX 3090) of Ada (RTX 4090) 24GB-kaarten is het FP8-pad de vLLM-optie, en daarbuiten is een GGUF-kwant onder llama.cpp de pragmatische keuze. Hetzelfde model op een 24GB-kaart is een ander verhaal.

• Je moet maximale gelijktijdigheid op één kaart bieden — de standaardinstellingen voor één GPU hierboven zijn het startpunt, niet de productievorm. Stem --max-num-seqs, de KV cache en de MTP config af op je eigen aanvraagmix voordat je het als voltooid beschouwt.

Kortom

Qwen3.8 27B is de zeldzame dense 27B die vLLM in productie op een enkele GPU serveert. Update naar vLLM 0.17.0+, haal de NVFP4-quant van 24,6 GiB op voor een 32GB-Blackwell-kaart, de FP8-quant voor één 48GB-kaart of twee in tensor-parallel, en reserveer BF16 voor een 80GB-GPU. De commando's zijn one-liners, de endpoint is O​penAI-compatibel, en omdat de gewichten onder Apache 2.0 vallen, kun je het zelf serveren of huren voor $0,33/$2,40 per miljoen tokens met een gratis tier — in beide gevallen dezelfde clientcode. Het enige wat nog niemand heeft is een onafhankelijk throughput-getal voor de 27B op vLLM, dus reserveer een uur om te benchmarken nadat je het hebt opgestart, voordat je iemand een latency-getal belooft.