SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-10-28

Mga kailangan para i-self-host ang Kimi K3

Kimi K3 ay may 2.8 trilyong parameter. Alamin ang VRAM at KV cache math, at ang tatlong totoong paraan para patakbuhin ito nang walang 32-GPU cluster.

Mga kinakailangan para sa self-hosting ng Kimi K3

Ang self-hosting ng Kimi K3 ay nangangailangan ng espasyo para sa 2.8 trillion parameters. Inilabas ng Moonshot ang mga open weight sa format na MXFP4, na humigit-kumulang kalahating byte bawat weight, kaya ang mga weight pa lamang ay aabot na sa 1.4 TB bago ka pa maglaan ng kahit isang token para sa cache. Walang accelerator na ibinebenta ngayon ang kayang maglaman nito nang mag-isa. Para sa isang GPU, ang sagot ay hindi. Para sa isang server, ang sagot ay oo sa dalawang paraan. Ang una ay isang 8-GPU node na may 288 GB accelerators, na siyang ginagamit ng pinakamaliit na inilathalang multi-user serving recipe. Ang pangalawa ay isang makina na may humigit-kumulang 1.6 TB ng pinagsamang RAM at VRAM na nagpapatakbo ng lossless Q8 GGUF ng Unsloth sa loob ng llama.cpp, may GPU man o wala, na nagsisilbi sa isang user sa bawat pagkakataon.

Iyan ang hatol. Ang lahat ng nasa ibaba ay ang aritmetika sa likod nito, dahil ang aritmetika ang bahaging magagamit mo muli sa susunod na release. Maraming infrastructure vendor ang naglathala ng mga deployment guide para sa K3 sa mga linggong sumunod sa anunsyo noong 16 July 2026, at bawat isa ay nag-assume na mayroon ka nang cluster. Ang pahinang ito ay nagsisimula sa kabilang dulo: kung magkano ang gastos, ano ang maaari mong patakbuhin sa halip nito, at kung paano malalaman kung alin sa dalawang opsyon ang kinabibilangan mo.

Hindi magkapareho ang kabuuang parameters at mga aktibong parameter

Ang K3 ay isang mixture of experts model. Hinahati ng MoE (mixture of experts) ang network sa maraming sub-network, at pinapapili sa isang router ng ilan sa mga ito para sa bawat token. Nakalista sa model card ang 2.8T na kabuuang parameters at 104B na ina-activate para sa bawat token. Binubuo ito ng 896 routed experts, kung saan 16 ang gumagana para sa anumang token, sa kabuuang 93 layers.

Magkaiba ang sinasagot na tanong ng dalawang bilang na ito. Ang pagpapalit sa mga ito ang pinakakaraniwang pagkakamali sa bawat thread na may tanong na “can I run this”.

Ang active parameters ang nagtatakda ng compute cost. Dumadaan ang isang token sa humigit-kumulang 104B parameters. Kaya ang throughput na dapat mong asahan ay mas kahawig ng 104B dense model kaysa sa 2.8T model. Ito ang pangunahing dahilan kung bakit gumagawa ng MoE.

Ang total parameters ang nagtatakda ng memory cost. Maaaring pumili ang router ng anumang expert para sa anumang token. Kaya kailangang naka-store ang lahat ng expert sa mabilis na storage bago dumating ang unang request. Posible namang VRAM lamang ang gamitin para sa mga hot expert at kunin ang iba kapag kinakailangan. Halimbawa, ang --moe-cache-mib ng llama.cpp ay nagtatago ng GPU cache ng mga expert na nasa system RAM, at ina-upload ang mga nawawala kapag pinili sila ng router. Hindi nito binabawasan ang kabuuang laki. Kailangan pa ring nasa RAM ang natitirang mga expert. Bukod dito, sampu-sampung gigabytes bawat segundo lamang ang kayang ilipat ng PCIe link, kumpara sa terabytes bawat segundo ng HBM. Kaya may oras na nawawala sa bawat cache miss. Mas mabagal pa ang pag-stream ng mga expert mula sa NVMe kapag hindi kasya ang model sa RAM. Nagbababala rin ang K3 guide ng Unsloth na mas mabagal nang malaki ang disk offloading.

Kaya mura itong i-compute ngunit magastos itong i-store. Ibase ang hardware sizing sa 2.8T. Ibase ang inaasahang bilis sa 104B.

Bytes bawat weight, at kung saan nanggagaling ang mga terabyte

Parameter count na pinarami ng bytes bawat weight. Para sa mga weight, iyan ang buong formula.

TsartWeight footprint of 2.8 trillion parameters, by precision
Ang datos sa likod ng tsart na ito
[
  {
    "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
  }
]

Ang K3 ay sinanay nang may kamalayan sa quantisation at inilabas na may MXFP4 weights at MXFP8 activations, kaya ang 4-bit row ang siyang totoo. Ang mga row sa itaas nito ay naroon para sa scale: sa bf16, ang parehong modelo ay mangangailangan ng 5.6 TB. Ang MXFP4 ay nag-iimbak din ng isang shared 8-bit scale para sa bawat block ng 32 weights, na nagdaragdag ng humigit-kumulang 6 na porsyento, at ang config ng Moonshot ay hindi isinasama ang attention, ang mga shared expert, at ang vision tower sa 4-bit format, kaya ang buong checkpoint ay umaabot sa humigit-kumulang 1.56 TB ayon sa bilang ng Unsloth sa halip na malinis na 1.4 TB.

Pinapakitid nito ang karaniwang escape hatch nang hindi ito tuluyang isinasara. Ang inilabas na checkpoint ay 4-bit na, kaya nakuha na ang madaling matitipid, ngunit ang pagbaba pa lalo ay nagpapabago sa numero. Base sa datos noong 27 October 2026, ang mga dynamic GGUF quantisation ng K3 na sinukat ng Unsloth ay tumatakbo mula 861.3 GB para sa 2-bit UD-Q2_K_XL hanggang 594 GB para sa 1-bit UD-IQ1_S, at inilathala ng Unsloth ang halaga nito: ang top-1 token agreement sa buong modelo ay 90.390 porsyento sa UD-Q2_K_XL, 84.127 porsyento sa 711.1 GB UD-IQ2_XXS, at 78.875 porsyento sa UD-IQ1_S. Ang Hugging Face repo nito ay mayroon ding mas maliliit na 1-bit file, hanggang 466 GB para sa UD-Q1_0, na walang kasamang inilathalang figure ng agreement. Iyan ay isang nasukat na pagbaba sa accuracy, at kahit ang pinakamaliit na file ay nasa 1.6 beses pa rin ng pinakamalaking single card.

Ilang GPU ang kailangan ng Kimi K3

TsartGPUs required to hold 1.4 TB of weights, before any KV cache
Ang datos sa likod ng tsart na ito
[
  {
    "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
  }
]

Ituring ang mga ito bilang minimum na requirement, hindi target. Ang bilang na ito ay para sa weights lamang: hindi kasama ang KV cache, activation buffers, allocator fragmentation, at walang espasyo para sa pangalawang sabay na request. Hindi kailangang maging pantay ang paghahati ng model: ang pipeline parallelism ng vLLM ay naghahati ng model base sa mga layer at sumusuporta sa hindi pantay na paghahati, at ang mga prefill recipe ng SGLang para sa K3 ay nagpapatakbo ng 8 at 16 pipeline stages sa loob ng 93 layers.

Ang inilathalang gabay ay mas mataas kaysa sa minimum. Ang launch guidance ng Moonshot ay nagrekomenda ng supernode na may 64 o higit pang accelerator. Noong 27 October 2026, ang SGLang cookbook ay may H100 configuration na binuo mula sa apat na 8-GPU node, 32 GPU, at 2,560 GB ng aggregate memory, kumpara sa minimum na 18 cards. Naglilista rin ito ng mga single-node recipe sa isang 8-GPU B300 node at isang 8-GPU MI350X o MI355X node, na may 2,304 GB sa 288 GB bawat card. Ang agwat na ito sa itaas ng minimum ay hindi nasasayang. Ito ay para sa KV cache, activation memory, at ang headroom na nagpapahintulot sa server na mag-batch ng maraming request nang sabay-sabay. Ang pinaka-angkop na row, 5 GB300 class cards, ay nag-a-round up sa praktikal na aplikasyon patungo sa eksaktong 8-GPU node na iyon, na siyang pinakamaliit na makina kung saan may inilathalang recipe ang sinuman para sa multi-user K3 serving.

Ang KV cache ang bahaging ikinagugulat ng maraming tao

Fixed cost ang weights. Hindi fixed ang KV (key value) cache: lumalaki ito kasabay ng context length at muli sa bawat sabay-sabay na user. Para sa ordinary attention, ang formula ay bytes per token = 2 * layers * kv_heads * head_dim * bytes_per_element, at pagkatapos ay i-multiply ito sa context length at concurrency.

Narito ang isang worked example, at halimbawa lamang ito: 64 layers, 8 KV heads, head dimension na 128, at fp8. Nagbibigay ito ng 2 64 8 128 1 = 131,072 bytes, o 128 KiB bawat token.

TsartKV cache per user in the worked example, at 128 KiB per token
Ang datos sa likod ng tsart na ito
[
  {
    "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
  }
]

Ang isang user na may 128k context ay kumokonsumo ng 16 GiB. Ang isang user sa buong isang milyon ay kumokonsumo ng 128 GiB. Halos kalahati ito ng isang 288 GB card para sa isang conversation pa lamang, bago pa ma-load ang kahit isang weight.

Hindi gumagamit ang K3 ng ordinary attention, at ito ang dahilan kung bakit. Ang 93 layer nito ay binubuo ng 69 KDA (Kimi Delta Attention) layer at 24 Gated MLA (multi-head latent attention) layer. Pinananatili ng KDA ang isang recurrent state na may fixed size sa halip na cache na lumalaki sa bawat token. Kino-compress naman ng MLA ang key at value sa isang low-rank latent vector, kaya mas mababa nang malaki ang aktuwal na per-token cost kaysa sa worked example. Ayon sa published config.json ng Moonshot, ang laki ng latent na ito ay isang kv_lora_rank na 512, kasama ang 64-wide rotary key (qk_rope_head_dim), kaya 576 values bawat token sa bawat MLA layer. Sa 24 layer na tig-2 bytes, katumbas ito ng 27,648 bytes, o humigit-kumulang 27 KiB bawat token. Para sa buong 1,048,576-token conversation, nasa 27 GiB ito, bukod pa sa fixed KDA state. Ituring ito bilang estimate, hindi measurement: nagpa-pad at nagla-layout ang mga engine ng cache sa sarili nilang paraan, at halos hinahati sa dalawa ng 8-bit cache ang laki nito.

Para makita kung ano ang hawak ng sarili mong deployment, huwag bantayan ang nvidia-smi habang itinataas ang --max-model-len. Pina-preallocate ng vLLM ang KV cache pool nito. Naka-size ito batay sa --gpu-memory-utilization (0.92 bilang default sa kasalukuyang docs) o sa isang tahasang per-GPU cache budget. Dahil dito, ipinapakita ng total GPU memory ang pool, hindi ang isang conversation. Sa halip, basahin ang startup log, kung saan iniuulat ng vLLM ang laki ng KV cache sa tokens at ang maximum concurrency para sa itinakda mong context length.

Mananatili ang ganitong paraan ng pagsusuri sa susunod na release. Kung nag-a-advertise ang isang model ng million-token context at walang sinasabi tungkol sa attention design nito, ipagpalagay na ang cache ang binding constraint hanggang may makapagpatunay ng iba.

Tier 1: pag-arkila ng cluster kada oras

Ito ang tier na nagpapatakbo ng K3 sa shipped precision nito para sa maraming user nang sabay-sabay. Ang isang machine na may sapat na RAM ay kayang magpatakbo ng K3 sa released precision nito gamit ang Q8 GGUF ng Unsloth, na tinatawag ng Unsloth na full precision lossless, ngunit ang paraang ito ay para sa isang user lang kada pagkakataon at tatalakayin sa tier 2. Dito, hindi mo binibili ang hardware. Ino-arkila mo lang ito para sa mga oras na kailangan mo at ititigil mo ito pagkatapos.

TsartMonthly cost at an assumed 2.50 USD per GPU hour, 30 day month
Ang datos sa likod ng tsart na ito
[
  {
    "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"
  }
]

Ang rate ay isang pagtatantya lamang, hindi isang pinal na presyo. Ang on-demand rates ay nag-iiba depende sa provider at sa henerasyon ng GPU; ang mga 288 GB parts na kailangan ng single-node recipes ay mas mahal kada oras kaysa sa H100, at mas mura ang reserved capacity. Kunin ang totoong presyo mula sa iyong provider at ulitin ang multiplication: GPUs beses hours beses rate. Ang layunin ng chart ay ipakita ang ratio. Ang pag-burst ng 8 GPU node sa loob ng apat na oras kada araw ay nagkakahalaga ng 2,400 USD kada buwan, habang ang pag-iwan sa SGLang na may 32 GPU H100 configuration ay nagkakahalaga ng 57,600 USD.

Ang parehong mainstream servers ay naglalathala ng launch command sa model card.

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 30000

Hindi ang mga bare command na ito ang pinapatakbo sa isang totoong cluster. Idagdag ang mga parallelism flag na tugma sa iyong hardware: ang SGLang ay gumagamit ng --tp-size para sa tensor parallel, --pp-size para sa pipeline parallel, at --ep-size para sa expert parallel. Ang tensor parallel beses pipeline parallel ay dapat katumbas ng bilang ng GPUs na mayroon ka, at ang expert parallel ang naghahati sa mga expert sa loob ng grupong iyon, kaya naman ang 32 GPU H100 recipe ay nagse-set ng parehong --tp-size 32 at --ep-size 32.

Siguraduhing tumatakbo na ang server bago ka magpadala ng totoong traffic:

curl http://127.0.0.1:30000/v1/models

Ang isang healthy na server ay sasagot ng isang JSON object na naglilista ng model id. Ang Connection refused ay nangangahulugang naglo-load pa ang process ng weights o kaya naman ay nag-exit na ito, kaya basahin ang server log bago mo subukan ulit.

Ang karaniwang failure noong mga unang linggo ay ang runtime na mas luma kaysa sa model. Ang K3 ay inilabas kasama ang KDA at isang bagong MoE layer na wala sa mga stable vLLM at SGLang releases noong launch, at ang sintomas nito ay ang pag-exit ng server habang nag-i-startup na may linyang katulad ng Model architectures [...] are not supported for now. Walang config change ang makakaayos nito, dahil ang code para patakbuhin ang mga layer na iyon ay wala sa iyong build. Nagbago na ito: simula noong 27 October 2026, ang SGLang ay may suporta na para sa K3 sa mga release nito simula v0.5.17, kung saan ang v0.5.22 ang pinakabago, at ang release notes ng vLLM mula v0.28.0 hanggang v0.32.0 ay kasama na ang K3 work. Mag-install ng kasalukuyang release. Ang ilang hardware-specific paths ay may pangalan pa rin ng dedicated image, halimbawa ang NVFP4 builds ng SGLang sa Blackwell, kaya suriin ang recipe para sa iyong card.

Isang paalala tungkol sa gastos na madalas makaligtaan. Ang metro ay nagsisimula kapag nag-start ang instance, hindi kapag handa na ang model. Ang 1.56 TB na download sa bilis na 1 GB/s ay aabutin ng mga 26 minuto ng cluster time bago lumabas ang unang token. I-stage ang mga weights sa isang volume na hindi nabubura pagkatapos ng instance, para ang pangalawang run ay magsimula sa loob lamang ng ilang minuto.

Tier 2: pagpapatakbo ng mas maliit na model sa isang accelerator

Hindi mo pinapatakbo ang K3 sa tier na ito. Sabihin mo ito nang malakas bago ka magsimula, dahil karamihan sa mga thread na "run K3 locally" ay humihinto rito nang hindi ito inaamin.

Ang fit rule ay parehong formula sa mas maliit na scale: parameters multiplied by bytes per weight, plus KV cache, plus mga 2 GB ng runtime overhead, ay dapat magkasya sa iyong VRAM. Sa 4-bit, ito ay humigit-kumulang kalahating byte bawat parameter, na nagbibigay ng mga komportableng pairing:

  • 16 GB card: isang 7B model sa 4-bit na may espasyo para sa mahabang context
  • 24 GB card: isang 14B model sa 4-bit
  • 48 GB card: isang 32B model sa 4-bit
  • 80 GB card: isang 70B model sa 4-bit, o isang 30B class MoE sa 8-bit

Ang bawat pairing sa itaas ay nag-aassume ng isang request sa bawat pagkakataon. Sa sandaling magpadala ng prompt ang pangalawang tao, ang bawat concurrent slot ay nangangailangan ng sarili nitong KV cache. Ito ang trade-off na ginagawa para sa iyo ng Ollama's NUM_PARALLEL and MAX_QUEUE settings sa pagitan ng mga parallel slot, queued requests, at ang natitirang VRAM mo.

May isang paraan para patakbuhin ang mismong K3 sa isang malaking machine, at ito ay nasa pagitan ng tier na ito at ng huli. Dinodokumento ng Unsloth ang mga GGUF build ng K3 sa llama.cpp, mula sa 1-bit at 2-bit quantisation hanggang sa UD-Q8_K_XL, na tinatawag nitong full precision lossless, at tinutukoy ang NVIDIA DGX Station bilang hardware na kayang magpatakbo nito. Ang rule of thumb nito ay ang RAM plus VRAM ay dapat humigit-kumulang katumbas ng quant size, mula sa mga 610 GB para sa 1-bit UD-IQ1_S build hanggang sa mga 1.6 TB para sa Q8. Kapag mas mababa rito, babagsak ang model sa disk at babagal nang husto. Opsyonal ang GPU: ang mga build instruction ng Unsloth ay nag-o-off ng CUDA "kung wala kang GPU o gusto mo lang ng CPU inference". Ang 1-bit at 2-bit builds ay K3 na heavily quantised, sa halaga ng accuracy na sinukat sa itaas. Ang Q8 build ay K3 sa released precision nito, na sineserbisyuhan sa isang user sa bilis ng RAM. Hindi alinman sa mga ito ang mas maliit na model.

Ang Ollama ang pinakamabilis na paraan para magkaroon ng gumaganang server sa isang VPS na may nakakabit na GPU:

curl -fsSL https://ollama.com/install.sh | sh
ollama run qwen3:14b

ollama run ang nagda-download ng model sa unang paggamit, pagkatapos ay dadalhin ka sa isang prompt. Ang tag na hindi umiiral ay magbabalik ng Error: model "..." not found, kaya kopyahin ang mga tag mula sa library page sa halip na i-type ang mga ito mula sa memorya. Ang buong walkthrough, kabilang ang systemd unit at remote access, ay nasa pagpapatakbo ng Ollama sa isang VPS.

Nagbibigay sa iyo ang llama.cpp ng higit na kontrol sa quantisation at 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 ang humihiling para sa bawat layer sa GPU. Basahin ang load log: ipinapakita nito kung ilang layer ang na-offload. Ang mga layer na napupunta sa system RAM ay tumatakbo sa bilis ng RAM sa halip na bilis ng HBM, kaya ang bilis ng generation ay babagsak nang malaki sa sandaling hindi na magkasya ang model. Ang mga trade-off sa pagitan ng dalawang tool na ito ay tinalakay sa Ollama at llama.cpp nang magkatabi.

Tier 3: hosted API, self-hosted orchestration

TsartKimi K3 published API pricing, USD per million tokens, checked 17 July 2026
Ang datos sa likod ng tsart na ito
[
  {
    "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"
  }
]

Ang endpoint ay compatible sa OpenAI, kaya gagana ang existing client kapag binago mo ang 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."}]}'

Ang gumaganang key ay nagbabalik ng JSON object na may choices array. Ang 401 ay nangangahulugang nabigo ang authentication: tiyaking tama ang key at hindi pa ito expired o disabled, at ang header ay nakasulat bilang Authorization: Bearer na sinusundan ng key. Ang error na model-not-found ay karaniwang nangangahulugang nagbago ang id, dahil nagreretiro ang mga provider ng mga id sa pagitan ng mga checkpoint.

Ngayon, tingnan natin ang break-even point gamit ang rental rate na nabanggit sa itaas. Ang isang always-on na 8 GPU node ay nagkakahalaga ng 14,400 USD kada buwan, at sa 15.00 USD kada isang milyong output tokens, ang parehong halaga ay makakabili ng humigit-kumulang 960 milyong output tokens mula sa API. Para makatipid, kailangan mong mag-generate ng halos isang bilyong output tokens kada buwan, o humigit-kumulang 30 milyon kada araw, at panatilihing busy ang cluster sa buong oras, dahil ang mga idle GPU ay may parehong singil gaya ng mga busy na GPU. Ang mga agent workload na mabigat sa prompt ay lalong nagpapalayo sa break-even point: ang paulit-ulit na context ay sinisingil sa cache-hit rate na 0.30 USD kada milyon sa halip na cache-miss rate na 3.00 USD.

Ang self-hosted mo sa tier na ito ay ang lahat ng nakapalibot sa model: isang gateway na humahawak sa API key para hindi ito makarating sa client, request at response logs, retries, rate limits, at per-user budgets. Tumatakbo ito sa isang maliit na VPS na walang GPU. Ang parehong setup ay ginagamit sa closed weights, kung saan ang self-hosting Claude ay hindi posible sa level ng model at ang orchestration lamang ang bahaging pagmamay-ari mo.

Aling serving stack ang nabibilang sa bawat tier

Ang mga server na gaya ng vLLM at SGLang ay nabibilang sa tier 1. Nagsisilbi ang mga ito para sa maraming request nang sabay-sabay, gamit ang continuous batching at paged KV cache, pati na rin ang tensor at expert parallelism na nakakalat sa ilang node. Ipinapalagay ng mga ito na gumagamit ka ng mga datacentre accelerator at mabilis na interconnect sa pagitan ng mga ito. Sa isang consumer card, mas mabigat ang mga ito i-install at kakaunti lang ang mapapansin mong benepisyo.

Ang llama.cpp at Ollama ay nabibilang sa tier 2. Nakatuon ang mga ito sa iisang machine, GGUF quantisation, CPU offload kapag hindi kasya ang model, at mababang concurrency. Ilo-load ng llama.cpp ang isang malaking MoE sa pamamagitan ng pagpapanatili ng expert weights sa system RAM (--cpu-moe o --n-cpu-moe) at, gamit ang --moe-cache-mib, ica-cache nito ang mga expert na ginagamit sa GPU; ganito tumatakbo ang mga K3 GGUF build ng Unsloth sa iisang machine. Ang bilis ay nakadepende sa RAM bandwidth at sa dalas ng pag-miss ng router sa cache. Kung mas malaki ang file kaysa sa pinagsamang RAM at VRAM, babagsak ito sa disk. Isa itong gumaganang setup para sa isang user. Hindi ito serbisyo na maaari mong lagyan ng maraming user. Ang buong paghahambing ay nasa Ollama laban sa vLLM, at hindi ito nagbabago base sa model: ang tanong ay palaging kung nagsisilbi ka ba ng maraming user sa shared hardware o isang user lang sa sarili mong machine.

Ang apat na numero na mananatiling may saysay pagkatapos ng checkpoint na ito

  1. Ang kabuuang parameters na pinarami sa bytes bawat weight ang nagtatakda ng memory floor. Walang tumatakbo nang mas mababa rito sa shipped precision, at ang pag-quantise nang mas mababa sa 4-bit release ay nagbibigay lamang ng hanggang 70 porsyento na matitipid kapalit ng accuracy, hindi ng isang order of magnitude.
  2. Ang active parameters ang nagtatakda ng throughput class. Ang isang 2.8T MoE na may 104B active ay nag-compute gaya ng isang 104B model.
  3. Ang KV cache bawat token, na pinarami sa context length at concurrency, ang gastos na patuloy na lumalaki matapos mong bayaran ang mga weight.
  4. Ang tokens per second per dollar ang tanging numero na nagtatakda ng tier. Lahat ng nasa itaas ay input lamang para rito.

Gamitin ang apat na ito sa anumang release at makukuha mo ang tamang sagot bago mo pa buksan ang vendor guide. Ang susunod ay inanunsyo na: inilabas ng Moonshot ang K3.1 Pro, na binuo sa K3 na may karagdagang post-training, sa Kimi Code noong 23 October 2026, at ayon sa API quickstart nito, ilalabas ang full weights sa o bago ang 4 November. Lagyan ng petsa ang bawat figure na isusulat mo. Ang mga presyo at listahan ng supported-architecture ay parehong nagbago sa loob ng dalawang linggo matapos ilunsad ang K3. Ang mga launch figure sa pahinang ito ay inilathala noong July 2026, at ang mga serving recipe, runtime release, at quantisation number ay muling sinuri noong 27 October 2026.

FAQ

Maaari ko bang patakbuhin ang Kimi K3 sa isang GPU lang?

Hindi. Ang mga weight ay nasa 1.4 TB sa MXFP4 precision na inilalabas ng Moonshot, at kahit ang pinakamaliit na inilathalang quantisation ng K3, ang 466 GB UD-Q1_0 file ng Unsloth, ay nasa 1.6 beses ng 288 GB na nasa pinakamalalaking accelerator na malawakang magagamit. Kayang panatilihin ng llama.cpp ang mga expert sa system RAM at i-cache ang mga aktibo sa GPU, ngunit nangangailangan pa rin ito ng humigit-kumulang na laki ng quant sa RAM at VRAM; kung mas mababa rito, babagsak ang model sa disk at tatakbo nang mas mabagal. Ang pinakamaliit na inilathalang serving recipe ay gumagamit ng isang 8-GPU node ng B300 o MI350X/MI355X cards, at ang H100 recipe ay gumagamit ng 32.

Gaano karaming VRAM ang kailangan ng Kimi K3?

Magsimula sa 1.4 TB para sa mga weight lamang, na katumbas ng 18 H100 80GB cards o 5 GB300 class cards. Idagdag pa rito ang KV cache at activation memory. Ang gabay sa pag-launch ng Moonshot ay nagrekomenda ng 64 o higit pang accelerator. Base sa datos noong 27 October 2026, ang SGLang cookbook ay naglalathala ng mga single-node recipe sa 8 B300 o 8 MI350X/MI355X cards, na may 2,304 GB aggregate, at isang 32 GPU H100 configuration na may 2,560 GB aggregate, kaya ituring ang figure ng mga weight bilang minimum at hindi bilang eksaktong requirement.

Kasya ba ang Kimi K3 sa isang node gamit ang quantisation?

Ang inilabas na 4-bit checkpoint ay kasya na sa isang node kung ang node na iyon ay may walong 288 GB cards, na siyang ginagamit ng mga B300 at MI355X recipe ng SGLang, at sa isang machine na may humigit-kumulang 1.6 TB ng RAM at VRAM sa pamamagitan ng lossless Q8 GGUF ng Unsloth. Ang pagbaba ng precision ay nakakatulong sa mas maliliit na machine: ang mga sinukat na dynamic GGUF build ng Unsloth ay mula 861.3 GB sa 2-bit hanggang 594 GB sa 1-bit, at ang repo nito ay naglilista ng mga 1-bit file hanggang 466 GB, kumpara sa humigit-kumulang 1.56 TB na lossless. Nasukat na ang epekto sa accuracy: ang top-1 agreement sa full model ay bumabagsak sa 90.390 percent sa UD-Q2_K_XL at 78.875 percent sa UD-IQ1_S. Wala sa mga ito ang kasya sa isang card lang.

Mas mura ba ang mag-renta ng GPU kaysa sa Kimi K3 API?

Sa mataas at tuloy-tuloy na volume lamang. Sa assumption na 2.50 USD bawat GPU hour, ang isang laging naka-on na 8 GPU node ay nagkakahalaga ng 14,400 USD kada buwan, at ang parehong halaga ay makakabili ng humigit-kumulang 960 milyong output token sa inilathalang rate na 15.00 USD bawat milyon. Magbabayad ka rin para sa mga idle hour, pag-download ng weight, at sa taong nagpapanatili sa cluster. Mag-renta kada oras para sa mga burst, at ikumpara ito sa sarili mong nasukat na token volume sa halip na sa hula lang.

Ano ang ibig sabihin ng 104B active parameters para sa bilis?

Ibig sabihin nito, ang arithmetic bawat token ay katulad ng sa isang 104B model, kaya ang throughput ay nasa class na iyon sa halip na sa 2.8T class. Wala itong sinasabi tungkol sa memory: lahat ng 2.8T parameters ay mananatiling resident, dahil ang router ay maaaring tumawag ng anumang expert para sa anumang token. Gamitin ang active count para i-predict ang tokens per second, at ang total count para sukatin ang kailangang VRAM.

Nakatulong ba ang artikulong ito?

#kimi-k3#self-hosted-llm#gpu#vram#inference