Kimi K3 zelf hosten: hardwarevereisten en berekeningen
Wilt u Kimi K3 zelf draaien? Met 2,8 biljoen parameters is dit model een uitdaging. Ontdek de VRAM-berekeningen, KV-cache vereisten en drie realistische manieren voor hosting.
Wat er nodig is voor het zelf hosten van Kimi K3
Het zelf hosten van Kimi K3 betekent dat u ruimte moet vinden voor 2,8 biljoen parameters. Moonshot heeft de open gewichten gepubliceerd in MXFP4, wat neerkomt op ongeveer een halve byte per gewicht. De gewichten alleen beslaan dus ruwweg 1.4 TB, nog voordat u één token aan cache toewijst. Geen enkele accelerator die momenteel te koop is, kan dit zelfstandig bevatten. Voor één GPU is het antwoord nee. Voor één server is het antwoord ja, in twee configuraties. De eerste is een node met 8 GPU's van 288 GB, wat de kleinste gepubliceerde recepten voor multi-user serving gebruiken. De tweede is één machine met ongeveer 1,6 TB aan gecombineerd RAM en VRAM die Unsloth's verliesvrije Q8 GGUF in llama.cpp draait, met of zonder GPU, waarbij één gebruiker tegelijk wordt bediend.
Dat is het oordeel. Alles hieronder is de rekenkunde die erachter zit, omdat de rekenkunde het onderdeel is dat u hergebruikt bij de volgende release. Verschillende infrastructuurleveranciers publiceerden in de weken na de aankondiging op 16 juli 2026 handleidingen voor K3-implementatie, en elk daarvan ging ervan uit dat u al over een cluster beschikte. Deze pagina begint bij het andere uiterste: wat het kost, wat u in plaats daarvan kunt draaien en hoe u bepaalt in welke van die twee categorieën u valt.
Totaal aantal parameters en actieve parameters zijn niet gelijk
K3 is een Mixture of Experts-model. MoE (Mixture of Experts) splitst het netwerk op in vele subnetwerken en laat een router per token een selectie hiervan kiezen. De modelkaart vermeldt 2,8T totale parameters en 104B geactiveerde parameters per token, verdeeld over 896 gerouteerde experts waarvan er 16 worden geactiveerd per token, verspreid over 93 lagen.
Deze twee parameteraantallen beantwoorden verschillende vragen, en het verwisselen ervan is de meest gemaakte fout in elke discussie over "kan ik dit draaien".
Actieve parameters bepalen de rekenkosten. Een token wordt vermenigvuldigd met ongeveer 104B parameters, dus de doorvoer die u kunt verwachten is vergelijkbaar met een 104B dense-model in plaats van een 2,8T-model. Dat is de volledige reden om een MoE te bouwen.
Totale parameters bepalen de geheugenkosten. De router kan bij elk token een willekeurige expert selecteren, dus elke expert moet op een snelle locatie staan voordat het eerste verzoek binnenkomt. Het vasthouden van alleen de actieve experts in VRAM en het ophalen van de rest op aanvraag is mogelijk: --moe-cache-mib van llama.cpp houdt een GPU-cache bij van experts die anders in het systeem-RAM staan en uploadt de ontbrekende experts zodra de router ze selecteert. Dit verkleint het totaal echter niet. De overige experts moeten nog steeds in het RAM staan, en een PCIe-verbinding verplaatst tientallen gigabytes per seconde tegenover de terabytes per seconde van HBM, dus elke cache-miss kost tijd. Het streamen van experts vanaf NVMe omdat het model ook niet in het RAM past, is nog trager, en de K3-handleiding van Unsloth waarschuwt dat disk-offloading aanzienlijk langzamer werkt.
Het is dus goedkoop om te berekenen en duur om op te slaan. Baseer de hardware op 2,8T. Baseer uw verwachtingen voor de snelheid op 104B.
Bytes per gewicht, en waar de terabytes vandaan komen
Aantal parameters vermenigvuldigd met bytes per gewicht. Dat is de volledige formule voor de gewichten.
De gegevens achter deze grafiek
[
{
"label": "bf16",
"bytes_per_weight": 2,
"weights_tb": 5.6
},
{
"label": "fp8",
"bytes_per_weight": 1,
"weights_tb": 2.8
},
{
"label": "4-bit (MXFP4, as shipped)",
"bytes_per_weight": 0.5,
"weights_tb": 1.4
},
{
"label": "2-bit",
"bytes_per_weight": 0.25,
"weights_tb": 0.7
}
]K3 is getraind met quantisation-awareness en uitgebracht met MXFP4-gewichten en MXFP8-activaties, dus de 4-bit rij is de werkelijke waarde. De rijen daarboven dienen ter vergelijking: bij bf16 zou hetzelfde model 5.6 TB vereisen. MXFP4 slaat bovendien een gedeelde 8-bit schaal op voor elk blok van 32 gewichten, wat ongeveer 6 procent toevoegt. De configuratie van Moonshot laat de attention-lagen, de gedeelde experts en de vision tower buiten het 4-bit formaat, waardoor het volledige checkpoint volgens de berekening van Unsloth uitkomt op ongeveer 1,56 TB in plaats van een zuivere 1.4 TB.
Dit verkleint de gebruikelijke ontsnappingsroute zonder deze volledig af te sluiten. Het uitgebrachte checkpoint is al 4-bit, dus de eenvoudige besparing is al behaald, maar verder verlagen verandert het getal nog steeds. Per 27 oktober 2026 variëren de dynamische GGUF-quantisaties van K3 die Unsloth heeft gemeten van 861,3 GB voor de 2-bit UD-Q2_K_XL tot 594 GB voor de 1-bit UD-IQ1_S. Unsloth publiceert wat dat kost: de top-1 token-overeenkomst met het volledige model is 90,390 procent bij UD-Q2_K_XL, 84,127 procent bij de 711,1 GB UD-IQ2_XXS en 78,875 procent bij UD-IQ1_S. De Hugging Face-repo bevat ook kleinere 1-bit bestanden, tot 466 GB voor UD-Q1_0, zonder dat daar een overeenkomstcijfer bij is gepubliceerd. Dat is een gemeten nauwkeurigheidsverlies, en zelfs het kleinste bestand is nog steeds ongeveer 1,6 keer de capaciteit van de grootste enkele kaart.
Hoeveel GPU's heeft Kimi K3 nodig
De gegevens achter deze grafiek
[
{
"config": "H100 80GB",
"hbm_per_gpu_gb": 80,
"gpus_for_weights": 18
},
{
"config": "H200 141GB",
"hbm_per_gpu_gb": 141,
"gpus_for_weights": 10
},
{
"config": "B200 192GB",
"hbm_per_gpu_gb": 192,
"gpus_for_weights": 8
},
{
"config": "GB300 288GB",
"hbm_per_gpu_gb": 288,
"gpus_for_weights": 5
}
]Beschouw deze aantallen als een ondergrens, niet als een streefwaarde. Ze tellen enkel de gewichten: zonder KV-cache, activatiebuffers, allocator-fragmentatie of ruimte voor een tweede gelijktijdige aanvraag. De verdeling hoeft niet gelijkmatig te zijn: de pipeline-parallelism van vLLM verdeelt het model over lagen en ondersteunt ongelijke verdelingen, en de K3 prefill-recepten van SGLang draaien 8 en 16 pipeline-stages over 93 lagen.
De gepubliceerde richtlijnen liggen boven deze ondergrens. De lanceringsrichtlijnen van Moonshot adviseerden een supernode van 64 of meer accelerators. Sinds 27 oktober 2026 levert het SGLang-kookboek een H100-configuratie opgebouwd uit vier 8-GPU nodes, 32 GPU's en 2.560 GB aan totaal geheugen, tegenover een ondergrens van 18 kaarten. Het vermeldt ook single-node recepten op één 8-GPU B300 node en één 8-GPU MI350X of MI355X node, met 2.304 GB bij 288 GB per kaart. Dat verschil boven de ondergrens is geen verspilling. Het is ruimte voor KV-cache, activatiegeheugen en de marge die de server in staat stelt om veel aanvragen tegelijk te verwerken. De meest toegankelijke rij, 5 GB300-klasse kaarten, wordt in de praktijk afgerond naar precies zo'n 8-GPU node; dit is de kleinste machine waarvoor iemand een K3-servingrecept voor meerdere gebruikers publiceert.
De KV-cache is het onderdeel dat mensen vaak verrast
Gewichten zijn een vaste kostenpost. De KV-cache (key value) is dat niet: deze groeit met de contextlengte en opnieuw met elke gelijktijdige gebruiker. Voor standaard attention is de formule bytes per token = 2 * layers * kv_heads * head_dim * bytes_per_element, en vervolgens vermenigvuldigt u dit met de contextlengte en de gelijktijdigheid.
Hier is een uitgewerkt voorbeeld, en het is slechts een voorbeeld: 64 lagen, 8 KV-heads, head-dimensie 128, fp8. Dat geeft 2 64 8 128 1 = 131.072 bytes, oftewel 128 KiB per token.
De gegevens achter deze grafiek
[
{
"label": "8k context",
"kv_gib_per_user": 1
},
{
"label": "32k context",
"kv_gib_per_user": 4
},
{
"label": "128k context",
"kv_gib_per_user": 16
},
{
"label": "1M context",
"kv_gib_per_user": 128
}
]Eén gebruiker met een context van 128k kost 16 GiB. Eén gebruiker met de volledige miljoen kost 128 GiB, wat bijna de helft is van een 288 GB-kaart voor één gesprek, nog voordat er een enkel gewicht is geladen.
K3 gebruikt geen standaard attention, en dat laatste getal is de reden waarom. De 93 lagen bestaan uit 69 KDA-lagen (Kimi Delta Attention) en 24 Gated MLA-lagen (multi-head latent attention). KDA behoudt een recurrente status van vaste grootte in plaats van een cache die met elk token groeit, en MLA comprimeert key en value tot één low-rank latent vector. Hierdoor liggen de werkelijke kosten per token ver onder het uitgewerkte voorbeeld. De gepubliceerde config.json van Moonshot geeft de grootte van die latent aan: een kv_lora_rank van 512 plus een 64-brede rotary key (qk_rope_head_dim), dus 576 waarden per token per MLA-laag. Over 24 lagen van elk 2 bytes is dat 27.648 bytes, ongeveer 27 KiB per token, of ruwweg 27 GiB voor een volledig gesprek van 1.048.576 tokens, plus de vaste KDA-status. Beschouw dit als een schatting in plaats van een meting: engines reserveren en structureren de cache op hun eigen manier, en een 8-bit cache halveert dit ongeveer.
Om te zien wat uw eigen implementatie in beslag neemt, moet u niet naar nvidia-smi kijken terwijl u --max-model-len verhoogt. vLLM pre-alloceert de KV-cachepool, gebaseerd op --gpu-memory-utilization (standaard 0.92 in de huidige documentatie) of op basis van een expliciet cachebudget per GPU. Het totale GPU-geheugen toont daarom de pool in plaats van één gesprek. Lees in plaats daarvan het opstartlogboek, waarin vLLM de grootte van de KV-cache in tokens en de maximale gelijktijdigheid bij uw contextlengte rapporteert.
De vorm van de redenering blijft behouden in de volgende release. Als een model een context van een miljoen tokens adverteert en niets vermeldt over het attention-ontwerp, ga er dan vanuit dat de cache de beperkende factor is totdat iemand het tegendeel bewijst.
Tier 1: het cluster per uur huren
Dit is de tier die K3 op de uitgebrachte precisie aan vele gebruikers tegelijk aanbiedt. Eén machine met voldoende RAM kan K3 ook op de uitgebrachte precisie draaien via Unsloth's Q8 GGUF, wat Unsloth als verliesvrije volledige precisie bestempelt, maar die methode bedient slechts één gebruiker tegelijk en wordt in tier 2 behandeld. Hier koopt u de hardware niet. U huurt deze voor de uren die u nodig heeft en stopt de huur daarna.
De gegevens achter deze grafiek
[
{
"label": "1 GPU, always on",
"gpu_hours": 720,
"usd_cost": "1,800"
},
{
"label": "8 GPUs, 4 hours a day",
"gpu_hours": 960,
"usd_cost": "2,400"
},
{
"label": "8 GPUs, always on",
"gpu_hours": 5760,
"usd_cost": "14,400"
},
{
"label": "32 GPUs, always on",
"gpu_hours": 23040,
"usd_cost": "57,600"
}
]Het tarief is een aanname, geen offerte. On-demand tarieven variëren sterk per provider en per GPU-generatie; de 288 GB-onderdelen die de single-node recepten vereisen, kosten per uur meer dan een H100, en gereserveerde capaciteit is goedkoper. Gebruik het werkelijke tarief van uw provider en voer de vermenigvuldiging opnieuw uit: GPU's maal uren maal tarief. Het doel van de tabel is de verhouding. Het inzetten van een 8 GPU-node gedurende vier uur per dag kost 2,400 USD per maand, terwijl het continu laten draaien van de SGLang-configuratie met 32 GPU H100's 57,600 USD kost.
Beide gangbare servers publiceren een opstartcommando op de modelkaart.
pip install vllm
vllm serve "moonshotai/Kimi-K3"pip install sglang
python3 -m sglang.launch_server --model-path "moonshotai/Kimi-K3" --host 0.0.0.0 --port 30000Geen van beide kale commando's is wat u op een echt cluster uitvoert. Voeg de parallellisatie-flags toe die overeenkomen met uw hardware: SGLang gebruikt --tp-size voor tensor parallel, --pp-size voor pipeline parallel en --ep-size voor expert parallel. Tensor parallel maal pipeline parallel moet gelijk zijn aan het aantal GPU's dat u daadwerkelijk heeft, en expert parallel splitst de experts binnen die groep; daarom stelt het 32 GPU H100-recept zowel --tp-size 32 als --ep-size 32 in.
Controleer of de server is opgestart voordat u echt verkeer verstuurt:
curl http://127.0.0.1:30000/v1/modelsEen gezonde server antwoordt met een JSON-object waarin de model-id wordt vermeld. Connection refused betekent dat het proces nog bezig is met het laden van gewichten of al is afgesloten; lees dus het serverlogboek voordat u het opnieuw probeert.
De meest voorkomende fout in de eerste weken was een runtime die ouder was dan het model. K3 werd uitgebracht met KDA en een nieuwe MoE-laag die de stabiele vLLM- en SGLang-releases bij de lancering nog niet bevatten. Het symptoom hiervan is dat de server tijdens het opstarten afsluit met een regel in de vorm van Model architectures [...] are not supported for now. Geen enkele configuratiewijziging lost dit op, omdat de code om die lagen uit te voeren niet in uw build aanwezig is. Dat is inmiddels veranderd: sinds 27 oktober 2026 bevat SGLang ondersteuning voor K3 in zijn releases vanaf v0.5.17, met v0.5.22 als de meest recente versie, en de release notes van vLLM v0.28.0 tot v0.32.0 bevatten allemaal K3-werkzaamheden. Installeer een actuele release. Sommige hardware-specifieke paden verwijzen nog steeds naar een specifieke image, zoals SGLang's NVFP4-builds op Blackwell; controleer dus het recept voor uw kaart.
Een kostenpost waar mensen vaak tegenaan lopen: de meter begint te lopen zodra de instantie start, niet wanneer het model gereed is. Een download van 1,56 TB met 1 GB/s kost ongeveer 26 minuten aan clustertijd voordat het eerste token wordt gegenereerd. Sla de gewichten op een volume op dat langer meegaat dan de instantie, zodat de tweede run binnen enkele minuten start.
Tier 2: een kleiner model draaien op één accelerator
U draait in deze tier geen K3. Spreek dit hardop uit voordat u begint, aangezien de meeste discussies over "K3 lokaal draaien" hier eindigen zonder dit toe te geven.
De regel voor pasvorm is dezelfde formule in het klein: parameters vermenigvuldigd met bytes per gewicht, plus KV-cache, plus ongeveer 2 GB aan runtime-overhead, moet onder uw VRAM blijven. Bij 4-bit is dat ongeveer een halve byte per parameter, wat comfortabele combinaties oplevert:
- 16 GB kaart: een 7B model op 4-bit met ruimte voor een lange context
- 24 GB kaart: een 14B model op 4-bit
- 48 GB kaart: een 32B model op 4-bit
- 80 GB kaart: een 70B model op 4-bit, of een 30B klasse MoE op 8-bit
Elke bovenstaande combinatie gaat uit van één verzoek tegelijk. Zodra een tweede persoon een prompt verstuurt, vereist elke gelijktijdige slot een eigen KV-cache. Dit is de afweging die Ollama's NUM_PARALLEL en MAX_QUEUE instellingen voor u maken tussen parallelle slots, wachtrijen voor verzoeken en het resterende VRAM.
Er is één manier om K3 zelf op een enkele grote machine te draaien, en deze bevindt zich tussen deze tier en de vorige. Unsloth documenteert GGUF-builds van K3 in llama.cpp, van 1-bit en 2-bit kwantisaties tot UD-Q8_K_XL, wat zij labelen als lossless op volledige precisie, en zij noemen een NVIDIA DGX Station als hardware die deze kan draaien. De vuistregel is dat RAM plus VRAM ongeveer gelijk moet zijn aan de kwantisatiegrootte, van ongeveer 610 GB voor de 1-bit UD-IQ1_S build tot ongeveer 1.6 TB voor de Q8. Daaronder valt het model terug op de schijf en vertraagt het aanzienlijk. Een GPU is optioneel: de build-instructies van Unsloth schakelen CUDA uit "als u geen GPU heeft of alleen CPU-inferentie wilt". De 1-bit en 2-bit builds zijn K3 zwaar gekwantiseerd, met het hierboven gemeten verlies aan nauwkeurigheid. De Q8-build is K3 op de uitgebrachte precisie, geserveerd aan één gebruiker op RAM-snelheid. Geen van beide is een kleiner model.
Ollama is de kortste weg naar een werkende server op een VPS met een gekoppelde GPU:
curl -fsSL https://ollama.com/install.sh | sh
ollama run qwen3:14bollama run downloadt het model bij het eerste gebruik en brengt u vervolgens naar een prompt. Een tag die niet bestaat geeft Error: model "..." not found terug, dus kopieer tags van de bibliotheekpagina in plaats van ze uit het hoofd te typen. De volledige handleiding, inclusief de systemd-unit en externe toegang, staat in Ollama draaien op een VPS.
llama.cpp biedt u meer controle over kwantisatie en offloading:
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j./build/bin/llama-server -m model.gguf -c 8192 -ngl 99 --host 0.0.0.0 --port 8080-ngl 99 vraagt om elke laag op de GPU te plaatsen. Lees het laadlogboek: dit toont hoeveel lagen er zijn ge-offload. Lagen die uitlopen naar het systeem-RAM draaien op RAM-bandbreedte in plaats van HBM-bandbreedte, waardoor de generatiesnelheid met een factor tien afneemt zodra het model niet meer past. De afwegingen tussen beide tools worden behandeld in Ollama en llama.cpp vergeleken.
Tier 3: gehoste API, zelfgehoste orkestratie
De gegevens achter deze grafiek
[
{
"label": "Input, cache hit",
"usd_per_million_tokens": "0.30"
},
{
"label": "Input, cache miss",
"usd_per_million_tokens": "3.00"
},
{
"label": "Output",
"usd_per_million_tokens": "15.00"
}
]Het eindpunt is compatibel met OpenAI, waardoor een bestaande client werkt nadat u de basis-URL heeft gewijzigd.
curl https://api.moonshot.ai/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $MOONSHOT_API_KEY" \
-d '{"model": "kimi-k3", "messages": [{"role": "user", "content": "Say hello."}]}'Een werkende sleutel retourneert een JSON-object met een choices-array. Een 401 betekent dat de authenticatie is mislukt: controleer of de sleutel correct is, niet is verlopen of uitgeschakeld, en of de header Authorization: Bearer gevolgd door de sleutel bevat. Een foutmelding over een niet-gevonden model betekent meestal dat de id is gewijzigd, omdat providers id's buiten gebruik stellen tussen checkpoints door.
Kijk nu naar het omslagpunt, uitgaande van het bovenstaande huurtarief. Een node met 8 GPU's die altijd aan staat, kost 14,400 USD per maand. Bij 15.00 USD per miljoen output-tokens koopt u voor hetzelfde bedrag ongeveer 960 miljoen output-tokens via de API. Om kostenvoordeel te behalen, moet u bijna een miljard output-tokens per maand genereren, oftewel ongeveer 30 miljoen per dag, en het cluster continu bezet houden. Inactieve GPU's worden namelijk tegen hetzelfde tarief gefactureerd als actieve GPU's. Agent-workloads met veel prompts verschuiven deze grens nog verder: herhaalde context wordt gefactureerd tegen het cache-hit-tarief van 0.30 USD per miljoen, in plaats van het cache-miss-tarief van 3.00 USD.
Wat u in deze laag zelf host, is alles rondom het model: een gateway die de API-sleutel vasthoudt zodat deze nooit een client bereikt, logs voor verzoeken en antwoorden, retries, rate limits en budgetten per gebruiker. Dit draait op een kleine VPS zonder GPU. Dezelfde verdeling geldt voor gesloten modellen, waarbij het zelf hosten van Claude op modelniveau niet mogelijk is en orkestratie het enige onderdeel is dat u in eigen beheer heeft.
Welke serverstack hoort bij welke laag
vLLM- en SGLang-klasse servers behoren tot laag 1. Deze zijn ontworpen om veel verzoeken tegelijkertijd te verwerken, met behulp van continuous batching en een paged KV cache, aangevuld met tensor- en expert-parallelisme verspreid over meerdere nodes. Ze gaan uit van datacenter-accelerators en een snelle interconnect tussen deze nodes. Op een enkele consumentenkaart zijn ze zwaarder om te installeren en bieden ze nauwelijks merkbare voordelen.
llama.cpp en Ollama behoren tot laag 2. Deze richten zich op één machine, GGUF-kwantisatie, CPU-offload wanneer het model niet in het geheugen past, en een lage gelijktijdigheid. llama.cpp laadt een enorm MoE-model door expert-gewichten in het systeem-RAM (--cpu-moe of --n-cpu-moe) te houden en, met --moe-cache-mib, de gebruikte experts in de GPU te cachen; op deze manier draaien Unsloth's K3 GGUF-builds op één machine. De snelheid is dan afhankelijk van de RAM-bandbreedte en hoe vaak de router de cache mist. Als het bestand groter is dan het gecombineerde RAM en VRAM, wordt er uitgeweken naar de schijf. Dit is een werkbare configuratie voor één gebruiker. Het is geen dienst waar u veel gebruikers op kunt laten werken. De volledige vergelijking staat in Ollama versus vLLM, en dit verandert niet per model: de vraag is altijd of u veel gebruikers bedient op gedeelde hardware of één gebruiker op uw eigen systeem.
De vier getallen die dit checkpoint overleven
- Het totaal aantal parameters vermenigvuldigd met bytes per gewicht bepaalt de minimale geheugenbehoefte. Niets draait onder deze grens bij de uitgebrachte precisie, en kwantisatie onder een 4-bit release levert maximaal ongeveer 70 procent winst op ten koste van nauwkeurigheid, geen orde van grootte.
- Actieve parameters bepalen de doorvoerklasse. Een 2.8T MoE met 104B actieve parameters rekent als een 104B model.
- KV-cache per token, vermenigvuldigd met contextlengte en gelijktijdigheid, is de kostenpost die blijft groeien nadat u voor de gewichten heeft betaald.
- Tokens per seconde per dollar is het enige getal dat een tier bepaalt. Alles hierboven is input daarvoor.
Pas deze vier toe op elke release en u krijgt het juiste antwoord voordat u een handleiding van de leverancier opent. De volgende is al aangekondigd: Moonshot rolde K3.1 Pro uit, gebouwd op K3 met verdere post-training, in Kimi Code op 23 oktober 2026, en de API quickstart vermeldt dat de volledige gewichten uiterlijk 4 november worden vrijgegeven. Voorzie elk cijfer dat u noteert van een datum. Prijzen en lijsten met ondersteunde architecturen veranderden beide in de twee weken nadat K3 werd gelanceerd. De lanceringscijfers op deze pagina zijn gepubliceerd in juli 2026, en de serving-recepten, runtime-releases en kwantisatiegetallen zijn opnieuw gecontroleerd op 27 oktober 2026.
FAQ
Kan ik Kimi K3 op een enkele GPU draaien?
Nee. De gewichten zijn ongeveer 1.4 TB bij de MXFP4-precisie die Moonshot levert. Zelfs de kleinste gepubliceerde kwantisatie van K3, het 466 GB UD-Q1_0-bestand van Unsloth, is ongeveer 1,6 keer de 288 GB van de grootste breed beschikbare accelerators. llama.cpp kan experts in het systeem-RAM houden en de actieve experts in de GPU cachen, maar dat vereist nog steeds ongeveer de grootte van de kwantisatie in RAM plus VRAM. Daaronder valt het model terug op de schijf en draait het aanzienlijk trager. De kleinste gepubliceerde serving-recepten gebruiken één node met 8 GPU's van het type B300 of MI350X/MI355X, en het H100-recept gebruikt er 32.
Hoeveel VRAM heeft Kimi K3 nodig?
Begin bij 1.4 TB alleen al voor de gewichten, wat neerkomt op 18 H100 80GB-kaarten of 5 kaarten van de B300-klasse. Voeg daar vervolgens KV-cache en activatiegeheugen aan toe. De lanceringsrichtlijnen van Moonshot adviseerden 64 of meer accelerators. Sinds 27 oktober 2026 publiceert het SGLang-kookboek single-node recepten op 8 B300- of 8 MI350X/MI355X-kaarten, met 2.304 GB totaal, en een H100-configuratie met 32 GPU's met 2.560 GB totaal. Beschouw het cijfer voor de gewichten daarom als een ondergrens en niet als een vereiste.
Past Kimi K3 door kwantisatie op één node?
Het geleverde 4-bit checkpoint past al op één node als die node uit acht kaarten van 288 GB bestaat, wat de B300- en MI355X-recepten van SGLang gebruiken, en op één machine met ongeveer 1,6 TB RAM plus VRAM via de verliesvrije Q8 GGUF van Unsloth. Lager gaan helpt kleinere machines: de gemeten dynamische GGUF-builds van Unsloth variëren van 861,3 GB bij 2-bit tot 594 GB bij 1-bit, en de repository bevat 1-bit bestanden tot 466 GB, tegenover ongeveer 1,56 TB verliesvrij. De nauwkeurigheidskosten zijn gemeten: de top-1 overeenkomst met het volledige model daalt naar 90,390 procent bij UD-Q2_K_XL en 78,875 procent bij UD-IQ1_S. Geen van deze past op een enkele kaart.
Is het huren van GPU's goedkoper dan de Kimi K3 API?
Alleen bij een hoog en constant volume. Bij een aangenomen prijs van 2,50 USD per GPU-uur kost een continu draaiende node met 8 GPU's 14,400 USD per maand. Voor hetzelfde bedrag koopt u ongeveer 960 miljoen output-tokens tegen het gepubliceerde tarief van 15.00 USD per miljoen. U betaalt ook voor inactieve uren, het downloaden van gewichten en de persoon die het cluster operationeel houdt. Huur per uur voor pieken en vergelijk dit met uw eigen gemeten tokenvolume in plaats van met een schatting.
Wat betekent 104B actieve parameters voor de snelheid?
Het betekent dat het rekenwerk per token gelijk is aan dat van een 104B-model, waardoor de doorvoer in die klasse valt in plaats van in de 2,8T-klasse. Dit zegt niets over het geheugen: alle 2,8T parameters blijven resident, omdat de router voor elk token elke expert kan aanroepen. Gebruik het actieve aantal om tokens per seconde te voorspellen, en het totale aantal om de VRAM-grootte te bepalen.