SSD Nodes Learn Hosting plans →
मार्गदर्शक Matt Connorद्वारे Matt Connor · अपडेटेड 2026-10-30

Kimi K3 स्वतः होस्ट करण्यासाठी किती GPU लागतात?

Kimi K3 चे 2.8 ट्रिलियन parameters, MXFP4 मधील सुमारे 1.4 TB weights आणि KV cache मोजणी समजून घ्या. 32-GPU cluster शिवाय चालवण्याचे तीन व्यवहार्य मार्ग येथे आहेत.

Kimi K3 स्वतः होस्ट करण्यासाठी आवश्यक बाबी

Kimi K3 स्वतः होस्ट करण्यासाठी 2.8 ट्रिलियन parameters साठवण्याइतकी जागा आवश्यक आहे. Moonshot ने open weights MXFP4 मध्ये प्रकाशित केले आहेत. प्रत्येक weight सुमारे अर्धा byte असल्यामुळे, cache साठी एकही token राखून ठेवण्यापूर्वीच weights सुमारे 1.4 TB होतात. आज उपलब्ध असलेल्या कोणत्याही accelerator मध्ये एवढी जागा एकट्याने नाही. एका GPU साठी उत्तर नाही. एका server साठी उत्तर होय आहे, आणि त्याचे दोन प्रकार आहेत. पहिला प्रकार म्हणजे एकूण 288 GB accelerators असलेला 8-GPU node. सर्वात लहान प्रकाशित multi-user serving recipes मध्ये हीच रचना वापरली आहे. दुसरा प्रकार म्हणजे सुमारे 1.6 TB एकत्रित RAM आणि VRAM असलेले एक machine. त्यावर GPU असो वा नसो, llama.cpp मध्ये Unsloth चे lossless Q8 GGUF चालवून एकावेळी एका user ला सेवा देता येते.

हा निष्कर्ष आहे. खालील सर्व माहिती यामागील गणित स्पष्ट करते, कारण पुढील release साठी पुन्हा वापरता येणारा भाग हेच गणित आहे. 16 July 2026 रोजी घोषणा झाल्यानंतरच्या काही आठवड्यांत अनेक infrastructure vendors ने K3 deployment guides प्रकाशित केले. त्या प्रत्येक मार्गदर्शकाने तुमच्याकडे आधीपासून cluster आहे असे गृहीत धरले. हे पृष्ठ उलट दिशेने सुरुवात करते: यासाठी किती खर्च येतो, त्याऐवजी तुम्ही काय चालवू शकता आणि या दोनपैकी तुम्ही कोणत्या परिस्थितीत आहात हे कसे ओळखायचे.

एकूण parameters आणि सक्रिय parameters समान नसतात

K3 हे mixture of experts मॉडेल आहे. MoE (mixture of experts) नेटवर्कला अनेक sub-networks मध्ये विभागते आणि प्रत्येक token साठी त्यांपैकी काही निवडण्यासाठी router वापरते. Model card मध्ये 2.8T एकूण parameters आणि प्रत्येक token साठी सक्रिय होणारे 104B parameters दिले आहेत. 93 layers मध्ये असलेल्या 896 routed experts पैकी कोणत्याही token साठी 16 experts सक्रिय होतात.

हे दोन parameter counts वेगवेगळ्या प्रश्नांची उत्तरे देतात. प्रत्येक "can I run this" चर्चेत त्यांची अदलाबदल करणे ही सर्वात सामान्य चूक असते.

सक्रिय parameters मुळे compute cost ठरतो. प्रत्येक token सुमारे 104B parameters मधून प्रक्रिया होतो. त्यामुळे अपेक्षित throughput हा 2.8T मॉडेलपेक्षा 104B dense मॉडेलसारखा असेल. MoE तयार करण्याचे हेच मुख्य कारण आहे.

एकूण parameters मुळे memory cost ठरतो. कोणत्याही token साठी router कोणताही expert निवडू शकतो. त्यामुळे पहिली request येण्यापूर्वी प्रत्येक expert जलद उपलब्ध असलेल्या storage मध्ये ठेवावा लागतो. फक्त वारंवार वापरले जाणारे experts VRAM मध्ये ठेवून उरलेले experts आवश्यकतेनुसार आणण्याची पद्धत उपलब्ध आहे. llama.cpp मधील --moe-cache-mib GPU cache मध्ये experts ठेवते. उरलेले experts system RAM मध्ये राहतात आणि router त्यांची निवड केल्यावर आवश्यक experts GPU वर upload केले जातात. मात्र यामुळे एकूण size कमी होत नाही. उरलेले experts तरीही RAM मध्ये ठेवावे लागतात. PCIe link वरून प्रति सेकंद काही दहा gigabytes इतका data transfer होतो, तर HBM चा वेग प्रति सेकंद terabytes इतका असतो. त्यामुळे प्रत्येक cache miss मुळे वेळ लागतो. मॉडेल RAM मध्येही बसत नसेल आणि experts NVMe वरून stream करावे लागत असतील, तर वेग आणखी कमी होतो. Unsloth च्या K3 guide मध्ये disk offloading खूपच कमी वेगाने चालते असा इशारा दिला आहे.

म्हणून computation स्वस्त आहे, पण storage महाग आहे. Hardware चे sizing 2.8T parameters नुसार करा. वेगाबाबतच्या अपेक्षा 104B parameters नुसार ठेवा.

प्रति weight bytes आणि terabytes कुठून येतात

Parameter count × bytes per weight. Weights साठी हेच संपूर्ण सूत्र आहे.

तक्ताWeight footprint of 2.8 trillion parameters, by precision
या तक्त्यामागील डेटा
[
  {
    "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 चे training quantisation-aware पद्धतीने झाले आणि ते MXFP4 weights व MXFP8 activations सह release करण्यात आले. त्यामुळे 4-bit row ही प्रत्यक्ष वापरातील row आहे. त्यावरील rows scale दाखवण्यासाठी आहेत: bf16 मध्ये त्याच model ला 5.6 TB आवश्यक असते. MXFP4 मध्ये प्रत्येक 32 weights च्या block साठी एक shared 8-bit scale देखील साठवला जातो. त्यामुळे सुमारे 6 percent अतिरिक्त जागा लागते. तसेच Moonshot च्या config मध्ये attention, shared experts आणि vision tower यांना 4-bit format मधून वगळले आहे. त्यामुळे Unsloth च्या मोजणीनुसार पूर्ण checkpoint सुमारे 1.56 TB होते, स्वच्छ 1.4 TB नाही.

यामुळे नेहमीचा पर्यायी मार्ग मर्यादित होतो, पण पूर्णपणे बंद होत नाही. Release केलेला checkpoint आधीच 4-bit आहे. त्यामुळे सहज मिळणारी बचत आधीच केली गेलेली आहे. तरीही त्यापेक्षा कमी bit वापरल्यास आकार आणखी कमी होतो. 27 October 2026 रोजी उपलब्ध माहितीनुसार, Unsloth ने मोजलेल्या K3 च्या dynamic GGUF quantisations चा आकार 2-bit UD-Q2_K_XL साठी 861.3 GB पासून 1-bit UD-IQ1_S साठी 594 GB पर्यंत आहे. Unsloth यासाठी होणारा परिणामही प्रकाशित करते: full model शी top-1 token agreement UD-Q2_K_XL मध्ये 90.390 percent, 711.1 GB असलेल्या UD-IQ2_XXS मध्ये 84.127 percent आणि UD-IQ1_S मध्ये 78.875 percent आहे. त्याच्या Hugging Face repo मध्ये आणखी लहान 1-bit files देखील आहेत. UD-Q1_0 साठी आकार 466 GB पर्यंत कमी होतो; मात्र त्यासोबत agreement figure प्रकाशित केलेली नाही. हा मोजलेला accuracy loss आहे. सर्वात लहान file देखील सर्वात मोठ्या single card पेक्षा सुमारे 1.6 पट मोठी आहे.

Kimi K3 साठी किती GPU आवश्यक आहेत

तक्ताGPUs required to hold 1.4 TB of weights, before any KV cache
या तक्त्यामागील डेटा
[
  {
    "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
  }
]

हे आकडे किमान मर्यादा म्हणून पहा; लक्ष्य म्हणून नाही. यात केवळ weights चा हिशोब आहे. KV cache, activation buffers, allocator fragmentation आणि एकाच वेळी दुसरी concurrent request हाताळण्यासाठीची मोकळी क्षमता यात समाविष्ट नाही. GPU ची विभागणी समान असणे आवश्यक नाही. vLLM चे pipeline parallelism मॉडेलचे layers नुसार विभाजन करते आणि असमान विभागणीला समर्थन देते. SGLang च्या K3 prefill recipes मध्ये 93 layers साठी 8 आणि 16 pipeline stages वापरल्या जातात.

प्रकाशित मार्गदर्शन या किमान मर्यादेपेक्षा जास्त आहे. Moonshot च्या launch guidance मध्ये 64 किंवा त्याहून अधिक accelerators असलेल्या supernode ची शिफारस केली होती. 27 October 2026 रोजी SGLang cookbook मध्ये चार 8-GPU nodes वर आधारित H100 configuration दिले आहे. त्यात 32 GPUs आणि एकूण 2,560 GB memory आहे. याच्या तुलनेत किमान 18 cards आवश्यक आहेत. त्याच cookbook मध्ये एका 8-GPU B300 node वर आणि एका 8-GPU MI350X किंवा MI355X node वर single-node recipes देखील दिल्या आहेत. येथे प्रत्येक card साठी 288 GB प्रमाणे एकूण 2,304 GB memory आहे. किमान मर्यादेपेक्षा जास्त असलेली ही क्षमता वाया जात नाही. ती KV cache, activation memory आणि एकाच वेळी अनेक requests batch करण्यासाठी आवश्यक headroom देते. 5 GB300 class cards असलेली सर्वात अनुकूल configuration प्रत्यक्षात अशाच 8-GPU node पर्यंत round up होते. अनेक वापरकर्त्यांसाठी K3 serving recipe प्रकाशित केलेली ही सर्वात लहान मशीन आहे.

KV cache हा लोकांना आश्चर्यचकित करणारा भाग आहे

Weights हा निश्चित खर्च आहे. KV (key value) cache तसा नाही: तो context length सोबत वाढतो आणि प्रत्येक concurrent user सोबत पुन्हा वाढतो. सामान्य attention साठी सूत्र bytes per token = 2 * layers * kv_heads * head_dim * bytes_per_element आहे. त्यानंतर context length आणि concurrency ने गुणाकार करा.

खाली एक कार्य केलेले उदाहरण दिले आहे. हे फक्त उदाहरण आहे: 64 layers, 8 KV heads, head dimension 128 आणि fp8. त्यामुळे 2 64 8 128 1 = 131,072 bytes, म्हणजे प्रत्येक token साठी 128 KiB मिळतात.

तक्ताKV cache per user in the worked example, at 128 KiB per token
या तक्त्यामागील डेटा
[
  {
    "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
  }
]

128k context वर एका user साठी 16 GiB खर्च होतात. पूर्ण million context वर एका user साठी 128 GiB खर्च होतात. एकही weight load करण्यापूर्वी, एका conversation साठी हे 288 GB card च्या जवळपास निम्मे आहे.

K3 सामान्य attention वापरत नाही. मागील आकडा त्याचे कारण स्पष्ट करतो. त्याच्या 93 layers पैकी 69 KDA (Kimi Delta Attention) layers आणि 24 Gated MLA (multi-head latent attention) layers आहेत. प्रत्येक token सोबत वाढणाऱ्या cache ऐवजी KDA निश्चित आकाराची recurrent state ठेवते. MLA key आणि value यांना एका low rank latent vector मध्ये compress करते. त्यामुळे प्रत्यक्ष per-token खर्च वरील उदाहरणापेक्षा खूपच कमी होतो. Moonshot च्या प्रकाशित config.json मध्ये त्या latent चा आकार दिला आहे: 512 चा kv_lora_rank आणि 64-wide rotary key (qk_rope_head_dim), म्हणजे प्रत्येक MLA layer साठी प्रत्येक token ला 576 values. 24 layers मध्ये प्रत्येकी 2 bytes धरल्यास 27,648 bytes मिळतात. हे प्रत्येक token साठी सुमारे 27 KiB, किंवा पूर्ण 1,048,576 token conversation साठी अंदाजे 27 GiB आहे. याशिवाय fixed KDA state असते. हा आकडा measurement ऐवजी estimate म्हणून वापरा. Engines cache ला त्यांच्या पद्धतीने pad आणि layout करतात. 8-bit cache वापरल्यास हा खर्च साधारण निम्मा होतो.

तुमच्या deployment मध्ये प्रत्यक्षात किती जागा राखीव आहे हे पाहण्यासाठी, --max-model-len वाढवत असताना nvidia-smi monitor करू नका. vLLM त्याचा KV cache pool आधीच preallocate करते. हा pool --gpu-memory-utilization वरून मोजला जातो (सध्याच्या docs मध्ये default 0.92) किंवा explicit per-GPU cache budget वरून मोजला जातो. त्यामुळे total GPU memory एका conversation ऐवजी संपूर्ण pool दाखवते. त्याऐवजी startup log वाचा. त्यात vLLM KV cache size tokens मध्ये आणि तुमच्या context length साठी maximum concurrency दाखवते.

पुढील release मध्येही या reasoning ची रचना लागू राहील. एखाद्या model ने million token context जाहीर केला आणि त्याच्या attention design विषयी काही सांगितले नाही, तर cache हीच binding constraint आहे असे गृहीत धरा, जोपर्यंत त्याच्या उलट पुरावा मिळत नाही.

स्तर 1: क्लस्टर तासाच्या दराने भाड्याने घ्या

अनेक वापरकर्त्यांना एकाच वेळी K3 त्याच्या प्रकाशित precision वर सेवा देणारा हा स्तर आहे. पुरेशी RAM असलेले एक मशीन Unsloth च्या Q8 GGUF द्वारे K3 त्याच्या प्रकाशित precision वर ठेवू शकते. Unsloth याला full precision lossless असे म्हणते. मात्र त्या पद्धतीत एका वेळी एकाच वापरकर्त्याला सेवा देता येते आणि तिचा समावेश स्तर 2 मध्ये आहे. येथे hardware खरेदी करायचे नसते. आवश्यक तेवढ्या तासांसाठी ते भाड्याने घ्या आणि नंतर बंद करा.

तक्ताMonthly cost at an assumed 2.50 USD per GPU hour, 30 day month
या तक्त्यामागील डेटा
[
  {
    "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"
  }
]

हा दर गृहीत धरलेला आहे; तो quote नाही. Provider आणि GPU generation नुसार on-demand दर मोठ्या प्रमाणात बदलतात. Single-node recipes साठी आवश्यक असलेल्या 288 GB भागांचा प्रति-तास खर्च H100 पेक्षा जास्त असतो. Reserved capacity स्वस्त असते. तुमच्या provider कडील वास्तविक संख्या घेऊन गुणाकार पुन्हा करा: GPUs times hours times rate. Chart चा उद्देश ratio दाखवणे हा आहे. दिवसाला चार तास 8 GPU node सुरू ठेवण्याचा खर्च दरमहा 2,400 USD असतो, तर SGLang साठी आकारलेली 32 GPU H100 configuration सुरू ठेवण्याचा खर्च 57,600 USD असतो.

दोन्ही मुख्य प्रवाहातील servers model card वर launch command प्रकाशित करतात.

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

प्रत्यक्ष cluster वर चालवण्यासाठी यापैकी कोणताही bare command पुरेसा नाही. तुमच्या hardware शी जुळणारे parallelism flags जोडा: SGLang tensor parallel साठी --tp-size, pipeline parallel साठी --pp-size आणि expert parallel साठी --ep-size स्वीकारते. Tensor parallel times pipeline parallel हे तुमच्याकडे प्रत्यक्ष असलेल्या GPUs इतके असणे आवश्यक आहे. Expert parallel त्या group मधील experts विभाजित करते. म्हणून 32 GPU H100 recipe मध्ये --tp-size 32 आणि --ep-size 32 दोन्ही सेट केले आहेत.

वास्तविक traffic पाठवण्यापूर्वी server सुरू झाला आहे का ते तपासा:

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

निरोगी server model id सूचीबद्ध करणाऱ्या JSON object ने उत्तर देतो. Connection refused याचा अर्थ process अजून weights load करत आहे किंवा आधीच exit झाला आहे. त्यामुळे पुन्हा प्रयत्न करण्यापूर्वी server log वाचा.

पहिल्या काही आठवड्यांत model पेक्षा जुना runtime ही सर्वसाधारण अडचण होती. K3 KDA आणि नवीन MoE layer सह प्रकाशित झाले. Stable vLLM आणि SGLang releases मध्ये launch वेळी या layer साठी code नव्हता. त्यामुळे startup दरम्यान server Model architectures [...] are not supported for now या स्वरूपाच्या ओळीने exit होतो. Configuration बदलून ही समस्या सुटत नाही, कारण या layers चालवण्यासाठी लागणारा code तुमच्या build मध्ये नाही. त्यानंतर परिस्थिती बदलली आहे: 27 October 2026 रोजी उपलब्ध स्थितीनुसार, SGLang च्या releases मध्ये v0.5.17 पासून K3 support आहे आणि v0.5.22 ही latest आवृत्ती आहे. तसेच vLLM च्या v0.28.0 ते v0.32.0 या सर्व release notes मध्ये K3 संदर्भातील काम समाविष्ट आहे. Current release install करा. काही hardware-specific paths मध्ये अजूनही dedicated image चे नाव दिलेले असते. उदाहरणार्थ, Blackwell साठी SGLang चे NVFP4 builds आहेत. त्यामुळे तुमच्या card साठी recipe तपासा.

एक खर्चाचा मुद्दा लक्षात ठेवा. Meter instance सुरू झाल्यावर सुरू होते; model तयार झाल्यावर नाही. 1 GB/s वेगाने 1.56 TB download करण्यास सुमारे 26 मिनिटे लागतात. या काळात पहिला token मिळण्यापूर्वी cluster चा वेळ खर्च होतो. Instance पेक्षा जास्त काळ टिकणाऱ्या volume वर weights आधीच stage करा. त्यामुळे दुसरी run काही मिनिटांत सुरू होईल.

स्तर 2: एका accelerator वर लहान मॉडेल चालवा

या स्तरावर तुम्ही K3 चालवत नाही. सुरुवात करण्यापूर्वी हे स्पष्टपणे सांगा, कारण “K3 locally चालवणे” यावरील बहुतेक चर्चा हे मान्य न करताच इथेच थांबतात.

फिट होण्याचा नियम तोच आहे, फक्त लहान प्रमाणात: parameters × bytes per weight, त्यात KV cache आणि सुमारे 2 GB runtime overhead जोडल्यावर एकूण वापर तुमच्या VRAM पेक्षा कमी असला पाहिजे. 4-bit मध्ये प्रत्येक parameter साठी साधारण अर्धा byte लागतो. त्यामुळे पुढील जोड्या व्यवहार्य ठरतात:

  • 16 GB card: 4-bit मधील 7B model, आणि मोठ्या context साठी अतिरिक्त जागा
  • 24 GB card: 4-bit मधील 14B model
  • 48 GB card: 4-bit मधील 32B model
  • 80 GB card: 4-bit मधील 70B model किंवा 8-bit मधील 30B class MoE

वरील प्रत्येक जोडीमध्ये एका वेळी एकच request गृहीत धरलेली आहे. दुसऱ्या व्यक्तीने prompt पाठवताच प्रत्येक concurrent slot साठी स्वतंत्र KV cache लागतो. उपलब्ध VRAM आणि parallel slots व queued requests यांच्यातील तडजोड Ollama मधील NUM_PARALLEL आणि MAX_QUEUE settings तुमच्यासाठी ठरवते.

एका मोठ्या मशीनवर K3 स्वतः चालवण्याचा एक मार्ग आहे. तो या स्तराच्या आणि शेवटच्या स्तराच्या मधला पर्याय आहे. Unsloth, llama.cpp मध्ये K3 चे GGUF builds दस्तऐवजीकरण करते. त्यात 1-bit आणि 2-bit quantisations पासून UD-Q8_K_XL पर्यंतचे builds आहेत. UD-Q8_K_XL ला ती full precision lossless असे म्हणते आणि हे builds चालवू शकणारे hardware म्हणून NVIDIA DGX Station चे नाव देते. तिच्या अंदाजानुसार RAM plus VRAM हे quant size इतके असावे: 1-bit UD-IQ1_S build साठी सुमारे 610 GB पासून Q8 साठी सुमारे 1.6 TB पर्यंत. यापेक्षा कमी memory असल्यास model disk वर fallback होते आणि वेग मोठ्या प्रमाणात कमी होतो. GPU आवश्यक नाही. “if you don't have a GPU or just want CPU inference” अशा परिस्थितीत Unsloth च्या build instructions मध्ये CUDA बंद केले जाते. 1-bit आणि 2-bit builds हे K3 चे heavily quantised प्रकार आहेत आणि त्यामुळे वर मोजलेल्या accuracy च्या किमतीवर ते चालतात. Q8 build हे released precision मधील K3 आहे आणि एका user ला RAM speed वर serve केले जाते. यापैकी कोणतेही लहान model नाही.

GPU जोडलेल्या VPS वर Ollama चालवणे हा कार्यरत server सुरू करण्याचा सर्वात सोपा मार्ग आहे:

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

ollama run पहिल्या वापरावेळी model download करते आणि त्यानंतर prompt दाखवते. अस्तित्वात नसलेला tag Error: model "..." not found परत करतो. त्यामुळे tags अंदाजाने टाइप करण्याऐवजी library page वरून copy करा. systemd unit आणि remote access यांसह संपूर्ण walkthrough VPS वर Ollama चालवणे येथे आहे.

llama.cpp quantisation आणि 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 प्रत्येक layer GPU वर ठेवण्याची विनंती करते. load log तपासा: त्यात किती layers offload झाले ते दिसते. system RAM मध्ये राहिलेले layers HBM bandwidth ऐवजी RAM bandwidth वर चालतात. त्यामुळे model बसणे थांबताच generation speed एका order of magnitude ने कमी होते. या दोन्ही tools मधील तडजोडी Ollama आणि llama.cpp ची बाजू-बाजूने तुलना येथे स्पष्ट केल्या आहेत.

स्तर 3: hosted API, self-hosted orchestration

तक्ताKimi K3 published API pricing, USD per million tokens, checked 17 July 2026
या तक्त्यामागील डेटा
[
  {
    "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 OpenAI compatible आहे. त्यामुळे base URL बदलल्यानंतर विद्यमान client कार्य करते.

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 मुळे choices array असलेला JSON object मिळतो. 401 आल्यास authentication अयशस्वी झाले आहे. key योग्य आहे आणि तिची मुदत संपलेली किंवा ती disabled केलेली नाही, हे तपासा. Header मध्ये Authorization: Bearer नंतर key दिली आहे, हेही तपासा. Model-not-found error सहसा id बदलल्यामुळे येतो, कारण providers checkpoints दरम्यान ids retire करतात.

आता वर गृहीत धरलेल्या rental rate नुसार break-even पाहू. सतत सुरू असलेल्या 8 GPU node ची किंमत दरमहा 14,400 USD आहे. 15.00 USD प्रति million output tokens या दराने तेवढ्याच रकमेत API कडून सुमारे 960 million output tokens मिळतात. Cost च्या दृष्टीने self-hosting फायदेशीर होण्यासाठी दरमहा जवळपास 1 billion output tokens generate करावे लागतील, म्हणजे दररोज अंदाजे 30 million. तसेच cluster संपूर्ण वेळ व्यस्त ठेवावा लागेल, कारण idle GPUs साठीही व्यस्त GPUs इतकाच दर आकारला जातो. Prompt-heavy agent workloads मुळे हा break-even point आणखी दूर जातो. वारंवार वापरल्या जाणाऱ्या context साठी cache-hit rate 0.30 USD प्रति million हा दर लागू होतो; cache-miss rate 3.00 USD आहे.

या स्तरावर तुम्ही model च्या आसपासची संपूर्ण व्यवस्था self-host करता: API key client पर्यंत कधीही पोहोचू नये यासाठी gateway, request आणि response logs, retries, rate limits आणि प्रत्येक user साठी budgets. हे GPU नसलेल्या छोट्या VPS वर चालवता येते. Closed weights साठीही हीच विभागणी लागू होते. Model स्तरावर Claude self-host करणे शक्य नसते; त्यामुळे orchestration हाच तुमच्या नियंत्रणातील भाग राहतो.

कोणता serving stack कोणत्या tier मध्ये येतो

vLLM आणि SGLang वर्गातील server tier 1 मध्ये येतात. ते एकाच वेळी अनेक requests हाताळण्यासाठी तयार केलेले असतात. यामध्ये continuous batching, paged KV cache, तसेच अनेक nodes वर पसरवलेले tensor आणि expert parallelism असते. हे datacentre accelerators आणि त्यांच्यामधील जलद interconnect गृहीत धरतात. एका consumer card वर ते install करणे अधिक अवघड असते आणि तुम्हाला प्रत्यक्ष जाणवेल असा फारसा फायदा मिळत नाही.

llama.cpp आणि Ollama tier 2 मध्ये येतात. ते एका machine साठी, GGUF quantisation साठी, model मावत नसताना CPU offload साठी आणि low concurrency साठी तयार केलेले आहेत. llama.cpp system RAM मध्ये expert weights ठेवून मोठा MoE load करू शकते (--cpu-moe किंवा --n-cpu-moe). तसेच --moe-cache-mib वापरून ती वापरले जाणारे experts GPU वर cache करू शकते. Unsloth चे K3 GGUF builds एका machine वर अशाच प्रकारे चालतात. त्यानंतर speed RAM bandwidth आणि router किती वेळा cache मध्ये चुकतो यावर अवलंबून असते. file चा आकार RAM आणि VRAM यांच्या एकत्रित क्षमतेपेक्षा मोठा असल्यास ते disk वर उतरते. एका user साठी ही कार्यक्षम रचना आहे. मात्र अनेक users साठी वापरता येईल अशी service ती नाही. संपूर्ण तुलना Ollama विरुद्ध vLLM येथे आहे. model बदलला तरी निष्कर्ष बदलत नाही. shared hardware वर अनेक users साठी serving करायचे आहे की स्वतःच्या hardware वर एका user साठी, हा नेहमीचा मुख्य प्रश्न आहे.

या टप्प्यानंतरही लागू राहणारे चार आकडे

  1. एकूण parameters गुणिले प्रत्येक weight साठी bytes म्हणजे मेमरीची किमान गरज. उपलब्ध precision मध्ये यापेक्षा कमी मेमरीवर काहीही चालत नाही. 4-bit release पेक्षाही कमी quantisation केल्यास accuracy कमी करून सुमारे 70 टक्क्यांपर्यंत बचत मिळू शकते; परंतु order of magnitude इतकी बचत मिळत नाही.
  2. Active parameters मुळे throughput class ठरतो. 104B active parameters असलेले 2.8T MoE मॉडेल 104B मॉडेलप्रमाणे compute करते.
  3. प्रत्येक token साठीचा KV cache गुणिले context length गुणिले concurrency म्हणजे weights साठीचा खर्च भरल्यानंतरही वाढत राहणारा खर्च.
  4. Tokens per second per dollar हा tier निवडण्यासाठी उपयुक्त असलेला एकमेव आकडा आहे. वरील सर्व आकडे त्यासाठीची input आहेत.

हे चार नियम कोणत्याही release वर लागू करा. Vendor guide उघडण्यापूर्वीच योग्य निष्कर्ष मिळतो. पुढील release आधीच जाहीर झाली आहे: Moonshot ने 23 October 2026 रोजी Kimi Code मध्ये K3 वर आधारित आणि पुढील post-training केलेले K3.1 Pro उपलब्ध केले. त्याच्या API quickstart नुसार full weights 4 November पर्यंत release केले जातील. त्यामुळे लिहून ठेवलेल्या प्रत्येक आकड्याला तारीख द्या. K3 launch नंतरच्या दोन आठवड्यांत prices आणि supported-architecture lists दोन्ही बदलल्या. या पृष्ठावरील launch figures July 2026 मध्ये प्रकाशित झाले होते. Serving recipes, runtime releases आणि quantisation numbers यांची 27 October 2026 रोजी पुन्हा पडताळणी करण्यात आली.

FAQ

मी Kimi K3 एकाच GPU वर चालवू शकतो का?

नाही. Moonshot ज्या MXFP4 precision मध्ये weights वितरित करते, त्या precision मध्ये weights सुमारे 1.4 TB आहेत. K3 ची प्रकाशित झालेली सर्वात लहान quantisation, म्हणजे Unsloth ची 466 GB UD-Q1_0 file, ही सर्वाधिक सहज उपलब्ध accelerator मधील 288 GB क्षमतेच्या सुमारे 1.6 पट आहे. llama.cpp experts system RAM मध्ये ठेवून active experts GPU वर cache करू शकते. तरीही RAM आणि VRAM मिळून quantised आकाराच्या अंदाजे एवढी क्षमता आवश्यक असते. त्यापेक्षा कमी क्षमता असल्यास model disk वर उतरतो आणि त्याचा वेग लक्षणीयरीत्या कमी होतो. प्रकाशित केलेल्या सर्वात लहान serving recipes मध्ये B300 किंवा MI350X/MI355X cards असलेला एक 8-GPU node वापरला आहे. H100 recipe मध्ये 32 cards वापरले आहेत.

Kimi K3 साठी किती VRAM आवश्यक आहे?

फक्त weights साठी 1.4 TB पासून सुरुवात करा. हे 18 H100 80GB cards किंवा 5 GB300 class cards इतके आहे. त्यावर KV cache आणि activation memory जोडा. Moonshot च्या launch guidance मध्ये 64 किंवा अधिक accelerators ची शिफारस केली होती. 27 October 2026 रोजी SGLang cookbook मध्ये 8 B300 किंवा 8 MI350X/MI355X cards असलेल्या single-node recipes प्रकाशित आहेत. त्यांची एकूण क्षमता 2,304 GB आहे. त्यात 2,560 GB aggregate असलेले 32 GPU H100 configuration देखील आहे. त्यामुळे weights ची क्षमता ही किमान मर्यादा समजा, अंतिम आवश्यकता नाही.

Quantisation मुळे Kimi K3 एका node वर बसतो का?

वितरित केलेला 4-bit checkpoint एका node वर बसतो, जर त्या node मध्ये प्रत्येकी 288 GB क्षमतेचे आठ cards असतील. SGLang च्या B300 आणि MI355X recipes मध्ये हीच रचना वापरली आहे. Unsloth च्या lossless Q8 GGUF द्वारे सुमारे 1.6 TB RAM आणि VRAM असलेल्या एका machine वरही तो बसतो. कमी quantisation मुळे लहान machines साठी आवश्यकता कमी होते. Unsloth च्या मोजलेल्या dynamic GGUF builds मध्ये 2-bit साठी 861.3 GB ते 1-bit साठी 594 GB अशी range आहे. त्याच्या repo मध्ये 466 GB पर्यंतच्या 1-bit files सूचीबद्ध आहेत. Lossless आकार सुमारे 1.56 TB आहे. Accuracy वरील परिणाम मोजला गेला आहे: full model सोबतचा top-1 agreement UD-Q2_K_XL मध्ये 90.390 percent आणि UD-IQ1_S मध्ये 78.875 percent पर्यंत कमी होतो. यापैकी कोणतेही single card वर बसत नाही.

Kimi K3 API पेक्षा GPUs भाड्याने घेणे स्वस्त आहे का?

फक्त जास्त आणि सातत्यपूर्ण volume असल्यास. प्रति GPU hour 2.50 USD गृहीत धरल्यास, सतत सुरू असलेल्या 8 GPU node ची किंमत दरमहा 14,400 USD येते. याच रकमेत प्रकाशित केलेल्या 15.00 USD per million या दराने सुमारे 960 million output tokens मिळतात. याशिवाय idle hours, weights downloads आणि cluster चालू ठेवणाऱ्या व्यक्तीचा खर्च द्यावा लागतो. Burst workload साठी GPUs hourly rent करा. अंदाजाऐवजी स्वतः मोजलेल्या token volume शी तुलना करा.

वेगासाठी 104B active parameters याचा अर्थ काय?

याचा अर्थ प्रत्येक token साठी लागणारी arithmetic ही 104B model इतकी असते. त्यामुळे throughput 2.8T class ऐवजी 104B class मध्ये येतो. याचा memory शी संबंध नाही. सर्व 2.8T parameters memory मध्ये resident राहतात, कारण router कोणत्याही token साठी कोणत्याही expert ला call करू शकतो. Tokens per second चा अंदाज घेण्यासाठी active count वापरा. VRAM चे sizing करण्यासाठी total count वापरा.

हा लेख उपयुक्त होता का?

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