Kimi K3 کو خود host کرنے کے لیے کیا درکار ہے؟
Kimi K3 کے 2.8 ٹریلین parameters کے لیے VRAM حساب، KV cache کی ریاضی، اور 32 GPU cluster کے بغیر اسے چلانے کے 3 قابلِ عمل طریقے جانیں۔
Kimi K3 کو self-host کرنے کے لیے کیا درکار ہے
Kimi K3 کو self-host کرنے کے لیے 2.8 ٹریلین parameters کے لیے گنجائش درکار ہے۔ Moonshot نے open weights کو MXFP4 میں جاری کیا، جس میں ہر weight تقریباً نصف byte کا ہوتا ہے۔ اس لیے صرف weights ہی تقریباً 1.4 TB بنتے ہیں، اس سے پہلے کہ cache کے لیے ایک بھی token مختص کیا جائے۔ آج دستیاب کوئی بھی accelerator اتنی گنجائش اکیلے فراہم نہیں کرتا۔ ایک GPU کے لیے جواب نہیں ہے۔ ایک server کے لیے جواب ہاں ہے، اور اس کی دو صورتیں ہیں۔ پہلی صورت 288 GB accelerators والا 8-GPU node ہے، جسے شائع شدہ کم سے کم multi-user serving recipes استعمال کرتی ہیں۔ دوسری صورت تقریباً 1.6 TB کی مجموعی RAM اور VRAM والی ایک machine ہے، جو GPU کے ساتھ یا اس کے بغیر Unsloth کے lossless Q8 GGUF کو llama.cpp میں چلاتی ہے اور ایک وقت میں ایک user کو serve کرتی ہے۔
یہ فیصلہ ہے۔ ذیل کی تمام معلومات اسی کے پیچھے موجود arithmetic بیان کرتی ہیں، کیونکہ یہی arithmetic آپ اگلی release پر دوبارہ استعمال کریں گے۔ 16 July 2026 کو اعلان کے بعد کے ہفتوں میں کئی infrastructure vendors نے K3 deployment guides شائع کیں، اور ہر guide نے یہ فرض کیا کہ آپ کے پاس پہلے سے cluster موجود ہے۔ یہ صفحہ دوسری سمت سے آغاز کرتا ہے: اس کی لاگت کیا ہے، اس کے بجائے آپ کیا چلا سکتے ہیں، اور یہ کیسے معلوم کریں کہ آپ ان دونوں میں سے کس صورت میں ہیں۔
کل parameters اور active parameters کی تعداد یکساں نہیں ہے
K3 ایک mixture of experts ماڈل ہے۔ MoE (mixture of experts) نیٹ ورک کو متعدد sub-networks میں تقسیم کرتا ہے اور router کو اجازت دیتا ہے کہ وہ ہر token کے لیے ان میں سے چند sub-networks منتخب کرے۔ Model card میں 2.8T total parameters اور ہر token کے لیے 104B activated parameters درج ہیں۔ یہ parameters 896 routed experts میں تقسیم ہیں، جن میں سے ہر token کے لیے 16 experts فعال ہوتے ہیں، اور یہ عمل 93 layers میں ہوتا ہے۔
یہ دونوں parameter counts مختلف سوالات کے جواب دیتے ہیں، اور انہیں ایک دوسرے کی جگہ استعمال کرنا ہر "can I run this" thread میں سب سے عام غلطی ہے۔
Active parameters compute cost طے کرتے ہیں۔ ہر token تقریباً 104B parameters سے گزرتا ہے، اس لیے متوقع throughput، 2.8T ماڈل کے بجائے 104B dense model جیسا ہوگا۔ MoE بنانے کی بنیادی وجہ یہی ہے۔
Total parameters memory cost طے کرتے ہیں۔ Router کسی بھی token کے لیے کوئی بھی expert منتخب کر سکتا ہے، اس لیے پہلی request آنے سے پہلے ہر expert کو کسی تیز storage میں محفوظ کرنا ضروری ہے۔ صرف hot experts کو VRAM میں رکھنا اور باقی experts کو ضرورت کے وقت fetch کرنا ممکن ہے۔ llama.cpp کا --moe-cache-mib ایسا ہی کرتا ہے: یہ ان experts کے لیے GPU cache رکھتا ہے جو بصورت دیگر system RAM میں موجود ہوتے ہیں، اور router کے انتخاب پر missing experts کو upload کرتا ہے۔ تاہم اس سے total parameters کم نہیں ہوتے۔ باقی experts کو پھر بھی RAM میں رکھنا پڑتا ہے، اور PCIe link کی رفتار HBM کی terabytes per second رفتار کے مقابلے میں صرف tens of gigabytes per second ہوتی ہے، اس لیے ہر cache miss وقت لیتا ہے۔ اگر model RAM میں بھی نہ سما سکے اور experts کو NVMe سے stream کرنا پڑے تو رفتار مزید کم ہو جاتی ہے۔ Unsloth کی K3 guide بھی خبردار کرتی ہے کہ disk offloading بہت کم رفتار سے چلتی ہے۔
لہذا compute کرنا نسبتاً سستا، لیکن store کرنا مہنگا ہے۔ Hardware کو 2.8T کے حساب سے منتخب کریں۔ اپنی speed expectations کو 104B کے حساب سے رکھیں۔
وزن کے لحاظ سے بائٹس، اور یہ ٹیرا بائٹس کہاں سے آتے ہیں
weights کی تعداد کو ہر weight کے بائٹس سے ضرب دیں۔ weights کے لیے مکمل فارمولا یہی ہے۔
اس چارٹ کے پیچھے کا ڈیٹا
[
{
"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 کو quantisation-aware طریقے سے train کیا گیا تھا اور اسے MXFP4 weights اور MXFP8 activations کے ساتھ release کیا گیا، اس لیے 4-bit row ہی اصل row ہے۔ اس کے اوپر والی rows scale دکھانے کے لیے ہیں: bf16 میں یہی model 5.6 TB درکار کرتا۔ MXFP4 ہر 32 weights کے block کے لیے ایک مشترک 8-bit scale بھی store کرتا ہے، جس سے تقریباً 6 فیصد اضافہ ہوتا ہے۔ مزید یہ کہ Moonshot کی config attention، shared experts اور vision tower کو 4-bit format سے باہر رکھتی ہے۔ اسی لیے Unsloth کی گنتی کے مطابق پورا checkpoint صاف 1.4 TB کے بجائے تقریباً 1.56 TB بنتا ہے۔
اس سے عام متبادل راستہ محدود ہوتا ہے، لیکن مکمل طور پر بند نہیں ہوتا۔ جاری کیا گیا checkpoint پہلے ہی 4-bit ہے، اس لیے آسان بچت پہلے ہی حاصل کی جا چکی ہے، لیکن مزید کم quantisation کرنے سے یہ عدد پھر بھی تبدیل ہوتا ہے۔ 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 فیصد، 711.1 GB والے UD-IQ2_XXS پر 84.127 فیصد، اور UD-IQ1_S پر 78.875 فیصد ہے۔ اس کے Hugging Face repo میں 1-bit کی مزید چھوٹی files بھی موجود ہیں، جو UD-Q1_0 کے لیے 466 GB تک جاتی ہیں، لیکن ان کے ساتھ agreement کا کوئی figure شائع نہیں کیا گیا۔ یہ accuracy میں قابلِ پیمائش کمی ہے، اور سب سے چھوٹی file بھی سب سے بڑے single card سے تقریباً 1.6 گنا بڑی ہے۔
Kimi K3 کے لیے کتنے GPUs درکار ہیں
اس چارٹ کے پیچھے کا ڈیٹا
[
{
"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 کے لیے گنجائش شامل نہیں۔ GPUs کی تقسیم کا برابر ہونا بھی ضروری نہیں۔ 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 میں H100 configuration شامل ہے، جو چار 8-GPU nodes، یعنی 32 GPUs اور مجموعی طور پر 2,560 GB memory، سے بنتی ہے۔ یہ 18 cards کی کم از کم حد کے مقابلے میں ہے۔ اسی cookbook میں single-node recipes بھی درج ہیں: ایک 8-GPU B300 node اور ایک 8-GPU MI350X یا MI355X node، جہاں ہر card کے لیے 288 GB اور مجموعی طور پر 2,304 GB دستیاب ہیں۔ کم از کم حد سے زیادہ یہ اضافی وسائل ضائع نہیں ہوتے۔ یہ KV cache، activation memory، اور اس headroom کے لیے درکار ہوتے ہیں جس سے server ایک وقت میں متعدد requests کو batch کر سکتا ہے۔ سب سے کم memory والے، 5 GB300 class cards، عملی طور پر اسی نوعیت کے 8-GPU node تک round up ہوتے ہیں۔ یہی سب سے چھوٹی machine ہے جس کے لیے کسی نے multi-user K3 serving recipe شائع کی ہے۔
KV cache وہ حصہ ہے جو اکثر لوگوں کو حیران کرتا ہے
Weights ایک مقررہ لاگت ہیں۔ KV (key value) cache مقررہ نہیں ہے: یہ context length کے ساتھ بڑھتا ہے اور ہر concurrent user کے ساتھ دوبارہ بڑھتا ہے۔ عام attention کے لیے formula bytes per token = 2 * layers * kv_heads * head_dim * bytes_per_element ہے، پھر اسے context length اور concurrency سے multiply کیا جاتا ہے۔
یہ ایک عملی مثال ہے، اور صرف مثال ہے: 64 layers، 8 KV heads، head dimension 128، fp8۔ اس سے 2 64 8 128 1 = 131,072 bytes حاصل ہوتے ہیں، یعنی ہر token کے لیے 128 KiB۔
اس چارٹ کے پیچھے کا ڈیٹا
[
{
"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 پر ایک user کی لاگت 128 GiB ہے۔ یہ ایک conversation کے لیے 288 GB card کا تقریباً نصف بنتا ہے، اور اس میں ایک بھی weight load ہونے سے پہلے کی حالت شامل ہے۔
K3 عام attention استعمال نہیں کرتا، اور آخری عدد اس کی وجہ واضح کرتا ہے۔ اس کی 93 layers میں 69 KDA (Kimi Delta Attention) layers اور 24 Gated MLA (multi-head latent attention) layers شامل ہیں۔ KDA ایسے cache کے بجائے fixed size recurrent state برقرار رکھتا ہے جو ہر token کے ساتھ بڑھتا ہے، جبکہ MLA key اور value کو ایک low rank latent vector میں compress کرتا ہے۔ اس لیے حقیقی per-token لاگت عملی مثال سے کافی کم ہو جاتی ہے۔ Moonshot کی شائع کردہ config.json میں اس latent کا size 512 کا kv_lora_rank اور 64-wide rotary key (qk_rope_head_dim) دیا گیا ہے، یعنی ہر MLA layer میں ہر token کے لیے 576 values۔ 24 layers میں ہر value کے لیے 2 bytes کے حساب سے یہ 27,648 bytes بنتے ہیں، یعنی تقریباً 27 KiB فی token، یا مکمل 1,048,576 token conversation کے لیے تقریباً 27 GiB، اس کے علاوہ fixed KDA state۔ اسے measurement کے بجائے estimate سمجھیں: engines cache کو اپنے طریقے سے pad اور lay out کرتے ہیں، اور 8-bit cache اسے تقریباً نصف کر دیتا ہے۔
اپنی deployment میں موجود مقدار دیکھنے کے لیے --max-model-len بڑھاتے ہوئے nvidia-smi کو monitor نہ کریں۔ vLLM اپنے KV cache pool کو پہلے سے allocate کرتا ہے۔ اس کا size --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 رپورٹ کرتا ہے۔
اس reasoning کا بنیادی انداز اگلی release میں بھی برقرار رہے گا۔ اگر کوئی model million token context کا اعلان کرے اور اپنی attention design کے بارے میں کچھ نہ بتائے تو cache کو binding constraint سمجھیں، جب تک کوئی اس کے برعکس ثابت نہ کر دے۔
درجہ 1: کلسٹر فی گھنٹہ کرائے پر لیں
یہ وہ درجہ ہے جس میں K3 کی جاری کردہ precision پر بیک وقت متعدد صارفین کو سروس دی جاتی ہے۔ کافی RAM والی ایک مشین بھی Unsloth کے Q8 GGUF کے ذریعے K3 کو اس کی جاری کردہ precision پر چلا سکتی ہے۔ Unsloth اسے full precision lossless کہتا ہے، لیکن اس طریقے میں ایک وقت میں صرف ایک صارف کو سروس دی جاتی ہے اور اس کا احاطہ درجہ 2 میں ہے۔ یہاں آپ hardware نہیں خریدتے۔ آپ اسے مطلوبہ گھنٹوں کے لیے کرائے پر لیتے ہیں اور کام مکمل ہونے کے بعد بند کر دیتے ہیں۔
اس چارٹ کے پیچھے کا ڈیٹا
[
{
"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 نہیں۔ on-demand rates provider اور GPU generation کے لحاظ سے بہت مختلف ہوتی ہیں۔ single-node recipes کے لیے درکار 288 GB parts کی فی گھنٹہ لاگت H100 سے زیادہ ہوتی ہے، جبکہ reserved capacity سستی ہوتی ہے۔ اپنے provider کی حقیقی شرح لے کر ضرب دوبارہ کریں: GPUs × hours × 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 شامل کریں: tensor parallel کے لیے SGLang --tp-size، pipeline parallel کے لیے --pp-size، اور expert parallel کے لیے --ep-size لیتا ہے۔ tensor parallel کو pipeline parallel سے ضرب دینے پر حاصل ہونے والی تعداد آپ کے actual GPUs کے برابر ہونی چاہیے۔ expert parallel اسی group کے اندر experts تقسیم کرتا ہے، اسی لیے 32 GPU H100 recipe میں --tp-size 32 اور --ep-size 32 دونوں set کیے گئے ہیں۔
حقیقی traffic بھیجنے سے پہلے تصدیق کریں کہ server start ہو چکا ہے:
curl http://127.0.0.1:30000/v1/modelsصحت مند server model id کی فہرست رکھنے والے JSON object کے ساتھ جواب دیتا ہے۔ Connection refused کا مطلب ہے کہ process ابھی weights load کر رہا ہے یا پہلے ہی exit ہو چکا ہے، اس لیے دوبارہ کوشش کرنے سے پہلے server log پڑھیں۔
ابتدائی ہفتوں میں عام failure یہ تھا کہ runtime model سے پرانا تھا۔ K3، KDA اور ایک نئی MoE layer کے ساتھ جاری ہوا تھا، لیکن stable vLLM اور SGLang releases میں launch کے وقت یہ شامل نہیں تھے۔ اس کی علامت startup کے دوران server کا ایسی line کے ساتھ exit ہونا ہے جس کی شکل Model architectures [...] are not supported for now جیسی ہو۔ کوئی config change اسے درست نہیں کر سکتی، کیونکہ ان layers کو چلانے والا code آپ کی build میں موجود نہیں ہے۔ اس کے بعد صورت حال بدل گئی ہے: 27 October 2026 تک SGLang اپنی releases میں v0.5.17 سے K3 support شامل کر رہا ہے، v0.5.22 تازہ ترین ہے، اور vLLM کی v0.28.0 سے v0.32.0 تک کی release notes میں K3 سے متعلق کام شامل ہے۔ موجودہ release install کریں۔ کچھ hardware-specific paths اب بھی dedicated image کا نام دیتے ہیں، مثلاً Blackwell کے لیے SGLang کی NVFP4 builds، اس لیے اپنے card کی recipe چیک کریں۔
لاگت کے بارے میں ایک اہم بات ہے جو اکثر نظر انداز ہو جاتی ہے۔ meter instance کے start ہوتے ہی چلنا شروع ہو جاتا ہے، model کے ready ہونے پر نہیں۔ 1.56 TB download کو 1 GB/s رفتار پر مکمل ہونے میں تقریباً 26 منٹ لگتے ہیں، اور اس دوران cluster time خرچ ہوتا ہے، پہلے token سے پہلے بھی۔ weights کو ایسی volume پر stage کریں جو instance کے بعد بھی برقرار رہے، تاکہ دوسری run چند منٹ میں شروع ہو جائے۔
درجہ 2: ایک accelerator پر چھوٹا model چلائیں
اس درجہ میں آپ K3 نہیں چلا رہے۔ شروع کرنے سے پہلے یہ بات واضح طور پر کہہ دیں، کیونکہ "run K3 locally" کے بارے میں زیادہ تر مباحثے اسی مقام پر یہ تسلیم کیے بغیر ختم ہو جاتے ہیں۔
فٹ ہونے کا اصول وہی formula ہے، مگر چھوٹے پیمانے پر: parameters کو فی weight bytes سے ضرب دیں، پھر KV cache اور runtime overhead کے تقریباً 2 GB شامل کریں۔ حاصل شدہ مقدار آپ کی VRAM سے کم ہونی چاہیے۔ 4-bit پر یہ تقریباً فی parameter آدھا byte بنتا ہے، جس سے یہ موزوں جوڑے حاصل ہوتے ہیں:
- 16 GB card: طویل context کی گنجائش کے ساتھ 4-bit پر 7B model
- 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 درکار ہوتا ہے۔ یہی وہ trade-off ہے جسے Ollama کی NUM_PARALLEL اور MAX_QUEUE settings آپ کے لیے parallel slots، queued requests اور باقی دستیاب VRAM کے درمیان طے کرتی ہیں۔
ایک طریقہ ہے جس سے K3 خود ایک single large machine پر چل سکتا ہے، اور یہ درجہ اس سے پچھلے درجہ اور آخری درجہ کے درمیان آتا ہے۔ Unsloth، llama.cpp میں K3 کے GGUF builds دستاویز کرتا ہے، جن میں 1-bit اور 2-bit quantisations سے لے کر UD-Q8_K_XL تک builds شامل ہیں۔ وہ UD-Q8_K_XL کو full precision lossless قرار دیتا ہے اور NVIDIA DGX Station کو ایسا hardware بتاتا ہے جو انہیں چلا سکتا ہے۔ اس کا عمومی اصول یہ ہے کہ RAM اور VRAM کا مجموعہ تقریباً quant size کے برابر ہو۔ یہ مقدار 1-bit UD-IQ1_S build کے لیے تقریباً 610 GB سے Q8 کے لیے تقریباً 1.6 TB تک ہے۔ اس سے کم memory ہونے پر model disk پر fallback کرتا ہے اور رفتار نمایاں طور پر کم ہو جاتی ہے۔ GPU اختیاری ہے: Unsloth کی build instructions میں CUDA کو اس صورت میں off کیا جاتا ہے کہ "if you don't have a GPU or just want CPU inference"۔ 1-bit اور 2-bit builds، K3 کے heavily quantised builds ہیں، اور ان کی accuracy کی قیمت وہی ہے جو اوپر بیان کی گئی ہے۔ Q8 build، K3 کو اس کی released precision پر چلاتا ہے اور ایک user کو RAM speed پر serve کرتا ہے۔ دونوں میں سے کوئی بھی چھوٹا model نہیں ہے۔
کام کرنے والا server حاصل کرنے کا مختصر ترین طریقہ GPU سے منسلک VPS پر Ollama چلانا ہے:
curl -fsSL https://ollama.com/install.sh | sh
ollama run qwen3:14bollama run پہلی بار استعمال پر model download کرتا ہے، پھر آپ کو prompt پر لے آتا ہے۔ جو tag موجود نہ ہو وہ Error: model "..." not found واپس کرتا ہے، اس لیے tags کو memory سے ٹائپ کرنے کے بجائے library page سے copy کریں۔ مکمل walkthrough، جس میں systemd unit اور remote access بھی شامل ہیں، VPS پر Ollama چلانے میں موجود ہے۔
llama.cpp آپ کو quantisation اور offload پر زیادہ control دیتا ہے:
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 کیے گئے ہیں۔ جو layers system RAM میں چلے جاتے ہیں وہ HBM bandwidth کے بجائے RAM bandwidth پر چلتے ہیں، اس لیے جیسے ہی model پوری طرح fit ہونا بند ہوتا ہے، generation speed تقریباً ایک order of magnitude کم ہو جاتی ہے۔ دونوں tools کے trade-offs Ollama اور llama.cpp کا بالمقابل جائزہ میں بیان کیے گئے ہیں۔
درجہ 3: hosted API، self-hosted orchestration
اس چارٹ کے پیچھے کا ڈیٹا
[
{
"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 ایک JSON object واپس کرتی ہے جس میں choices array ہوتا ہے۔ 401 کا مطلب ہے کہ authentication ناکام ہوئی ہے: تصدیق کریں کہ key درست ہے، expired یا disabled نہیں، اور header میں key سے پہلے Authorization: Bearer درج ہے۔ 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 خرید سکتی ہے۔ لاگت کے لحاظ سے فائدہ حاصل کرنے کے لیے آپ کو ماہانہ تقریباً 1 billion output tokens، یعنی روزانہ تقریباً 30 million، generate کرنے ہوں گے اور cluster کو پورا وقت مصروف رکھنا ہوگا، کیونکہ idle GPUs پر بھی busy GPUs جیسی ہی rate سے billing ہوتی ہے۔ Prompt-heavy agent workloads میں یہ حد مزید دور چلی جاتی ہے: بار بار استعمال ہونے والا context cache-hit rate یعنی 0.30 USD فی million پر bill ہوتا ہے، نہ کہ cache-miss rate یعنی 3.00 USD پر۔
اس tier میں آپ model کے گرد موجود تمام اجزا self-host کرتے ہیں: ایسا gateway جو API key محفوظ رکھتا ہے تاکہ وہ کبھی client تک نہ پہنچے، request اور response logs، retries، rate limits، اور فی user budgets۔ یہ سب ایک چھوٹے VPS پر چلتا ہے، جس میں GPU بالکل نہیں ہوتا۔ یہی تقسیم closed weights پر بھی لاگو ہوتی ہے، جہاں Claude کی self-hosting model level پر ممکن نہیں اور صرف orchestration آپ کے اختیار میں رہتی ہے۔
کون سا serving stack کس tier سے تعلق رکھتا ہے
vLLM اور SGLang جیسے servers tier 1 سے تعلق رکھتے ہیں۔ یہ بیک وقت بہت سی requests serve کرنے کے لیے بنائے گئے ہیں۔ ان میں 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، اور کم concurrency کے لیے بنائے گئے ہیں۔ llama.cpp ایک بہت بڑے MoE کو اس طرح load کر سکتا ہے کہ expert weights system RAM میں رکھے جائیں (--cpu-moe یا --n-cpu-moe)، اور --moe-cache-mib کے ساتھ استعمال ہونے والے experts کو GPU پر cache کیا جائے۔ Unsloth کی K3 GGUF builds ایک ہی machine پر اسی طرح چلتی ہیں۔ اس کے بعد speed کا انحصار RAM bandwidth اور router کے cache miss ہونے کی frequency پر ہوتا ہے۔ اگر file، RAM اور VRAM کے مجموعے سے بڑی ہو تو باقی حصہ disk پر چلا جاتا ہے۔ یہ ایک user کے لیے قابلِ عمل setup ہے۔ یہ ایسی service نہیں جس پر بہت سے users کو چلایا جا سکے۔ مکمل موازنہ Ollama بمقابلہ vLLM میں ہے، اور model بدلنے سے اصول نہیں بدلتا: ہمیشہ یہ سوال ہوتا ہے کہ آپ shared hardware پر بہت سے users کو serve کر رہے ہیں یا اپنی machine پر ایک user کو۔
وہ چار اعداد جو اس مرحلے سے آگے بھی اہم رہتے ہیں
- کل parameters کو فی weight bytes سے ضرب دینے پر کم از کم درکار memory ملتی ہے۔ shipped precision پر اس سے کم memory میں کچھ نہیں چلتا، اور 4-bit release سے بھی کم quantisation کرنے پر accuracy کی قیمت کے بدلے زیادہ سے زیادہ تقریباً 70 فیصد memory بچتی ہے، نہ کہ ایک order of magnitude۔
- Active parameters throughput class متعین کرتے ہیں۔ 104B active parameters والا 2.8T MoE، 104B model کی طرح compute کرتا ہے۔
- فی token KV cache کو context length اور concurrency سے ضرب دینے پر وہ لاگت ملتی ہے جو weights کی لاگت ادا کرنے کے بعد بھی بڑھتی رہتی ہے۔
- 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 کے مطابق مکمل 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 تقریباً 1.4 TB ہیں۔ حتیٰ کہ K3 کی سب سے چھوٹی شائع شدہ quantisation، یعنی Unsloth کی 466 GB UD-Q1_0 فائل، بھی بڑے پیمانے پر دستیاب accelerators میں سب سے بڑے accelerator کی 288 GB گنجائش سے تقریباً 1.6 گنا زیادہ ہے۔ llama.cpp experts کو system RAM میں رکھ کر active experts کو GPU پر cache کر سکتا ہے، لیکن اس کے لیے بھی تقریباً quant size کے برابر RAM کے علاوہ VRAM درکار ہوتی ہے۔ اس سے کم memory ہونے پر model disk پر منتقل ہو جاتا ہے اور بہت سست چلتا ہے۔ سب سے چھوٹی شائع شدہ serving recipes میں B300 یا MI350X/MI355X cards کا ایک 8-GPU node استعمال ہوتا ہے، جبکہ H100 recipe میں 32 GPUs استعمال ہوتے ہیں۔
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 مجموعی memory والی 32 GPU H100 configuration بھی شامل ہے۔ اس لیے weights کے figure کو کم از کم ضرورت سمجھیں، مکمل requirement نہیں۔
کیا quantisation سے Kimi K3 ایک node میں آ سکتا ہے؟
فراہم کردہ 4-bit checkpoint ایک node میں آ جاتا ہے، بشرطیکہ اس node میں 288 GB کے آٹھ cards ہوں۔ یہی cards SGLang کی B300 اور MI355X recipes میں استعمال ہوتے ہیں۔ Unsloth کے lossless Q8 GGUF کے ذریعے یہ تقریباً 1.6 TB RAM اور VRAM والی ایک machine میں بھی چل سکتا ہے۔ کم quantisation چھوٹی machines کے لیے مددگار ہے۔ Unsloth کی measured dynamic GGUF builds میں 2-bit پر 861.3 GB سے 1-bit پر 594 GB تک کے files شامل ہیں۔ اس کی repo میں 466 GB تک کی 1-bit files بھی درج ہیں، جبکہ lossless size تقریباً 1.56 TB ہے۔ accuracy کی قیمت بھی measured ہے: full model کے ساتھ top-1 agreement UD-Q2_K_XL پر 90.390 percent اور UD-IQ1_S پر 78.875 percent تک گر جاتا ہے۔ ان میں سے کوئی بھی ایک card پر fit نہیں ہوتا۔
کیا Kimi K3 API کے مقابلے میں GPUs کرائے پر لینا سستا ہے؟
صرف زیادہ اور مستقل volume پر۔ اگر فی GPU hour لاگت 2.50 USD فرض کی جائے تو ہمیشہ چلنے والے 8 GPU node کی ماہانہ لاگت 14,400 USD ہوگی۔ اسی رقم سے شائع شدہ شرح 15.00 USD فی million output tokens کے حساب سے تقریباً 960 million output tokens خریدے جا سکتے ہیں۔ اس کے علاوہ idle hours، weights downloads اور cluster کو فعال رکھنے والے فرد کی لاگت بھی شامل ہوتی ہے۔ bursts کے لیے GPUs فی گھنٹہ کرائے پر لیں، اور اندازے کے بجائے اپنی measured token volume سے موازنہ کریں۔
رفتار کے لیے 104B active parameters کا کیا مطلب ہے؟
اس کا مطلب ہے کہ ہر token کے لیے arithmetic ایک 104B model جتنی ہے۔ اس لیے throughput 2.8T class کے بجائے 104B class میں رہتا ہے۔ اس سے memory کے بارے میں کچھ معلوم نہیں ہوتا۔ تمام 2.8T parameters memory میں موجود رہتے ہیں، کیونکہ router کسی بھی token کے لیے کسی بھی expert کو call کر سکتا ہے۔ tokens per second کا اندازہ لگانے کے لیے active count استعمال کریں، اور VRAM کا سائز طے کرنے کے لیے total count استعمال کریں۔