SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-30

Kimi K3 ను స్వయంగా హోస్ట్ చేయడానికి ఎంత VRAM కావాలి?

Kimi K3లో 2.8 ట్రిలియన్ parameters ఉన్నాయి. MXFP4 weights, VRAM arithmetic, KV cache math, అలాగే 32 GPU cluster లేకుండా నడిపే మూడు వాస్తవ మార్గాలు తెలుసుకోండి.

Kimi K3 ను స్వయంగా హోస్ట్ చేయడానికి అవసరమైన వనరులు

Kimi K3 ను స్వయంగా హోస్ట్ చేయాలంటే 2.8 ట్రిలియన్ parameters కు స్థలం కల్పించాలి. Moonshot, సుమారు ఒక్క weight కు అర byte చొప్పున ఉండే MXFP4 లో open weights ను విడుదల చేసింది. కాబట్టి ఒక్క token cache ను కూడా కేటాయించే ముందు weights‌కే సుమారుగా 1.4 TB అవసరం. ప్రస్తుతం విక్రయంలో ఉన్న ఏ accelerator కూడా ఈ మొత్తాన్ని ఒక్కదానిపై ఉంచలేరు. ఒక్క GPU విషయంలో సమాధానం లేదు. ఒక్క server విషయంలో రెండు విధానాల్లో సమాధానం ఉంది. మొదటిది, ఒక్కో accelerator కు 288 GB సామర్థ్యం కలిగిన 8-GPU node. ప్రచురించబడిన అతి చిన్న multi-user serving recipes ఉపయోగించేది ఇదే. రెండవది, మొత్తం RAM మరియు VRAM కలిపి సుమారు 1.6 TB కలిగిన ఒక machine. ఇందులో GPU ఉన్నా లేకపోయినా llama.cpp లో Unsloth యొక్క lossless Q8 GGUF ను నడిపించి, ఒకేసారి ఒక్క user కు సేవ అందించవచ్చు.

ఇదే తుది నిర్ణయం. కింద ఉన్నది దాని వెనుకనున్న లెక్కలు. ఎందుకంటే తదుపరి release లో మీరు మళ్లీ ఉపయోగించేది ఈ లెక్కలనే. 16 July 2026న ప్రకటన వెలువడిన తర్వాతి వారాల్లో అనేక infrastructure vendors K3 deployment guides ను ప్రచురించాయి. అయితే ప్రతి guide కు మీరు ఇప్పటికే ఒక cluster కలిగి ఉన్నారని ఊహించింది. ఈ పేజీ దీనికి విరుద్ధమైన దిశ నుంచి ప్రారంభమవుతుంది: దీనికి ఎంత ఖర్చవుతుంది, దాని బదులుగా మీరు ఏమి నడపవచ్చు, అలాగే మీరు ఆ రెండు విధానాల్లో ఏదిలో ఉన్నారో ఎలా గుర్తించాలి.

మొత్తం parameters సంఖ్య మరియు క్రియాశీల parameters సంఖ్య ఒకేలా ఉండవు

K3 అనేది mixture of experts model. MoE (mixture of experts) నెట్‌వర్క్‌ను అనేక sub-networkలుగా విభజిస్తుంది. ప్రతి token కోసం వాటిలో కొన్నింటిని router ఎంచుకునేలా చేస్తుంది. Model cardలో మొత్తం 2.8T parameters మరియు ప్రతి tokenకు activated అయ్యే 104B parameters ఉన్నట్లు పేర్కొంది. ఇవి 896 routed expertsలో నుంచి ప్రతి tokenకు 16 experts పనిచేసే విధంగా, 93 layers అంతటా అమలవుతాయి.

ఈ రెండు parameter సంఖ్యలు వేర్వేరు ప్రశ్నలకు సమాధానాలు ఇస్తాయి. వాటిని పరస్పరం మార్చడం ప్రతి "can I run this" చర్చలో కనిపించే అత్యంత సాధారణ తప్పు.

Active parameters compute costను నిర్ణయిస్తాయి. ప్రతి token సుమారు 104B parameters ద్వారా గణించబడుతుంది. అందువల్ల మీరు ఆశించాల్సిన throughput 2.8T model కంటే 104B dense model throughputకు దగ్గరగా ఉంటుంది. MoE నిర్మాణాన్ని ఉపయోగించడానికి ఇదే ప్రధాన కారణం.

Total parameters memory costను నిర్ణయిస్తాయి. ఏ tokenకైనా router ఏ expertనైనా ఎంచుకోవచ్చు. కాబట్టి మొదటి request రాకముందే ప్రతి expertను వేగవంతమైన నిల్వలో ఉంచాలి. తరచుగా ఉపయోగించే expertsను మాత్రమే VRAMలో ఉంచి, మిగిలిన వాటిని అవసరమైనప్పుడు తెచ్చుకునే విధానం ఉంది. llama.cpp యొక్క --moe-cache-mib, system RAMలో ఉండే experts కోసం GPU cacheను నిర్వహిస్తుంది. Router వాటిని ఎంచుకున్నప్పుడు cacheలో లేని expertsను upload చేస్తుంది. అయితే ఇది మొత్తం పరిమాణాన్ని తగ్గించదు. మిగిలిన experts RAMలోనే ఉండాలి. PCIe link ప్రతి సెకనుకు కొన్ని దశాబ్దాల gigabytesను మాత్రమే తరలిస్తుంది, HBM ప్రతి సెకనుకు terabytes స్థాయిలో dataను తరలిస్తుంది. అందువల్ల ప్రతి cache missకు సమయం పడుతుంది. Model RAMలో సరిపోకపోతే expertsను NVMe నుంచి stream చేయడం ఇంకా నెమ్మదిగా ఉంటుంది. Disk offloading చాలా నెమ్మదిగా నడుస్తుందని Unsloth యొక్క K3 guide హెచ్చరిస్తుంది.

కాబట్టి compute చేయడం తక్కువ ఖర్చుతో కూడుకున్నది, కానీ నిల్వ చేయడం ఖరీదైనది. Hardwareను 2.8T ఆధారంగా ఎంచుకోండి. Speedపై మీ అంచనాలను 104B ఆధారంగా రూపొందించండి.

బరువుకు బైట్లు, టెరాబైట్లు ఎక్కడి నుంచి వస్తాయి

Parameter count ను ఒక్కో weight కు అవసరమైన bytes తో గుణిస్తే సరిపోతుంది. Weights కోసం మొత్తం formula ఇదే.

చార్ట్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 ను quantisation-aware పద్ధతిలో train చేసి, MXFP4 weights మరియు MXFP8 activations తో release చేశారు. అందువల్ల 4-bit వరుసే వాస్తవికమైనది. దాని పైనున్న వరుసలు పోలిక కోసం మాత్రమే ఉన్నాయి: bf16 వద్ద ఇదే model కు 5.6 TB అవసరమవుతుంది. ప్రతి 32 weights గల block కు MXFP4 ఒకే shared 8-bit scale ను కూడా నిల్వ చేస్తుంది. దీనివల్ల సుమారు 6 శాతం అదనంగా చేరుతుంది. అలాగే Moonshot config లో attention, shared experts మరియు vision tower ను 4-bit format నుంచి మినహాయించారు. అందువల్ల Unsloth లెక్క ప్రకారం పూర్తి checkpoint పరిమాణం సుమారు 1.56 TB అవుతుంది. ఇది ఖచ్చితమైన 1.4 TB కాదు.

దీనివల్ల సాధారణంగా ఉపయోగించే తగ్గింపు మార్గం పరిమితమవుతుంది, కానీ పూర్తిగా మూసుకుపోదు. విడుదలైన checkpoint ఇప్పటికే 4-bit లో ఉంది. కాబట్టి సులభంగా పొందగలిగే storage saving ఇప్పటికే తీసుకున్నారు. అయినప్పటికీ ఇంకా తక్కువ bit format కు మారితే పరిమాణం తగ్గుతుంది. 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 ప్రచురించింది: పూర్తి 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 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 కోసం అవసరమైన స్థలం ఇందులో ఉండదు. ఈ విభజన సమానంగా ఉండాల్సిన అవసరం లేదు. vLLM యొక్క pipeline parallelism మోడల్‌ను layers ఆధారంగా విభజిస్తుంది మరియు అసమాన విభజనలకు మద్దతు ఇస్తుంది. SGLang యొక్క K3 prefill recipes 93 layers పై 8 మరియు 16 pipeline stages ను అమలు చేస్తాయి.

ప్రచురించిన మార్గదర్శకాలు ఈ కనీస పరిమితికంటే ఎక్కువ వనరులను సూచిస్తున్నాయి. Moonshot విడుదల మార్గదర్శకాల్లో 64 లేదా అంతకంటే ఎక్కువ accelerators కలిగిన supernode ను సిఫార్సు చేసింది. 27 October 2026 నాటికి, SGLang cookbook నాలుగు 8-GPU nodes, మొత్తం 32 GPUs మరియు 2,560 GB aggregate memory తో రూపొందించిన H100 configuration ను అందిస్తుంది. ఇది 18 cards తో ఉన్న కనీస పరిమితికంటే ఎక్కువ. అలాగే ఒక 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 కలిగిన అనుకూలమైన row, ఆచరణలో అదే తరహా 8-GPU node వరకు round up అవుతుంది. Multi-user K3 serving recipe ను ప్రచురించిన వారిలో ఇదే అత్యల్ప సామర్థ్యం కలిగిన machine.

KV cache ఆశ్చర్యానికి గురిచేసే భాగం

Weights ఒక స్థిరమైన ఖర్చు. KV (key value) cache అలా కాదు: ఇది context length పెరిగే కొద్దీ, అలాగే concurrent users సంఖ్య పెరిగే కొద్దీ పెరుగుతుంది. సాధారణ attention కోసం formula bytes per token = 2 * layers * kv_heads * head_dim * bytes_per_element. తరువాత దాన్ని context length మరియు concurrencyతో గుణించాలి.

ఇదిగో ఒక worked example. ఇది కేవలం ఉదాహరణ మాత్రమే: 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 అవసరం. ఒక్క conversationకే 288 GB cardలో దాదాపు సగం వినియోగమవుతుంది. ఒక్క weight కూడా load చేయకముందే ఇది జరుగుతుంది.

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 ఖర్చు ఈ worked example కంటే చాలా తక్కువగా ఉంటుంది. Moonshot ప్రచురించిన config.json ప్రకారం ఆ latent పరిమాణం 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, అంటే ప్రతి tokenకు సుమారు 27 KiB. పూర్తి 1,048,576 token conversationకు ఇది సుమారు 27 GiB అవుతుంది. దీనికి fixed KDA state అదనం. దీన్ని measurementగా కాక estimateగా పరిగణించాలి. Engines cacheను తమ స్వంత విధానాల్లో pad చేసి layout చేస్తాయి. 8-bit cache దీనిని సుమారు సగానికి తగ్గిస్తుంది.

మీ deploymentలో ఎంత cache ఉందో తెలుసుకోవడానికి --max-model-len పెంచుతున్నప్పుడు nvidia-smi ను monitor చేయవద్దు. vLLM తన KV cache poolను ముందుగానే allocate చేస్తుంది. ఆ pool పరిమాణం --gpu-memory-utilization నుండి వస్తుంది (ప్రస్తుత docsలో defaultగా 0.92) లేదా explicit per-GPU cache budget నుండి వస్తుంది. అందువల్ల మొత్తం GPU memory ఒక conversationను కాకుండా poolను చూపిస్తుంది. బదులుగా startup logను చదవండి. అక్కడ vLLM KV cache పరిమాణాన్ని tokensలో, అలాగే మీ context length వద్ద maximum concurrencyని చూపిస్తుంది.

తదుపరి release వచ్చినా ఈ reasoning విధానం మారదు. ఏదైనా model million token contextను ప్రకటించి, తన attention design గురించి ఏమీ చెప్పకపోతే, వేరే విషయం నిరూపించబడే వరకు cacheనే ప్రధాన పరిమితిగా పరిగణించండి.

టైర్ 1: క్లస్టర్‌ను గంటల ప్రాతిపదికన అద్దెకు తీసుకోవడం

అనేక మంది వినియోగదారులకు ఒకేసారి K3 విడుదలైన ఖచ్చితత్వంతో సేవలు అందించేది ఈ టైర్. తగినంత RAM ఉన్న ఒకే మెషీన్‌లో Unsloth యొక్క Q8 GGUF ద్వారా K3 ను విడుదలైన ఖచ్చితత్వంతో నడపవచ్చు. Unsloth దీన్ని పూర్తి ఖచ్చితత్వం, నష్టం లేనిది అని పేర్కొంటుంది. అయితే ఆ విధానంలో ఒకేసారి ఒక వినియోగదారుకే సేవ అందుతుంది. దాని వివరాలు టైర్ 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"
  }
]

ఈ rate ఒక అంచనా మాత్రమే; ఇది quote కాదు. Provider మరియు GPU generation ఆధారంగా on-demand rates విస్తృతంగా మారుతాయి. Single-node recipes కు అవసరమైన 288 GB భాగాల hourly cost, H100 కంటే ఎక్కువ. Reserved capacity చౌకగా ఉంటుంది. మీ provider ఇచ్చే నిజమైన సంఖ్యను తీసుకుని గణనను మళ్లీ చేయండి: GPUs times hours times rate. Chart ఉద్దేశం నిష్పత్తిని చూపడం. రోజుకు నాలుగు గంటలు 8 GPU node ను burst చేయడం వల్ల నెలకు 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 commands లో ఏదీ నేరుగా అమలు చేయరు. మీ hardware కు సరిపోయే parallelism flags ను జోడించండి: tensor parallel కోసం SGLang --tp-size ను, pipeline parallel కోసం --pp-size ను, expert parallel కోసం --ep-size ను స్వీకరిస్తుంది. Tensor parallel ను 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 సమయానికి ఇవి అందుబాటులో లేవు. దీని లక్షణం startup సమయంలో server exit అవుతూ Model architectures [...] are not supported for now వంటి line చూపించడం. Configuration మార్చడం వల్ల ఇది పరిష్కారం కాదు, ఎందుకంటే ఆ layers ను నడిపే code మీ build లో లేదు. అప్పటి నుంచి పరిస్థితి మారింది: 27 October 2026 నాటికి SGLang releases లో v0.5.17 నుంచి K3 support ఉంది. తాజా version v0.5.22. vLLM యొక్క v0.28.0 నుంచి v0.32.0 వరకు release notes అన్నింటిలోనూ K3 కు సంబంధించిన పని ఉంది. ప్రస్తుత release ను install చేయండి. కొన్ని hardware-specific paths ఇప్పటికీ ప్రత్యేక image ను సూచిస్తాయి. ఉదాహరణకు Blackwell కోసం SGLang యొక్క NVFP4 builds ఉన్నాయి. కాబట్టి మీ card కోసం ఉన్న recipe ను తనిఖీ చేయండి.

ఖర్చుకు సంబంధించిన ఒక విషయం తరచుగా గుర్తించబడదు. Meter instance ప్రారంభమైనప్పుడు మొదలవుతుంది; model ready అయినప్పుడు కాదు. 1 GB/s వేగంతో 1.56 TB download చేయడానికి మొదటి token రావడానికి ముందు cluster time లో సుమారు 26 నిమిషాలు పడుతుంది. Instance కంటే ఎక్కువ కాలం నిలిచే volume పై weights ను ముందుగానే stage చేయండి. అప్పుడు రెండో run నిమిషాల్లో ప్రారంభమవుతుంది.

Tier 2: ఒక accelerator పై చిన్న model ను నడపడం

ఈ tier లో మీరు K3 ను నడపడం లేదు. ప్రారంభించే ముందు దీన్ని స్పష్టంగా చెప్పండి. ఎందుకంటే “K3 locally ను నడపడం” గురించి ఉన్న చాలా చర్చలు ఈ దశలోనే ముగుస్తాయి, కానీ దాన్ని అంగీకరించవు.

Fit నియమం అదే formula యొక్క చిన్న రూపం: parameters × ప్రతి weight కు bytes, దానికి KV cache మరియు సుమారు 2 GB runtime overhead కలపాలి. మొత్తం మీ VRAM పరిమితిలో ఉండాలి. 4-bit వద్ద ప్రతి parameter కు సుమారు అర byte అవసరం. అందువల్ల ఈ జతలు సౌకర్యవంతంగా సరిపోతాయి:

  • 16 GB card: 4-bit లో 7B model, long 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 తరగతి MoE

పైన పేర్కొన్న ప్రతి జత ఒకేసారి ఒక request ను మాత్రమే అనుమానిస్తుంది. రెండో వ్యక్తి prompt పంపిన వెంటనే, ప్రతి concurrent slot కు స్వంత KV cache అవసరం అవుతుంది. మీకు మిగిలిన VRAM మరియు parallel slots, queued requests మధ్య trade-off ను Ollama యొక్క NUM_PARALLEL మరియు MAX_QUEUE settings మీ కోసం నిర్వహిస్తాయి.

ఒకే పెద్ద machine పై K3 ను నడపడానికి ఒక మార్గం ఉంది. ఇది ఈ tier మరియు చివరి tier మధ్యలో ఉంటుంది. Unsloth, llama.cpp కోసం K3 యొక్క GGUF builds ను documents చేస్తుంది. ఇవి 1-bit మరియు 2-bit quantisations నుంచి UD-Q8_K_XL వరకు ఉంటాయి. UD-Q8_K_XL ను ఇది full precision lossless గా పేర్కొంటుంది. వీటిని నడపగల hardware గా NVIDIA DGX Station ను కూడా పేర్కొంటుంది. దాని సాధారణ నియమం ప్రకారం RAM + VRAM మొత్తం quant size కు సుమారుగా సమానంగా ఉండాలి. 1-bit UD-IQ1_S build కు సుమారు 610 GB నుంచి Q8 కు సుమారు 1.6 TB వరకు అవసరం. దీనికంటే తక్కువ memory ఉంటే model disk కు fallback అవుతుంది, వేగం తీవ్రంగా తగ్గుతుంది. GPU తప్పనిసరి కాదు. GPU లేకపోయినా లేదా CPU inference మాత్రమే కావాలనుకున్నా CUDA ను off చేయడానికి Unsloth build instructions సూచిస్తాయి. 1-bit మరియు 2-bit builds అనేవి K3 యొక్క heavily quantised రూపాలు. దీనివల్ల accuracy తగ్గుతుంది. Q8 build అనేది K3 విడుదలైన precision తో ఉండే రూపం. ఇది ఒక 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 ను చదవండి. Offload చేసిన layers సంఖ్య అందులో కనిపిస్తుంది. System RAM లోకి spill అయ్యే layers, HBM bandwidth బదులుగా RAM bandwidth వద్ద నడుస్తాయి. అందువల్ల model పూర్తిగా fit కాకపోయిన వెంటనే generation speed ఒక order of magnitude తగ్గుతుంది. ఈ రెండు tools మధ్య trade-offs 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 సరైనదేనా, అది 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 ఖర్చవుతుంది. ఒక్కో million output tokens కు 15.00 USD చొప్పున అదే మొత్తంతో API నుంచి సుమారు 960 million output tokens పొందవచ్చు. ఖర్చు పరంగా self-hosting ప్రయోజనకరంగా ఉండాలంటే నెలకు దాదాపు ఒక billion output tokens, అంటే రోజుకు సుమారు 30 million tokens, generate చేయాలి. అలాగే cluster మొత్తం సమయం busy గా ఉండాలి. ఎందుకంటే idle GPUs కు కూడా busy GPUs తో సమానమైన రేటుతో billing జరుగుతుంది. Prompt-heavy agent workloads లో ఈ break-even point ఇంకా దూరమవుతుంది. Repeated context కు cache-hit rate వద్ద ఒక్కో million కు 0.30 USD చెల్లించాలి; cache-miss rate వద్ద మాత్రం ఒక్కో million కు 3.00 USD చెల్లించాలి.

ఈ స్థాయిలో మీరు self-host చేసేది model చుట్టూ ఉన్న మిగతా వ్యవస్థ: API key client కు ఎప్పటికీ చేరకుండా ఉంచే gateway, request మరియు response logs, retries, rate limits, అలాగే ప్రతి user కు budgets. ఇవన్నీ GPU లేని చిన్న VPS పై నడపవచ్చు. Closed weights కు కూడా ఇదే విభజన వర్తిస్తుంది. అక్కడ model స్థాయిలో Claude ను self-host చేయడం సాధ్యం కాదు. మీరు స్వంతంగా నిర్వహించగలిగేది orchestration మాత్రమే.

ఏ సేవా stack ఏ tierకు చెందుతుంది

vLLM మరియు SGLang తరగతికి చెందిన servers tier 1కు చెందుతాయి. ఇవి continuous batching మరియు paged KV cacheతో ఒకేసారి అనేక requestsను అందించడానికి రూపొందించబడ్డాయి. అదనంగా tensor parallelism మరియు expert parallelismను అనేక nodesలో విస్తరించగలవు. ఇవి datacentre accelerators మరియు వాటి మధ్య వేగవంతమైన interconnect ఉన్నాయని భావిస్తాయి. ఒకే consumer cardపై వీటిని install చేయడం క్లిష్టంగా ఉంటుంది. మీరు గమనించేంత అదనపు ప్రయోజనం కూడా సాధారణంగా ఉండదు.

llama.cpp మరియు Ollama tier 2కు చెందుతాయి. ఇవి ఒక machine, GGUF quantisation, model సరిపోనప్పుడు CPU offload, మరియు తక్కువ concurrency కోసం ఉద్దేశించబడ్డాయి. llama.cpp expert weightsను system RAMలో ఉంచి భారీ MoEను load చేయగలదు (--cpu-moe లేదా --n-cpu-moe). --moe-cache-mibతో అది ఉపయోగించే expertsను GPUలో cache చేస్తుంది. Unsloth యొక్క K3 GGUF builds ఒకే machineపై పనిచేసే విధానం ఇదే. తరువాత speed RAM bandwidthపై, అలాగే router cacheలో miss అయ్యే తరచుదనంపై ఆధారపడుతుంది. File పరిమాణం RAM మరియు VRAM మొత్తం కంటే ఎక్కువైతే, అది diskకు వెళ్తుంది. ఒక user కోసం ఇది ఉపయోగించగల setup. అనేక usersకు అందించగల serviceగా దీనిని ఉపయోగించలేరు. పూర్తి పోలిక Ollama మరియు vLLM పోలికలో ఉంది. Model మారినా ఇది మారదు: shared hardwareపై అనేక usersకు service అందిస్తున్నారా, లేక మీ స్వంత hardwareపై ఒక userకు మాత్రమే service అందిస్తున్నారా అన్నదే ఎల్లప్పుడూ ప్రశ్న.

ఈ checkpoint ను దాటి నిలిచే నాలుగు సంఖ్యలు

  1. మొత్తం parameters ను ఒక్కో weight కు అవసరమైన bytes తో గుణిస్తే కనీస memory అవసరం లభిస్తుంది. విడుదలైన precision వద్ద దీనికంటే తక్కువ memoryతో ఏదీ నడవదు. 4-bit release కంటే దిగువకు quantise చేస్తే accuracy తగ్గుదలతో గరిష్ఠంగా సుమారు 70 శాతం memory ఆదా అవుతుంది; పదింతల తగ్గుదల మాత్రం రాదు.
  2. Active parameters throughput తరగతిని నిర్ణయిస్తాయి. 104B active parameters ఉన్న 2.8T MoE, 104B model లాగానే compute చేస్తుంది.
  3. ఒక్కో token కు KV cache అవసరం, దాన్ని context length మరియు concurrency తో గుణించాలి. Weights కోసం ఇప్పటికే చెల్లించిన తర్వాత కూడా నిరంతరం పెరుగుతూ ఉండే ఖర్చు ఇదే.
  4. ఒక్క dollar కు tokens per second మాత్రమే ఏ tier ఎంచుకోవాలో నిర్ణయించే సంఖ్య. పైవన్నీ దీనికి inputs.

ఈ నాలుగింటిని ఏ releaseకైనా వర్తింపజేస్తే vendor guide తెరవకముందే సరైన సమాధానం లభిస్తుంది. తదుపరి release ఇప్పటికే ప్రకటించబడింది: Moonshot, K3 ఆధారంగా మరింత post-training చేసిన K3.1 Pro ను 23 October 2026న Kimi Codeలో విడుదల చేసింది. దీని API quickstart ప్రకారం పూర్తి weights 4 November నాటికి విడుదల అవుతాయి. తరువాత మీరు రాసే ప్రతి figureకు date చేర్చండి. K3 విడుదలైన తరువాతి రెండు వారాల్లో prices మరియు supported-architecture lists రెండూ మారాయి. ఈ పేజీలోని launch figures July 2026లో ప్రచురించబడ్డాయి. Serving recipes, runtime releases మరియు quantisation numbers ను 27 October 2026న మళ్లీ పరిశీలించారు.

FAQ

నేను ఒకే GPUపై Kimi K3ను నడపవచ్చా?

లేదు. Moonshot విడుదల చేసిన MXFP4 precisionలో weights పరిమాణం సుమారు 1.4 TB ఉంటుంది. K3 కోసం ప్రచురించిన అతి చిన్న quantisation అయిన Unsloth యొక్క 466 GB UD-Q1_0 file కూడా విస్తృతంగా లభించే అతిపెద్ద acceleratorsలోని 288 GB కంటే సుమారు 1.6 రెట్లు పెద్దది. llama.cpp experts ను system RAMలో ఉంచి, active experts ను GPUలో cache చేయగలదు. అయినప్పటికీ RAMలో quant sizeకు, దానికి అదనంగా 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 ప్రారంభ మార్గదర్శకంలో 64 లేదా అంతకంటే ఎక్కువ acceleratorsను సిఫారసు చేసింది. 27 October 2026 నాటికి SGLang cookbookలో 8 B300 లేదా 8 MI350X/MI355X cardsతో ఒకే node recipes, మొత్తం 2,304 GB memoryతో, అలాగే మొత్తం 2,560 GB memoryతో 32 GPU H100 configuration ప్రచురించబడ్డాయి. అందువల్ల weights పరిమాణాన్ని అవసరమైన పరిమితిగా కాకుండా కనీస అంచనాగా పరిగణించండి.

Quantisation వల్ల Kimi K3 ఒకే nodeలో సరిపోతుందా?

విడుదల చేసిన 4-bit checkpoint ఒక nodeలో సరిపోతుంది, అయితే ఆ nodeలో 288 GB memory కలిగిన ఎనిమిది cards ఉండాలి. SGLang యొక్క B300 మరియు MI355X recipes ఇదే configurationను ఉపయోగిస్తాయి. 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 వరకు ఉంటాయి. దాని repoలో 466 GB వరకు తగ్గిన 1-bit files కూడా ఉన్నాయి. Lossless పరిమాణం సుమారు 1.56 TB. Accuracyపై ప్రభావం కొలవబడింది: పూర్తి modelతో top-1 agreement UD-Q2_K_XL వద్ద 90.390 percentకు, UD-IQ1_S వద్ద 78.875 percentకు పడిపోతుంది. వీటిలో ఏదీ ఒకే cardలో సరిపోదు.

Kimi K3 API కంటే GPUs అద్దెకు తీసుకోవడం చౌకగా ఉంటుందా?

అధికంగా మరియు నిరంతరంగా ఉండే volume ఉన్నప్పుడు మాత్రమే. GPUకు గంటకు 2.50 USD అని అనుకుంటే, ఎల్లప్పుడూ నడిచే 8 GPU nodeకు నెలకు 14,400 USD ఖర్చవుతుంది. అదే మొత్తంతో ప్రచురించిన ప్రతి million tokensకు 15.00 USD రేటు వద్ద సుమారు 960 million output tokens పొందవచ్చు. Idle hours, weights downloads మరియు clusterను నిరంతరం నిర్వహించే వ్యక్తి ఖర్చులు కూడా ఉంటాయి. తాత్కాలిక అధిక workload కోసం గంటల వారీగా అద్దెకు తీసుకోండి. అంచనాకు బదులుగా మీరు కొలిచిన token volumeతో పోల్చండి.

104B active parameters వల్ల speedపై ఏమి ప్రభావం ఉంటుంది?

ప్రతి tokenకు అవసరమైన arithmetic 104B model స్థాయిలో ఉంటుందని దీని అర్థం. అందువల్ల throughput 2.8T classలో కాకుండా 104B classలో ఉంటుంది. ఇది memory గురించి ఏమీ చెప్పదు. Router ఏ tokenకైనా ఏ expertనైనా పిలవగలదు కాబట్టి మొత్తం 2.8T parameters memoryలోనే residentగా ఉంటాయి. Tokens per secondను అంచనా వేయడానికి active countను ఉపయోగించండి. VRAM పరిమాణాన్ని నిర్ణయించడానికి total countను ఉపయోగించండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

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