Qwen 3.8 27B op een VPS met Ollama draaien
Qwen 3.8 27B draait met Ollama op CPU-only VPS’en, maar niet met 8 of 16 GB RAM. Bekijk de vereiste 18 GB download, snelheid en passende VPS-grootte.
Kunt u Qwen 3.8 27B op een VPS zonder GPU uitvoeren?
Voor het uitvoeren van Qwen 3.8 27B op een VPS hebt u de tag qwen3.8:27b nodig. Sinds 21 October 2026 bevat de Ollama-bibliotheek deze als lokaal te downloaden tag: 27.3 miljard parameters, Q4_K_M-kwantisatie, een Apache 2.0-licentie, een contextvenster van 256K en een download van 18 GB met daarin ook een vision projector van ongeveer 0.9 GB. Ollama heeft ondersteuning voor Qwen 3.8 27B toegevoegd in v0.32.12, dat op 14 August 2026 is uitgebracht. Een oudere installatie moet u daarom eerst bijwerken. Sinds 29 October 2026 is de nieuwste stabiele release v0.40.13, gepubliceerd op 28 October 2026.
Het korte antwoord is: ja, op een VPS van 32 GB of meer, maar langzaam. Een dicht 27B-model in Q4 heeft alleen voor de gewichten ongeveer 17 GB RAM nodig, voordat er ook maar één contexttoken is opgeslagen. Daarmee vallen abonnementen met 8 GB en 16 GB volledig af. Op een gangbare VPS met tweekanaals DDR4 ligt de bovengrens rond 3 tokens per seconde. Dat is langzamer dan de meeste mensen lezen.
De eerdere 27B-tags staan nog steeds in de bibliotheek: qwen3.6:27b en qwen3.5:27b zijn beide Q4_K_M-builds van vergelijkbare omvang. Qwen3.8-27B behoudt de architectuur van Qwen3.6-27B. De officiële configuratiebestanden voor beide modellen geven dezelfde layerindeling. De onderstaande geheugenberekening geldt daarom voor beide. Controleer de actuele lijst voordat u een opdracht kopieert op de Ollama-pagina met Qwen3.8-tags. De berekening is gebaseerd op het aantal parameters, het aantal bits per gewicht en de indeling van de attention, niet op het versienummer.
Welke Ollama-tag u moet ophalen en hoe u dit controleert
Als u een tag ophaalt die niet bestaat, krijgt u een duidelijke foutmelding. U kunt dit dus snel op de server zelf controleren. Een bestaande tag kan lokaal alsnog niet uitvoerbaar zijn. Dat zorgt vaak voor problemen met GLM 5.2, dat wel in de library staat maar alleen vanuit de cloud van Ollama wordt aangeboden.
ollama --version
ollama pull qwen3.8:27b
ollama show qwen3.8:27bollama show toont de architectuur, het aantal parameters, de contextlengte en de quantisatie van de tag die u daadwerkelijk hebt. Als de parameterregel 27.3B vermeldt en de quantisatieregel Q4_K_M vermeldt, gebruikt u de build waarop deze handleiding is gebaseerd. De library bevat voor dezelfde gewichten ook qwen3.8:27b-q8_0 en qwen3.8:27b-bf16 met een hogere precisie, varianten van 27b-mtp en de tags 27b-nvfp4, 27b-mxfp8, 27b-mlx en 27b-mlx-bf16, die op de tagpagina als MLX worden aangeduid. Dit formaat is bedoeld voor Apple Silicon en niet voor een Linux VPS. In tegenstelling tot qwen3.6 heeft de vermelding qwen3.8 geen 35b-a3b-tags. Deze MoE-modellen (mixture of experts) vallen nog steeds onder qwen3.6 en gedragen zich op de CPU heel anders. Hieronder leest u daar meer over.
Aantal parameters maal bytes per gewicht
De gegevens achter deze grafiek
[
{
"label": "Q4_K_M",
"size_gb": 17,
"bits_per_weight": 4.98,
"notes": "published tag qwen3.8:27b, language model file"
},
{
"label": "Q5_K_M",
"size_gb": 19.5,
"bits_per_weight": 5.7,
"notes": "computed, no official library tag exists"
},
{
"label": "NVFP4",
"size_gb": 18,
"bits_per_weight": 5.27,
"notes": "published tag 27b-nvfp4, MLX build, one file including the vision encoder"
},
{
"label": "Q8_0",
"size_gb": 29,
"bits_per_weight": 8.5,
"notes": "published tag 27b-q8_0, language model file"
},
{
"label": "BF16",
"size_gb": 55,
"bits_per_weight": 16.1,
"notes": "published tag 27b-bf16, language model file"
}
]De formule bestaat uit één regel. Het aantal bytes voor gewichten = aantal parameters * bits per gewicht / 8. Bij exact 4 bits zouden 27.3 miljard parameters 13.7 GB innemen. Het taalmodelbestand in de geleverde Q4_K_M-tag is 17 GB groot. In de praktijk komt dat neer op 4.98 bits per gewicht.
Dat verschil is geen fout. K-quant-indelingen slaan niet elke tensor op met de nominale bitbreedte. Tensoren die door compressie de meeste kwaliteit verliezen, krijgen meer bits. De tensorlijst van Ollama voor het geleverde qwen3.8:27b-bestand toont deze op Q6_K: de uitvoerlaag, ongeveer de helft van de feed-forward-downprojecties, de attention-V-projecties in ongeveer de helft van de lagen met volledige attention en ongeveer de helft van de gefuseerde QKV-projecties in de lagen met lineaire attention. De kleine normalisatietensoren behouden de volledige precisie van 32 bits. De tokenembedding, de attention-Q- en K-projecties en de feed-forward-gate- en upprojecties blijven op Q4_K, net als de meeste andere modelonderdelen. De naam van de indeling is een gemiddelde. Dat gemiddelde ligt rond 5. Hetzelfde effect is zichtbaar aan de andere kant van de schaal: 55 GB voor BF16 komt neer op 16.1 bits per gewicht in plaats van een vaste 16. Daar is de tokenembedding, net als al het andere, BF16. Het kleine overschot komt door de metadata van het bestand, de normalisatietensoren die op 32 bits blijven en het feit dat de vermelde grootte is afgerond op de dichtstbijzijnde gigabyte.
Houd rekening met de volledige tag, niet alleen met het taalmodelbestand. Elke GGUF-tag van qwen3.8:27b bevat ook een vision projector van ongeveer 0.9 GB. Daarom wordt de Q4_K_M-tag vermeld als 18 GB.
Q5_K_M heeft geen gepubliceerde tag in de officiële qwen3.8-bibliotheekvermelding. Daarom is de rij van 19.5 GB berekend met de gebruikelijke 5.7 bits per gewicht voor deze indeling en niet gemeten. Q8_0 verdubbelt Q4 bijna tot 29 GB. Op een systeem dat alleen de CPU gebruikt, verdubbelt die omvang de geheugendoorvoer per token. Daardoor halveert ook ongeveer het aantal tokens per seconde. Alleen daarom is Q4_K_M hier de juiste standaardkeuze. Als u de kwaliteitsafweging wilt beoordelen in plaats van alleen het geheugengebruik, laat een nadere vergelijking van Q4, Q8 en fp16 zien vanaf welk punt de uitvoer daadwerkelijk verslechtert.
Wat de KV-cache kost naarmate de context groeit
De gewichten vormen een vaste kostenpost. De KV-cache (key- en value-cache, de aandachtstoestand die het model bewaart voor elke token die het al heeft gezien) groeit lineair met de contextlengte. Hier raakt de meeste RAM in de praktijk op.
De gegevens achter deze grafiek
[
{
"label": "4k tokens",
"kv_f16_gb": 0.25,
"kv_q8_gb": 0.13
},
{
"label": "8k tokens",
"kv_f16_gb": 0.5,
"kv_q8_gb": 0.25
},
{
"label": "16k tokens",
"kv_f16_gb": 1,
"kv_q8_gb": 0.5
},
{
"label": "32k tokens",
"kv_f16_gb": 2,
"kv_q8_gb": 1
},
{
"label": "64k tokens",
"kv_f16_gb": 4,
"kv_q8_gb": 2
},
{
"label": "128k tokens",
"kv_f16_gb": 8,
"kv_q8_gb": 4
}
]Deze cijfers komen uit het configuratiebestand van het model. Qwen3.8-27B is, net als Qwen3.6-27B, een model met hybride aandacht. Slechts 16 van de 64 lagen gebruiken volledige aandacht en houden een cache bij die met elke token groeit. Deze lagen hebben onder GQA (grouped-query attention) 4 key/value-heads en een headdimensie van 256. De overige 48 lagen gebruiken lineaire aandacht (Gated DeltaNet) en houden in plaats daarvan een toestand met vaste omvang bij. Volgens mijn berekening is die ongeveer 150 MB per conversatieslot, ongeacht de contextlengte. Dat komt neer op 64 KiB per token bij f16, dus 2 GB bij 32k tokens en 8 GB bij 128k. Vertrouw mijn berekening niet zonder die op uw eigen systeem te controleren. Laad het model en lees de kolom SIZE van ollama ps. Die rapporteert gewichten, cache en overhead als één geheel.
De context van 256K in de modelkaart is met deze architectuur haalbaar, maar niet kosteloos. Het vullen ervan bij f16 kost ongeveer 16 GB aan cache boven op de gewichten, op een machine die al 17 GB aan gewichten gebruikt. Ollama geeft u standaard niet het volledige contextvenster. De documentatie over de contextlengte van Ollama stelt de standaardwaarde in op basis van VRAM: 4k tokens bij minder dan 24 GiB, 32k bij 24 tot 48 GiB en 256k bij 48 GiB of meer. Een CPU-only VPS heeft helemaal geen VRAM en valt daarom in de categorie van 4k. U verhoogt deze waarde bewust met OLLAMA_CONTEXT_LENGTH. Deze variabele geldt voor de hele server, maar is niet de enige instelmogelijkheid. Met num_ctx instellen in het afzonderlijke verzoek houdt u een lage standaardwaarde voor alle andere verzoeken, terwijl één lange taak een groter contextvenster krijgt. Verhoog de waarde stapsgewijs en controleer ollama ps na elke wijziging.
Twee instellingen houden de cache klein. OLLAMA_KV_CACHE_TYPE=q8_0 slaat de cache op met 8 bits in plaats van 16. Bij 32k tokens daalt het gebruik daarmee van 2 GB naar 1 GB. Hiervoor is flash attention vereist. Stel daarom ook OLLAMA_FLASH_ATTENTION=1 in en controleer de afname in ollama ps in plaats van ervan uit te gaan dat de instelling is toegepast. Als u het cachetype nog niet eerder hebt gewijzigd, behandelt een uitleg over q8_0 versus f16 voor de KV-cache van Ollama het instellen van beide variabelen en het lezen van de waarden voor en na de wijziging. OLLAMA_NUM_PARALLEL=1 is net zo belangrijk. Ollama kan meerdere verzoeken tegelijk verwerken. Elk slot krijgt daarom zijn eigen deel van de context. Als u de parallelliteit verhoogt, vermenigvuldigt u stilzwijgend de cache waarvoor u capaciteit moet reserveren. De huidige standaardwaarde is al 1 en de onderstaande override legt die waarde vast. Als meer dan één persoon deze machine gebruikt, begint daar het probleem. Het aantal gelijktijdige gebruikers dat een zelfgehost model kan verwerken wordt veel eerder bepaald door cacheslots en de wachtrijdiepte dan door het aantal cores.
Wat past in 8, 16, 32 en 64 GB RAM
De gegevens achter deze grafiek
[
{
"label": "8 GB",
"q4_max_ctx_ktok": 0,
"q8_max_ctx_ktok": 0,
"notes": "Weights alone exceed the box. Use a 4b or 8b model."
},
{
"label": "16 GB",
"q4_max_ctx_ktok": 0,
"q8_max_ctx_ktok": 0,
"notes": "17 GB of weights does not fit in 16 GB of RAM."
},
{
"label": "32 GB",
"q4_max_ctx_ktok": 128,
"q8_max_ctx_ktok": null,
"notes": "Q4 fits with room for long context. Q8 weights fit, but usable context needs a measured total memory budget."
},
{
"label": "64 GB",
"q4_max_ctx_ktok": 256,
"q8_max_ctx_ktok": 256,
"notes": "Both fit with the full 256K window."
}
]Lees de twee getallen als duizenden contexttokens die naast de gewichten en de vision projector passen, met een f16-cache, op een headless Linux VPS met ongeveer 1.5 GB over voor het besturingssysteem en een kleine extra marge. Een nul betekent dat de gewichten zelf niet passen, dus dat er niets past; null betekent dat de gewichten wel passen, maar dat voor die categorie geen bruikbaar contextcijfer is bevestigd.
8 GB en 16 GB zijn geen twijfelgevallen. 17 GB aan gewichten past niet in 16 GB RAM, en geen enkele contextinstelling verandert dat. Extra swap biedt evenmin een oplossing. Ollama brengt het GGUF-bestand met memory mapping in kaart. Zodra de resident pages groter worden dan het RAM, begint de kernel deze pagina's te verwijderen en opnieuw in te lezen. Elk token haalt dan gigabytes van de schijf. De server heeft voortdurend hoge iowait en verwerkt aanzienlijk minder dan één token per seconde.
32 GB is het instappunt. De gewichten nemen 17 GB in beslag, de vision projector voegt ongeveer 0.9 GB toe en er blijft ruwweg 12.5 GB over. Dat is voldoende voor ongeveer 128k tokens aan f16-context, met marge. Q8_0-gewichten van 29 GB passen binnen 32 GB, maar de bruikbare context hangt ook af van de vision projector, de cache, het besturingssysteem en het runtimegeheugen. Controleer de totale geheugengrootte op uw server voordat u ervan uitgaat dat Q8 op deze categorie uitvoerbaar is.
64 GB biedt voldoende ruimte. Met Q4 blijft ruimte over voor het volledige venster van 256k, en ook Q8_0-gewichten passen samen met het volledige venster van 256k. Voordat u 64 GB aanschaft voor Q8, moet duidelijk zijn wat u daarvoor krijgt: een iets betere uitvoer tegen de helft van de snelheid, op een machine die al traag was. Q4 bereikt op een 32 GB-abonnement al 128k tokens. Voor vrijwel iedereen is dat de betere afweging.
Hoe snel is CPU-inferentie op een VPS?
Voor het genereren van één token uit een dense model moeten alle gewichten één keer uit het geheugen worden gelezen. Niet slechts een deel ervan. Alle gewichten. De snelheidslimiet wordt dus niet bepaald door het aantal cores, maar door de geheugenbandbreedte gedeeld door de omvang van de gewichten. Bij Q4 komt dat neer op 17 GB aan geheugenverkeer per token.
De gegevens achter deze grafiek
[
{
"label": "DDR4-2666, 2 channel",
"mem_bandwidth_gb_s": 42.6,
"ceiling_tok_s": 2.5
},
{
"label": "DDR4-3200, 2 channel",
"mem_bandwidth_gb_s": 51.2,
"ceiling_tok_s": 3
},
{
"label": "DDR5-4800, 2 channel",
"mem_bandwidth_gb_s": 76.8,
"ceiling_tok_s": 4.5
},
{
"label": "DDR4-3200, 8 channel",
"mem_bandwidth_gb_s": 204.8,
"ceiling_tok_s": 12
},
{
"label": "DDR5-4800, 12 channel",
"mem_bandwidth_gb_s": 460.8,
"ceiling_tok_s": 27.1
}
]Dit zijn bovengrenzen, geen metingen. In de praktijk ligt de uitvoersnelheid rond 50 tot 70 procent van de weergegeven waarde, omdat geheugenlatentie en onvolledig prefetching betekenen dat u de theoretische piek nooit bereikt. Een VPS met tweekanaals DDR4-3200 heeft een bovengrens van 3 tokens per seconde. Reken dus op ongeveer 2. Een systeem met tweekanaals DDR5-4800 heeft een bovengrens van 4.5. Reken daar op ongeveer 3.
Voor de grote serverconfiguraties geldt een belangrijke waarschuwing. Een EPYC-platform met twaalf geheugenkanalen heeft 460.8 GB/s en een bovengrens van 27.1 tokens per seconde, maar u huurt geen volledige EPYC-server. Geheugenbandbreedte is een hostbrede resource die wordt gedeeld door alle tenants op die machine. Een slice met 8 vCPU's beschikt dus niet over twaalf exclusieve geheugenkanalen. Handleidingen die op GPU's zijn gericht, laten dit volledig buiten beschouwing. Dit verklaart waarom twee VPS-abonnementen met hetzelfde aantal vCPU's bij hetzelfde model een factor drie kunnen verschillen.
Meer vCPU's leveren om dezelfde reden al snel geen voordeel meer op. Zodra de cores sneller om gegevens vragen dan de geheugencontroller die kan leveren, voegen extra threads alleen planningskosten toe. Ollama heeft geen omgevingsvariabele voor het aantal threads op serverniveau. Stel daarom num_thread in de aanvraag options in op het aantal fysieke cores, meet de snelheid en probeer daarna de helft van dat aantal. Op veel gedeelde abonnementen is de lagere instelling sneller.
Promptverwerking werkt anders. Prefill, de verwerking van uw invoer voordat het eerste token verschijnt, is voornamelijk afhankelijk van rekenkracht en niet van geheugenbandbreedte. De snelheid schaalt daardoor met het aantal cores. In de praktijk betekent dit dat er bij een grote prompt eerst een lange pauze is voordat de uitvoer begint, gevolgd door de hierboven genoemde gelijkmatige, lage snelheid. Meet beide delen afzonderlijk met --verbose. Hiermee worden voor elke aanvraag een prompt eval rate en een eval rate weergegeven.
Als het dense 27B-model eenvoudigweg te traag is, bekijk dan de tags qwen3.6:35b-a3b voordat u CPU-gebruik opgeeft. Deze activeren per token ongeveer 3 miljard parameters in plaats van alle 27.3 miljard. Daardoor neemt het geheugenverkeer per token met bijna een orde van grootte af, ook al is het bestand op schijf groter. U ruilt RAM-gebruik in voor snelheid. Ook de keuze van de runtime is hierbij van belang. Ollama en llama.cpp bieden verschillende CPU-optimalisatieopties voor dezelfde onderliggende inferentiecode.
Wanneer u beter een GPU-uur kunt huren
De gegevens achter deze grafiek
[
{
"label": "L40S, 48 GB",
"mem_bandwidth_gb_s": 864,
"ceiling_tok_s": 51
},
{
"label": "RTX 4090, 24 GB",
"mem_bandwidth_gb_s": 1008,
"ceiling_tok_s": 59
},
{
"label": "A100, 80 GB",
"mem_bandwidth_gb_s": 2039,
"ceiling_tok_s": 120
},
{
"label": "H100 SXM, 80 GB",
"mem_bandwidth_gb_s": 3350,
"ceiling_tok_s": 197
}
]Dezelfde formule toegepast op gepubliceerde GPU-geheugenbandbreedte levert een ander type antwoord op. Een consumentenkaart van 24 GB heeft voor deze gewichten een bovengrens van 59 tokens per seconde. Een actuele datacenterkaart haalt 197. Dat verschil dicht u niet door het aantal threads af te stemmen. De kaart gebruikt een geheugenbandbreedte van 1008 GB/s, terwijl uw VPS tientallen GB/s haalt.
Bepaal de grens daarom op basis van de workload en niet op basis van voorkeur. CPU-inferentie is de juiste keuze wanneer het werk asynchroon verloopt en niemand erop wacht: 's nachts een verzameling documenten samenvatten of een classificatietaak uitvoeren terwijl u slaapt. Huur een GPU zodra iemand op de uitvoer wacht of zodra er sneller verzoeken binnenkomen dan uw systeem ze kan verwerken. CPU-runtimes zijn niet beperkt tot één verzoek tegelijk: de documentatie van de llama.cpp-server beschrijft parallelle decodering en continuous batching op zowel CPU als GPU, en Ollama kan ook parallelle verzoeken verwerken, ten koste van meer cache. Uw gemeten verwerkingssnelheid in verhouding tot de aankomstsnelheid bepaalt de keuze. Meet daarom een realistische batch op uw eigen systeem. Zodra verzoeken sneller binnenkomen dan uw systeem ze verwerkt, groeit de wachtrij.
De kostenvergelijking is minder duidelijk dan zij lijkt. Voor een VPS van 64 GB betaalt u elk uur van de maand, ongeacht of het model is geladen. Bij een GPU-huur per uur staan de kosten voor rekenkracht los van de opslagkosten, die kunnen doorlopen nadat de GPU is gestopt. Als uw werkelijke gebruik twee uur per dag bedraagt, kan een gehuurde GPU zowel sneller als goedkoper zijn. Bereken eerst uw gebruikspercentage en bepaal daarna de prijs. Een VPS met een GPU kiezen behandelt waarop u de instance zelf controleert, en vLLM loopt op GPU voor op Ollama zodra u gelijktijdige verzoeken verwerkt omdat vLLM deze correct bundelt.
Er is nog een derde optie die vaak wordt vergeten. Houd het 27B-model op de CPU voor batchverwerking en gebruik een gehost API-model voor het interactieve pad. Niets verplicht u om één model voor beide doeleinden te gebruiken.
Ollama installeren en uw eigen systeem meten
Het installatiescript is het officiële script. Het stelt een systemd-service in die als de speciale gebruiker ollama draait.
curl -fsSL https://ollama.com/install.sh | sh
ollama --version
free -gollama --version moet 0.32.12 of hoger tonen. Dit is de eerste release met ondersteuning voor Qwen 3.8 27B. Controleer free -g voordat u iets binnenhaalt. De uitvoer gebruikt GiB. Een systeem met volgens de specificaties 32 GB RAM kan daarom ongeveer 29 tonen in de kolom total. Vergelijk het beschikbare geheugen met de eerder genoemde ruimte voor gewichten en cache.
Stel de runtime-opties in via een systemd-override en niet in uw shell. Het model draait binnen de service en ziet uw interactieve omgeving daarom niet.
sudo systemctl edit ollama[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_NUM_PARALLEL=1"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"
Environment="OLLAMA_KEEP_ALIVE=60m"sudo systemctl restart ollama
ollama pull qwen3.8:27b
ollama run qwen3.8:27b --verbose "Name two Linux distributions."De uitvoer van --verbose is de meting waarvoor u dit uitvoert. eval rate is het aantal tokens per seconde tijdens het genereren. prompt eval rate is de prefill-snelheid. load duration is de tijd die nodig was om de gewichten van schijf te lezen. Daarom is OLLAMA_KEEP_ALIVE=60m ingesteld: op een CPU kost het bij elk verzoek opnieuw laden van 17 GB vanaf schijf meer tijd dan het verzoek zelf. De standaardtime-out voor inactiviteit is vijf minuten. Daardoor betaalt een batchwachtrij met tussenpozen tussen items die laadtijd steeds opnieuw. de opties om een model geladen te houden omvatten zowel het veld keep_alive per verzoek als het permanent maken van de instelling, zodat deze na een reboot behouden blijft.
Controleer de geheugenvoetafdruk vanuit een tweede terminal terwijl het model geladen is.
ollama psDe kolom SIZE toont de werkelijke geheugenvoetafdruk, inclusief de KV-cache. Deze hoort ongeveer overeen te komen met de gewichten, de vision projector en de rij voor uw contextlengte in de KV-grafiek. Bij 8192 tokens en een 8-bits cache neemt het groeiende deel van de cache slechts ongeveer een kwart gigabyte in beslag. Bij een cache die op f16 bleef, zou dit 0.5 GB zijn, plus de vaste state van de lineaire attention. De kolom PROCESSOR moet 100% CPU tonen. Als daar iets anders staat, gebruikt iets een GPU. De snelheidsmetingen in deze handleiding zijn dan niet van toepassing op uw systeem.
Foutscenario's en de exacte tekenreeksen die u ziet
Het model wordt niet geladen. Ollama geeft een regel weer waarin beide waarden worden genoemd, in de vorm model requires more system memory (18.6 GiB) than is available (15.2 GiB). Dit is de goede fout, omdat Ollama dit controleerde voordat geheugen werd toegewezen, in plaats van het aan de kernel over te laten. Verlaag de contextlengte, kies een kleinere tag of stap over naar een groter plan.
Het proces verdwijnt halverwege een antwoord. De client toont niets bruikbaars en journalctl -u ollama -n 50 laat zien dat de service opnieuw wordt gestart. Voer dmesg -T | tail uit. Een regel met Out of memory: Killed process ... (ollama) betekent dat de OOM-killer van de kernel het proces heeft beëindigd. Dit gebeurt wanneer de controle vooraf slaagt, maar de cache tijdens een lang gesprek groter wordt dan de schatting. Verlaag de contextlengte.
Het ophalen mislukt direct. Error: pull model manifest: file does not exist betekent dat de tag niet in de library staat. Een versienummer dat nog niet is uitgebracht, geeft exact deze fout. Hetzelfde geldt voor een typefout in de tag. qwen3.8:27b bestaat wel. Als exact die tag mislukt, controleer dan eerst op een typefout. Bevestig de tag op de library-pagina voordat u uw netwerk de schuld geeft. Als een geldige tag wel wordt opgehaald maar niet wil starten, controleer dan ollama --version tegen 0.32.12.
Alles werkt, maar het is onaanvaardbaar traag. Minder dan één token per seconde op een systeem met voldoende RAM wijst op paging en niet op een tekort aan rekenkracht. Voer tijdens het genereren vmstat 1 uit. Een waarde die niet nul is in de kolom si of so betekent dat de kernel naar swap wisselt. De oplossing is een kortere context of minder geladen modellen. Een constant hoge waarde in wa zonder swapactiviteit betekent dat de memory-mapped gewichten opnieuw van schijf worden gelezen. Dat betekent dat ze niet echt in het geheugen passen.
Het eerste token duurt 30 seconden en daarna wordt de uitvoer sneller. Dat is prefill en is normaal. Een lange systeemprompt wordt bij elk verzoek opnieuw verwerkt wanneer de cache niet kan worden gebruikt. Verkort daarom eerst de systeemprompt voordat u iets anders afstemt.
Waar een 27B-model dat alleen op de CPU draait daadwerkelijk geschikt voor is
Stel verwachtingen op basis van de cijfers, niet op basis van hoop. Met twee tot vier tokens per seconde duurt een antwoord van 500 tokens twee tot vier minuten. Dat is onbruikbaar voor chat, maar goed werkbaar voor een wachtrij. Een model dat nadenkt voordat het antwoordt, maakt die berekening nog ongunstiger. De verborgen redeneertokens worden namelijk met dezelfde lage snelheid gegenereerd als het antwoord. Daarom is het afstemmen van het niveau van de redeneerinspanning op de taak een van de weinige manieren om een antwoord te verkorten zonder van model te wisselen. Het samenvatten van documenten, het in bulk toekennen van labels, het extraheren van velden uit een achterstand aan bestanden en onbemande codebeoordeling verdragen deze snelheid. Er wacht dan namelijk niemand op het antwoord. Hulp bij programmeren bevindt zich precies op die grens. Daarom loont het om een codeeragent een model te laten gebruiken dat u zelf host voor achtergrondtaken zoals commitberichten en testskeletten, maar niet voor inline-suggesties waarop u wacht.
Privacy is het belangrijkste argument. Het model draait op hardware die u huurt en beheert, geen enkel verzoek verlaat de server en u betaalt niets per token. Dat is veel waard voor gereguleerde gegevens, zelfs bij drie tokens per seconde. Vergelijk dit wel eerlijk met het alternatief: voor self-hosting van een model op frontier-schaal is een orde van grootte meer hardware nodig. Een 27B-model op de CPU is het goedkoopste punt op die schaal waarbij de uitvoer nog steeds de moeite waard is om te lezen.
Om dit te benchmarken hebt u echte gestructureerde invoer nodig. Voor de meeste openbare data-API's is echter eerst een account vereist voordat u de doorvoersnelheid kunt meten. Het demoschema van Strasmore (dat wij uitvoeren) documenteert alleen-lezen-SQL voor Amerikaanse aandelen- en optiedata, zonder sleutel en zonder registratie, met tabelnamen die de database bevatten: https://ai.strasmore.com/api/demo/sql?sql=SELECT ticker, close FROM global_markets.delayed_stocks_minute_aggs LIMIT 5. De demo beperkt elke aanroep tot 500 rijen en 20 seconden. De historische gegevens beginnen op 1 januari 2025. Dat is ruim meer dan een server met twee tokens per seconde kan verwerken. De volledige lijst met kolommen staat op https://ai.strasmore.com/api/demo/schema.
Als dit uw eerste Ollama-installatie is, behandelt de volledige handleiding voor het uitvoeren van Ollama op een VPS de serviceconfiguratie, de HTTP API en de firewallregels waarvan deze handleiding ervan uitgaat dat u ze al hebt ingesteld. Stel poort 11434 niet bloot aan internet. De lokale API van Ollama vereist geen authenticatie. Alles wat toegang heeft tot die poort kan uw model gebruiken.
FAQ
Is er een Qwen 3.8 27B-model op Ollama?
Ja. Op 21 oktober 2026 bevat de Ollama-bibliotheek een vermelding voor qwen3.8. qwen3.8:27b (ook voorzien van de tag latest) is een 18 GB Q4_K_M-build van een dicht model met 27.3 miljard parameters, een vision-projector en een contextvenster van 256K. Het draait lokaal en vereist Ollama v0.32.12 of hoger. De oudere tags qwen3.6:27b en qwen3.5:27b staan nog steeds vermeld. Controleer https://ollama.com/library/qwen3.8/tags voor de actuele lijst. Een tag die niet bestaat, mislukt met Error: pull model manifest: file does not exist.
Hoeveel RAM heb ik nodig om een Qwen 27B-model op een VPS te draaien?
32 GB is het praktische minimum voor Q4_K_M. De gewichten zijn 17 GB, de vision-projector voegt ongeveer 0.9 GB toe, het besturingssysteem heeft ongeveer 1.5 GB nodig en de KV-cache voegt bij f16 ongeveer 1 GB toe per 16,000 tokens context. Dat komt doordat slechts 16 van de 64 lagen van het model een groeiende cache bijhouden. Een abonnement met 16 GB kan de gewichten helemaal niet bevatten. Swap helpt niet, omdat het bestand via memory mapping wordt benaderd en de kernel het bij elk token opnieuw van schijf leest. Met 64 GB hebt u ruimte voor het volledige venster van 256K, zelfs met Q8_0-gewichten van 29 GB.
Hoeveel tokens per seconde levert een 27B-model op CPU?
Deel de geheugenbandbreedte door de omvang van de gewichten en neem daarvan vervolgens 50 tot 70 procent. Een VPS met tweekanaals DDR4-3200 heeft een theoretische bovengrens van ongeveer 3 tokens per seconde en levert ongeveer 2. Een machine met tweekanaals DDR5-4800 heeft een theoretische bovengrens van ongeveer 4.5 en levert ongeveer 3. Serverplatforms met meer geheugenkanalen zien er op papier veel beter uit, maar de geheugenbandbreedte wordt gedeeld door elke tenant op de host. Meet daarom uw eigen prestaties met ollama run qwen3.8:27b --verbose en lees de regel eval rate.
Moet ik Q4 of Q8 gebruiken op een CPU-only VPS?
In vrijwel alle gevallen Q4_K_M. Q8_0 is 29 GB tegenover 17 GB. De gewichten passen dus binnen 32 GB, maar de projector, cache, het besturingssysteem en de runtime laten weinig reserve over. Met 64 GB hebt u ruimte voor een lange context. Q8_0 verplaatst per token bijna twee keer zoveel geheugen, waardoor uw aantal tokens per seconde ongeveer halveert. Het kwaliteitsverschil tussen Q4_K_M en Q8_0 bij een 27B-model is voor de meeste taken klein. Gebruik het extra RAM liever voor een langere context. Dat verandert wat het model kan doen, in plaats van alleen de formulering van de uitvoer te veranderen.
Wanneer is het huren van een GPU goedkoper dan een VPS met veel RAM?
Wanneer uw gebruiksduur laag is of wanneer iemand op het resultaat wacht. Een GPU met 24 GB geheugen heeft voor deze gewichten een theoretische bovengrens van ongeveer 59 tokens per seconde, tegenover naar schatting 2 of 3 op een gebruikelijke VPS. De kosten voor GPU-rekenkracht per uur stoppen wanneer de instance stopt, maar permanente opslag kan nog steeds geld kosten. Voor een VPS met 64 GB betaalt u de hele maand, ongeacht of het model is geladen. Bereken hoeveel uur per dag u daadwerkelijk tokens genereert. Het omslagpunt hangt af van de huurtarieven, runtime en kosten voor permanente opslag. Continu batchwerk met lage prioriteit is het scenario waarin de VPS die altijd actief is de goedkoopste optie is.