Jinsi ya ku-self-host Kimi K3: Mwongozo wa kiufundi
Kimi K3 ina parameta trilioni 2.8 zinazohitaji miundombinu mikubwa. Jifunze hesabu za VRAM na KV cache ili kuendesha modeli hii bila kutumia nguzo ya GPU 32 kwa njia sahihi.
Mahitaji ya ku-self-host Kimi K3
Ku-self-host Kimi K3 kunamaanisha kutafuta nafasi kwa ajili ya parameters trilioni 2.8. Moonshot ilichapisha uzito (weights) wazi katika muundo wa MXFP4, ambao ni takriban nusu byte kwa kila parameter, kwa hivyo uzito pekee unafikia takriban 1.4 TB kabla ya kutenga hata token moja ya cache. Hakuna accelerator inayouzwa leo inayoweza kuhifadhi kiasi hicho peke yake. Kwa GPU moja, jibu ni hapana. Kwa seva moja, jibu ni ndiyo katika maumbo mawili. La kwanza ni node ya GPU 8 zenye accelerators za 288 GB, ambayo ndiyo inayotumiwa na maelekezo madogo zaidi yaliyochapishwa ya kutoa huduma kwa watumiaji wengi. La pili ni mashine moja yenye takriban 1.6 TB ya RAM na VRAM kwa pamoja inayotumia Unsloth's lossless Q8 GGUF katika llama.cpp, ikiwa na au bila GPU, ikihudumia mtumiaji mmoja kwa wakati mmoja.
Hiyo ndiyo hukumu. Kila kitu hapa chini ni hesabu iliyo nyuma ya uamuzi huo, kwa sababu hesabu ndiyo sehemu unayotumia tena kwenye toleo lijalo. Wauzaji kadhaa wa miundombinu walichapisha miongozo ya deployment ya K3 katika wiki zilizofuata tangazo la tarehe 16 Julai 2026, na kila mmoja alidhani tayari unamiliki cluster. Ukurasa huu unaanza upande wa pili: gharama zake, nini unaweza kuendesha badala yake, na jinsi ya kujua ni kipi kati ya hayo mawili unachoweza kufanya.
Jumla ya vigezo na vigezo amilifu si idadi sawa
K3 ni modeli ya aina ya mixture of experts (MoE). MoE hugawanya mtandao katika sub-networks nyingi na kuruhusu router kuchagua chache kati ya hizo kwa kila token. Kadi ya modeli inaorodhesha jumla ya vigezo 2.8T na 104B vinavyotumika (activated) kwa kila token, kutoka kwa experts 896 walioelekezwa ambapo 16 hufanya kazi kwa token yoyote ile, katika layers 93.
Idadi hizo mbili za vigezo hujibu maswali tofauti, na kuzichanganya ndilo kosa la kawaida zaidi katika kila mjadala wa "je, ninaweza kuendesha hii".
Vigezo amilifu huamua gharama ya kompyuta (compute cost). Token huzidishwa kupitia takriban vigezo 104B, kwa hivyo throughput unayopaswa kutarajia inafanana na ile ya modeli ya 104B dense badala ya 2.8T. Hiyo ndiyo sababu nzima ya kujenga MoE.
Jumla ya vigezo huamua gharama ya kumbukumbu (memory cost). Router inaweza kuchagua expert yeyote kwa token yoyote, kwa hivyo kila expert lazima ahifadhiwe mahali pa haraka kabla ya ombi la kwanza kufika. Kuhifadhi experts amilifu pekee kwenye VRAM na kuchota wengine inapohitajika ni jambo linalowezekana: --moe-cache-mib ya llama.cpp huweka GPU cache ya experts ambao vinginevyo hukaa kwenye RAM ya mfumo na kupakia wale wanaokosekana kadiri router inavyowachagua. Hata hivyo, hii haipunguzi jumla ya vigezo. Experts waliosalia bado lazima wakae kwenye RAM, na link ya PCIe husafirisha makumi ya gigabytes kwa sekunde dhidi ya terabytes kwa sekunde za HBM, kwa hivyo kila cache miss hugharimu muda. Kutiririsha (streaming) experts kutoka NVMe kwa sababu modeli haitoshi kwenye RAM ni polepole zaidi, na mwongozo wa K3 wa Unsloth unaonya kuwa disk offloading huenda polepole sana.
Kwa hivyo, ni rahisi kukokotoa lakini ni ghali kuhifadhi. Pima ukubwa wa maunzi (hardware) kulingana na 2.8T. Pima matarajio yako ya kasi kulingana na 104B.
Baiti kwa kila uzito, na asili ya terabytes
Idadi ya vigezo ikizidishwa na baiti kwa kila uzito. Kwa uzito, hiyo ndiyo fomula nzima.
Data iliyo nyuma ya chati hii
[
{
"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 ilifunzwa kwa kuzingatia quantisation na kutolewa ikiwa na uzito wa MXFP4 na activation za MXFP8, kwa hivyo safu ya 4-bit ndiyo halisi. Safu zilizo juu yake zipo kwa ajili ya kulinganisha: katika bf16, modeli hiyo hiyo ingehitaji 5.6 TB. MXFP4 pia huhifadhi scale moja ya 8-bit inayoshirikiwa kwa kila kizuizi cha uzito 32, jambo linaloongeza takriban asilimia 6, na usanidi wa Moonshot huacha attention, wataalamu wanaoshiriki (shared experts) na vision tower nje ya muundo wa 4-bit, kwa hivyo checkpoint nzima inafikia takriban 1.56 TB kwa hesabu ya Unsloth badala ya 1.4 TB kamili.
Hii hupunguza njia ya kawaida ya kuepuka bila kuifunga kabisa. Checkpoint iliyotolewa tayari ni 4-bit, kwa hivyo akiba rahisi imeshachukuliwa, lakini kushuka zaidi bado kunabadilisha namba hiyo. Kufikia 27 Oktoba 2026, quantisation za GGUF za K3 zinazobadilika ambazo Unsloth imepima huanzia 861.3 GB kwa UD-Q2_K_XL ya 2-bit hadi 594 GB kwa UD-IQ1_S ya 1-bit, na Unsloth huchapisha gharama yake: makubaliano ya token ya juu-1 na modeli kamili ni asilimia 90.390 katika UD-Q2_K_XL, asilimia 84.127 katika UD-IQ2_XXS ya 711.1 GB na asilimia 78.875 katika UD-IQ1_S. Repo yake ya Hugging Face pia hubeba faili ndogo zaidi za 1-bit, hadi 466 GB kwa UD-Q1_0, bila takwimu ya makubaliano kuchapishwa pamoja nazo. Hilo ni upotevu wa usahihi uliopimwa, na hata faili ndogo zaidi bado ni takriban mara 1.6 ya kadi moja kubwa zaidi.
Kimi K3 inahitaji GPU ngapi
Data iliyo nyuma ya chati hii
[
{
"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
}
]Soma namba hizo kama kiwango cha chini, si kama lengo. Namba hizo huhesabu uzito (weights) pekee: hazijumuishi KV cache, buffers za activation, fragmentation ya allocator, wala nafasi kwa ajili ya ombi la pili la wakati mmoja. Mgawanyo wenyewe hauhitaji kuwa sawa: pipeline parallelism ya vLLM hugawa model kulingana na layers na inaruhusu migawanyo isiyo sawa, na maelekezo ya prefill ya K3 katika SGLang huendesha hatua 8 na 16 za pipeline kwenye layers 93.
Mwongozo uliotolewa uko juu ya kiwango hicho cha chini. Mwongozo wa uzinduzi wa Moonshot ulipendekeza supernode ya accelerators 64 au zaidi. Kufikia tarehe 27 Oktoba 2026, cookbook ya SGLang inatoa configuration ya H100 iliyojengwa kutoka nodes nne za 8-GPU, jumla ya GPU 32 na 2,560 GB ya kumbukumbu, dhidi ya kiwango cha chini cha 18 cards, na pia inaorodhesha maelekezo ya node moja kwenye node moja ya 8-GPU B300 na node moja ya 8-GPU MI350X au MI355X, 2,304 GB kwa 288 GB kila kadi. Pengo hilo lililo juu ya kiwango cha chini si upotevu. Ni kwa ajili ya KV cache, kumbukumbu ya activation, na nafasi ya ziada inayoruhusu seva kuchakata maombi mengi kwa wakati mmoja. Safu inayofaa zaidi, kadi za daraja la 5 GB300, kwa vitendo huzungushiwa juu hadi kufikia node hiyo ya 8-GPU, ambayo ndiyo mashine ndogo zaidi ambayo mtu yeyote amechapisha maelekezo ya kutoa huduma ya K3 kwa watumiaji wengi.
KV cache ndiyo sehemu inayowashangaza watu
Uzito (weights) ni gharama isiyobadilika. KV (key value) cache sivyo: hukua kulingana na urefu wa muktadha (context length) na pia kwa kila mtumiaji anayefanya kazi kwa wakati mmoja. Kwa attention ya kawaida, fomula ni bytes per token = 2 * layers * kv_heads * head_dim * bytes_per_element, kisha unazidisha kwa urefu wa muktadha na kwa idadi ya watumiaji.
Huu hapa ni mfano wa hesabu, na ni mfano tu: tabaka 64, KV heads 8, ukubwa wa head 128, fp8. Hii inatoa 2 64 8 128 1 = 131,072 bytes, hivyo 128 KiB kwa kila token.
Data iliyo nyuma ya chati hii
[
{
"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
}
]Mtumiaji mmoja mwenye muktadha wa 128k anagharimu 16 GiB. Mtumiaji mmoja mwenye muktadha kamili wa milioni moja anagharimu 128 GiB, ambayo ni karibu nusu ya kadi ya 288 GB kwa mazungumzo moja, kabla hata uzito wowote kupakiwa.
K3 haitumii attention ya kawaida, na namba hiyo ya mwisho ndiyo sababu. Tabaka zake 93 ni tabaka 69 za KDA (Kimi Delta Attention) na tabaka 24 za Gated MLA (multi-head latent attention). KDA huhifadhi hali ya mara kwa mara (recurrent state) yenye ukubwa usiobadilika badala ya cache inayokua kwa kila token, na MLA hubana key na value kuwa vector moja ya low rank, kwa hivyo gharama halisi kwa kila token hushuka sana chini ya mfano uliotolewa. Faili ya config.json iliyochapishwa na Moonshot inatoa ukubwa wa latent hiyo: kv_lora_rank ya 512 pamoja na rotary key yenye upana wa 64 (qk_rope_head_dim), hivyo 576 values kwa kila token kwa kila tabaka la MLA. Katika tabaka 24 zenye 2 bytes kila moja, hiyo ni 27,648 bytes, takriban 27 KiB kwa kila token, au karibu 27 GiB kwa mazungumzo kamili ya token 1,048,576, pamoja na hali ya KDA isiyobadilika. Ichukulie hiyo kama makadirio badala ya kipimo kamili: injini hupanga na kuweka cache katika njia zao wenyewe, na cache ya 8-bit huipunguza kwa takriban nusu.
Ili kuona kile ambacho deployment yako inashikilia, usifuatilie nvidia-smi wakati unapandisha --max-model-len. vLLM hutenga mapema (preallocate) pool yake ya KV cache, iliyopimwa kutoka --gpu-memory-utilization (0.92 kwa chaguo-msingi katika nyaraka za sasa) au kutoka kwa bajeti maalum ya cache kwa kila GPU, kwa hivyo kumbukumbu ya jumla ya GPU huonyesha pool hiyo badala ya mazungumzo moja. Badala yake, soma log ya kuanza (startup log), ambapo vLLM huripoti ukubwa wa KV cache katika token na uwezo wa juu wa watumiaji kwa urefu wa muktadha wako.
Muundo wa hoja (reasoning) utaendelea kuwepo katika toleo lijalo. Ikiwa mfano (model) unatangaza muktadha wa token milioni moja na hausemi chochote kuhusu muundo wake wa attention, chukulia kuwa cache ndiyo kizuizi kikuu hadi mtu mwingine atakapothibitisha vinginevyo.
Tier 1: kukodisha cluster kwa saa
Hii ndiyo tier inayohudumia K3 katika usahihi wake wa awali (shipped precision) kwa watumiaji wengi kwa wakati mmoja. Mashine moja yenye RAM ya kutosha inaweza pia kuhifadhi K3 katika usahihi wake wa awali kupitia Q8 GGUF ya Unsloth, ambayo Unsloth huiita "full precision lossless", lakini njia hiyo humhudumia mtumiaji mmoja kwa wakati mmoja na imeelezwa katika tier 2. Hapa hununui maunzi (hardware). Unaikodisha kwa saa unazohitaji na unaizima baadaye.
Data iliyo nyuma ya chati hii
[
{
"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"
}
]Kiwango cha bei ni makadirio tu, si nukuu rasmi. Viwango vya on-demand hutofautiana sana kulingana na mtoa huduma na kizazi cha GPU; sehemu za 288 GB zinazohitajika na maelekezo ya single-node hugharimu zaidi kwa saa kuliko H100, na uwezo uliotengwa (reserved capacity) ni nafuu zaidi. Chukua namba halisi ya mtoa huduma wako na ufanye hesabu upya: idadi ya GPU mara saa mara kiwango cha bei. Lengo la chati hii ni kuonyesha uwiano. Kuendesha node ya GPU 8 kwa saa nne kwa siku hugharimu 2,400 USD kwa mwezi, wakati kuacha usanidi wa H100 wa GPU 32 ukiwa umewashwa kwa ajili ya SGLang hugharimu 57,600 USD.
Seva zote mbili kuu huchapisha amri ya uzinduzi kwenye kadi ya modeli.
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 30000Hakuna amri yoyote kati ya hizo unayopaswa kuendesha kwenye cluster halisi. Ongeza flag za parallelism zinazolingana na maunzi yako: SGLang hutumia --tp-size kwa tensor parallel, --pp-size kwa pipeline parallel, na --ep-size kwa expert parallel. Tensor parallel mara pipeline parallel lazima ilingane na idadi ya GPU ulizonazo, na expert parallel hugawa wataalamu (experts) ndani ya kundi hilo, ndiyo maana maelekezo ya H100 ya GPU 32 huweka --tp-size 32 na --ep-size 32 zote mbili.
Thibitisha kuwa seva imewaka kabla ya kutuma trafiki halisi:
curl http://127.0.0.1:30000/v1/modelsSeva iliyo salama hujibu kwa JSON object inayoorodhesha kitambulisho cha modeli (model id). Connection refused inamaanisha mchakato bado unapakia uzito (weights) au tayari umesimama, kwa hivyo soma log ya seva kabla ya kujaribu tena.
Hitilafu ya kawaida katika wiki za kwanza ilikuwa runtime iliyopitwa na wakati kulinganisha na modeli. K3 ilitolewa ikiwa na KDA na safu mpya ya MoE ambayo matoleo thabiti (stable releases) ya vLLM na SGLang hayakuwa nayo wakati wa uzinduzi, na dalili yake ni seva kusimama wakati wa kuanza ikiwa na mstari wa aina ya Model architectures [...] are not supported for now. Hakuna mabadiliko ya usanidi (config) yanayoweza kurekebisha hilo, kwa sababu msimbo wa kuendesha safu hizo haupo kwenye build yako. Hilo limebadilika tangu wakati huo: kuanzia tarehe 27 Oktoba 2026, SGLang imekuwa na usaidizi wa K3 katika matoleo yake tangu v0.5.17, huku v0.5.22 ikiwa ya hivi karibuni, na maelezo ya toleo (release notes) ya vLLM kuanzia v0.28.0 hadi v0.32.0 yote yanajumuisha kazi za K3. Sakinisha toleo la sasa. Baadhi ya njia mahususi za maunzi bado hutaja image maalum, kwa mfano build za NVFP4 za SGLang kwenye Blackwell, kwa hivyo angalia maelekezo ya kadi yako.
Ujumbe mmoja kuhusu gharama ambao huwashangaza watu. Mita huanza kuhesabu wakati instance inapoanza, si wakati modeli inapokuwa tayari. Upakuaji wa 1.56 TB kwa kasi ya 1 GB/s ni takriban dakika 26 za muda wa cluster kabla ya token ya kwanza. Hifadhi uzito (weights) kwenye volume inayodumu zaidi ya instance, ili uendeshaji wa pili uanze ndani ya dakika chache.
Tier 2: endesha model ndogo kwenye accelerator moja
Hauendeshi K3 katika tier hii. Tamka hili kwa sauti kabla ya kuanza, kwa sababu mijadala mingi ya "run K3 locally" huishia hapa bila kukiri ukweli huo.
Kanuni ya kutosheleza (fit rule) ni fomula ileile kwa kiwango kidogo: idadi ya parameters mara bytes kwa kila weight, pamoja na KV cache, na takriban 2 GB ya runtime overhead, lazima viwe ndani ya VRAM yako. Katika 4-bit, hii ni takriban nusu byte kwa kila parameter, jambo linalotoa mchanganyiko unaofaa:
- Kadi ya 16 GB: model ya 7B katika 4-bit ikiwa na nafasi ya context ndefu
- Kadi ya 24 GB: model ya 14B katika 4-bit
- Kadi ya 48 GB: model ya 32B katika 4-bit
- Kadi ya 80 GB: model ya 70B katika 4-bit, au 30B class MoE katika 8-bit
Kila mchanganyiko hapo juu unachukulia ombi moja kwa wakati mmoja, na pindi mtu wa pili anapotuma prompt, kila slot inayofanya kazi kwa wakati mmoja inahitaji KV cache yake yenyewe. Hii ndiyo biashara ambayo mipangilio ya Ollama ya NUM_PARALLEL na MAX_QUEUE inakufanyia kati ya slots zinazofanya kazi sambamba, maombi yaliyopangwa kwenye foleni, na VRAM uliyobaki nayo.
Kuna njia moja ya kuendesha K3 yenyewe kwenye mashine moja kubwa, na inakaa kati ya tier hii na ile ya mwisho. Unsloth inaandika kuhusu builds za GGUF za K3 katika llama.cpp, kuanzia quantisations za 1-bit na 2-bit hadi UD-Q8_K_XL, ambayo inaiita full precision lossless, na kutaja NVIDIA DGX Station kama maunzi yanayoweza kuiendesha. Kanuni yake ya jumla ni kwamba RAM pamoja na VRAM lazima ziwe sawa na ukubwa wa quant, kuanzia takriban 610 GB kwa build ya 1-bit UD-IQ1_S hadi takriban 1.6 TB kwa Q8; chini ya hapo, model inahamia kwenye disk na kasi hupungua sana. GPU ni ya hiari: maelekezo ya build ya Unsloth huzima CUDA "kama huna GPU au unataka tu CPU inference". Builds za 1-bit na 2-bit ni K3 iliyopunguzwa ubora (heavily quantised), kwa gharama ya usahihi iliyopimwa hapo juu. Build ya Q8 ni K3 katika usahihi wake wa awali, inayohudumia mtumiaji mmoja kwa kasi ya RAM. Hakuna kati ya hizi iliyo model ndogo.
Ollama ndiyo njia ya haraka zaidi ya kupata seva inayofanya kazi kwenye VPS yenye GPU iliyounganishwa:
curl -fsSL https://ollama.com/install.sh | sh
ollama run qwen3:14bollama run hupakua model wakati wa matumizi ya kwanza, kisha inakuweka kwenye prompt. Tag isiyokuwepo inarudisha Error: model "..." not found, kwa hivyo nakili tags kutoka kwenye ukurasa wa library badala ya kuziandika kwa kukumbuka. Mwongozo kamili, ikijumuisha systemd unit na ufikiaji wa mbali, uko katika kuendesha Ollama kwenye VPS.
llama.cpp inakupa udhibiti zaidi juu ya quantisation na offload:
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 huomba kila layer iwekwe kwenye GPU. Soma log ya mzigo (load log): inaonyesha ni layers ngapi zilihamishiwa kwenye GPU. Layers zinazozidi uwezo na kuingia kwenye system RAM hufanya kazi kwa bandwidth ya RAM badala ya bandwidth ya HBM, kwa hivyo kasi ya uzalishaji (generation speed) hupungua kwa kiasi kikubwa pindi tu model inapoacha kutoshea. Biashara kati ya zana hizi mbili imeelezewa katika Ollama na llama.cpp kulinganishwa.
Tier 3: API inayohudumiwa, orchestration inayojiendesha (self-hosted)
Data iliyo nyuma ya chati hii
[
{
"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"
}
]Endpoint hii inaoana na OpenAI, kwa hivyo client iliyopo inafanya kazi baada ya kubadilisha base URL.
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."}]}'Key inayofanya kazi inarudisha JSON object yenye array ya choices. 401 inamaanisha uthibitishaji (authentication) umefeli: hakikisha key ni sahihi na haijaisha muda wake au kulemazwa, na kwamba header inasomeka Authorization: Bearer ikifuatiwa na key hiyo. Error ya model-not-found kwa kawaida inamaanisha id imebadilika, kwa sababu watoa huduma hustaafisha ids kati ya checkpoints.
Sasa kuhusu gharama, tukitumia kiwango cha ukodishaji kilichotajwa hapo juu. Node ya 8 GPU inayowaka muda wote inagharimu 14,400 USD kwa mwezi, na kwa 15.00 USD kwa kila milioni ya output tokens, kiasi hicho hicho cha pesa hununua takriban milioni 960 za output tokens kutoka kwenye API. Ili kupata faida ya gharama lazima utoe karibu bilioni moja ya output tokens kwa mwezi, takriban milioni 30 kwa siku, na uweke cluster ikifanya kazi muda wote, kwa sababu GPUs zisizofanya kazi hutoza gharama sawa na zile zinazofanya kazi. Mizigo ya kazi ya agent inayohitaji prompt nyingi husogeza mstari huo mbali zaidi: context inayojirudia hutoza kwa kiwango cha cache-hit cha 0.30 USD kwa milioni badala ya kiwango cha cache-miss cha 3.00 USD.
Unachojiendeshea (self-host) katika tier hii ni kila kitu kinachozunguka model: gateway inayohifadhi API key ili isiwahi kufika kwa client, logs za maombi na majibu, majaribio ya kurudia (retries), mipaka ya kasi (rate limits), na bajeti kwa kila mtumiaji. Hiyo huendeshwa kwenye VPS ndogo isiyo na GPU yoyote. Mgawanyo huo huo unatumika kwa closed weights, ambapo self-hosting Claude haiwezekani katika ngazi ya model na orchestration ndiyo sehemu pekee unayomiliki.
Ni stack ipi ya kuhudumia inayomilikiwa na tier ipi
Seva za daraja la vLLM na SGLang ni za tier 1. Zipo ili kuhudumia maombi mengi kwa wakati mmoja, zikitumia continuous batching na paged KV cache, pamoja na tensor na expert parallelism iliyosambazwa kwenye nodes kadhaa. Zinahitaji accelerators za datacentre na muunganisho wa kasi wa juu kati yao. Kwenye kadi moja ya kawaida (consumer card), ni nzito kusakinisha na hazikupi faida kubwa unayoweza kuiona.
llama.cpp na Ollama ni za tier 2. Zinalenga mashine moja, GGUF quantisation, CPU offload wakati model haitoshi, na concurrency ya chini. llama.cpp itapakia MoE kubwa kwa kuhifadhi expert weights kwenye system RAM (--cpu-moe au --n-cpu-moe) na, kwa kutumia --moe-cache-mib, kuhifadhi experts inayotumia kwenye GPU, na ndivyo builds za Unsloth K3 GGUF zinavyoendeshwa kwenye mashine moja. Kasi hutegemea bandwidth ya RAM na mara ngapi router inakosa cache, na kama faili ni kubwa kuliko RAM pamoja na VRAM, mfumo hutumia disk. Hii ni setup inayofaa kwa mtumiaji mmoja. Sio huduma unayoweza kuweka watumiaji wengi. Ulinganisho kamili uko kwenye Ollama dhidi ya vLLM, na haubadiliki kulingana na model: swali ni kama unahudumia watumiaji wengi kwenye maunzi (hardware) ya pamoja au mtumiaji mmoja kwenye mashine yako mwenyewe.
Nambari nne zinazodumu zaidi ya kituo hiki cha ukaguzi
- Jumla ya vigezo (parameters) ikizidishwa na baiti kwa kila uzito (weight) inatoa kiwango cha chini cha kumbukumbu. Hakuna kinachofanya kazi chini ya kiwango hicho kwa usahihi wa toleo asilia, na kuweka quantisation chini ya 4-bit release kunakupa hadi asilimia 70 ya akiba ya kumbukumbu kwa gharama ya usahihi, si kwa kiwango cha ukubwa wa mara kumi (order of magnitude).
- Vigezo amilifu (active parameters) vinatoa daraja la throughput. MoE ya 2.8T yenye 104B amilifu hufanya hesabu kama modeli ya 104B.
- KV cache kwa kila token, ikizidishwa na urefu wa muktadha (context length), ikizidishwa na concurrency, ndiyo gharama inayoendelea kukua baada ya kulipia uzito wa modeli.
- Tokens kwa sekunde kwa kila dola ndiyo nambari pekee inayochagua daraja. Kila kitu hapo juu ni ingizo la nambari hiyo.
Tumia nambari hizo nne kwa toleo lolote na utapata jibu sahihi kabla ya kufungua mwongozo wa mtoa huduma. Toleo linalofuata tayari limetangazwa: Moonshot ilizindua K3.1 Pro, iliyojengwa juu ya K3 ikiwa na post-training zaidi, ndani ya Kimi Code mnamo 23 Oktoba 2026, na mwongozo wake wa kuanza haraka (API quickstart) unasema uzito kamili (full weights) utatolewa ifikapo 4 Novemba. Kisha weka tarehe kila takwimu unayoandika. Bei na orodha za usanifu unaotumika (supported-architecture lists) zote zilibadilika ndani ya wiki mbili baada ya K3 kuzinduliwa. Takwimu za uzinduzi kwenye ukurasa huu zilichapishwa mnamo Julai 2026, na mapishi ya kuhudumia (serving recipes), matoleo ya runtime na nambari za quantisation zilikaguliwa upya mnamo 27 Oktoba 2026.
FAQ
Je, ninaweza kuendesha Kimi K3 kwenye GPU moja?
Hapana. Uzito wa modeli hii ni takriban 1.4 TB kwa usahihi wa MXFP4 ambao Moonshot inasambaza, na hata quantisation ndogo zaidi iliyochapishwa ya K3, faili ya Unsloth ya 466 GB UD-Q1_0, ni takriban mara 1.6 ya 288 GB inayopatikana kwenye accelerators kubwa zaidi zinazotumika sana. llama.cpp inaweza kuhifadhi wataalamu (experts) kwenye RAM ya mfumo na kuweka wale wanaotumika kwenye GPU, lakini bado inahitaji takriban ukubwa wa quant kwenye RAM pamoja na VRAM, na chini ya hapo modeli hupungua kasi sana kwa sababu ya kutumia diski. Mapishi madogo zaidi ya usambazaji (serving recipes) yanayochapishwa hutumia node moja ya GPU 8 za B300 au MI350X/MI355X, na mapishi ya H100 hutumia 32.
Kimi K3 inahitaji VRAM kiasi gani?
Anza na 1.4 TB kwa ajili ya uzito pekee, ambayo ni 18 kadi za H100 80GB au 5 kadi za daraja la GB300. Kisha ongeza kumbukumbu ya KV cache na activation juu yake. Mwongozo wa uzinduzi wa Moonshot ulipendekeza accelerators 64 au zaidi. Kufikia tarehe 27 Oktoba 2026, kitabu cha mapishi cha SGLang kinachapisha mapishi ya node moja kwenye kadi 8 za B300 au 8 za MI350X/MI355X, jumla ya 2,304 GB, na usanidi wa GPU 32 za H100 wenye jumla ya 2,560 GB, kwa hivyo chukulia takwimu ya uzito kama kiwango cha chini badala ya hitaji kamili.
Je, quantisation inafanya Kimi K3 kutoshea kwenye node moja?
Checkpoint ya 4-bit inayotolewa tayari inatoshea kwenye node moja ikiwa node hiyo ina kadi nane za 288 GB, ambayo ndiyo inayotumiwa na mapishi ya SGLang ya B300 na MI355X, na kwenye mashine moja yenye takriban 1.6 TB ya RAM pamoja na VRAM kupitia Q8 GGUF isiyo na hasara ya Unsloth. Kushuka chini zaidi husaidia mashine ndogo: ujenzi wa dynamic GGUF uliopimwa na Unsloth huanzia 861.3 GB kwa 2-bit hadi 594 GB kwa 1-bit, na repo yake inaorodhesha faili za 1-bit hadi 466 GB, ikilinganishwa na takriban 1.56 TB bila hasara. Gharama ya usahihi imepimwa: makubaliano ya top-1 na modeli kamili hushuka hadi asilimia 90.390 kwenye UD-Q2_K_XL na asilimia 78.875 kwenye UD-IQ1_S. Hakuna hata moja inayotoshea kwenye kadi moja.
Je, kukodisha GPU ni nafuu kuliko API ya Kimi K3?
Ni nafuu tu kwa ujazo mkubwa na thabiti. Kwa makadirio ya 2.50 USD kwa saa ya GPU, node ya GPU 8 inayowaka kila wakati inagharimu 14,400 USD kwa mwezi, na kiasi hicho cha pesa hununua takriban token milioni 960 za pato kwa kiwango kilichochapishwa cha 15.00 USD kwa kila milioni. Pia unalipia saa za kutofanya kazi, upakuaji wa uzito, na mtu anayehakikisha cluster inabaki hai. Kodisha kwa saa kwa ajili ya matumizi ya ghafla, na ulinganishe na ujazo wako wa token uliopimwa badala ya kukisia.
104B active parameters inamaanisha nini kwa kasi?
Inamaanisha kuwa hesabu kwa kila token ni ile ya modeli ya 104B, kwa hivyo throughput inakuwa katika daraja hilo badala ya daraja la 2.8T. Haisemi chochote kuhusu kumbukumbu: vigezo vyote 2.8T vinabaki kwenye kumbukumbu, kwa sababu router inaweza kuita mtaalamu yeyote kwa token yoyote. Tumia idadi ya active parameters kutabiri token kwa sekunde, na idadi ya jumla kupima ukubwa wa VRAM.