SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-30

Kimi K3-ஐ self-host செய்வது எப்படி? முழுமையான வழிகாட்டி

2.8 டிரில்லியன் parameters கொண்ட Kimi K3 மாடலை இயக்குவதற்கான VRAM மற்றும் KV cache கணக்கீடுகளை அறியுங்கள். 32 GPU கிளஸ்டர் இன்றி இதை இயக்க உதவும் மூன்று நடைமுறை வழிகளைப் பாருங்கள்.

Kimi K3-ஐ self-host செய்வதற்குத் தேவையானவை

Kimi K3-ஐ self-host செய்வது என்பது 2.8 டிரில்லியன் parameters-க்கு இடம் கண்டறிவதாகும். Moonshot இதன் open weights-ஐ MXFP4 வடிவில் வெளியிட்டுள்ளது. இது ஒரு weight-க்கு சுமார் அரை byte அளவு என்பதால், நீங்கள் ஒரு token cache-ஐ ஒதுக்குவதற்கு முன்பே, weights மட்டுமே தோராயமாக 1.4 TB ஆகிறது. தற்போது விற்பனையில் உள்ள எந்தவொரு accelerator-ம் இதைத் தனியாகத் தாங்காது. ஒரு GPU-வில் இதை இயக்க முடியாது. ஒரு server-ல் இதை இரண்டு வழிகளில் இயக்கலாம். முதலாவது, 288 GB accelerators கொண்ட 8-GPU node; இதுவே வெளியிடப்பட்ட மிகச்சிறிய multi-user serving முறைகளில் பயன்படுத்தப்படுகிறது. இரண்டாவது, சுமார் 1.6 TB combined RAM மற்றும் VRAM கொண்ட ஒரு machine; இது llama.cpp-ல் Unsloth-ன் lossless Q8 GGUF-ஐ, GPU இருந்தாலும் இல்லாவிட்டாலும், ஒரு நேரத்தில் ஒரு பயனருக்குச் சேவை செய்யும் வகையில் இயக்குகிறது.

இதுவே இறுதி முடிவு. கீழே உள்ளவை இதற்கான கணக்கீடுகள்; ஏனெனில் அடுத்த release-ல் நீங்கள் மீண்டும் இதையே பயன்படுத்த வேண்டியிருக்கும். ஜூலை 16, 2026 அன்று அறிவிப்பு வெளியான சில வாரங்களில் பல உள்கட்டமைப்பு விற்பனையாளர்கள் K3 deployment வழிகாட்டிகளை வெளியிட்டனர், அவை ஒவ்வொன்றும் உங்களிடம் ஏற்கனவே ஒரு cluster இருப்பதாகவே கருதுகின்றன. இந்தப் பக்கம் மறுமுனையிலிருந்து தொடங்குகிறது: இதற்கு எவ்வளவு செலவாகும், அதற்குப் பதிலாக எதை இயக்கலாம், மற்றும் நீங்கள் எந்த நிலையில் இருக்கிறீர்கள் என்பதை எப்படி அறிவது என்பது பற்றி விளக்குகிறது.

Total parameters மற்றும் active parameters ஒரே எண்ணாக இருக்காது

K3 என்பது mixture of experts model ஆகும். MoE (mixture of experts) network-ஐ பல sub-networks-ஆகப் பிரிக்கிறது. ஒவ்வொரு token-க்கும் அவற்றில் சிலவற்றை router தேர்வு செய்கிறது. Model card-ல் 2.8T total parameters என்றும், ஒவ்வொரு token-க்கும் 104B activated parameters என்றும் குறிப்பிடப்பட்டுள்ளது. இதில் 896 routed experts உள்ளன; ஒவ்வொரு token-க்கும் அவற்றில் 16 experts செயல்படும். இந்த அமைப்பு 93 layers முழுவதும் பயன்படுத்தப்படுகிறது.

இந்த இரண்டு parameter எண்ணிக்கைகளும் வெவ்வேறு கேள்விகளுக்குப் பதிலளிக்கின்றன. “இதை இயக்க முடியுமா?” என்ற ஒவ்வொரு விவாதத்திலும், இவற்றை மாற்றிப் புரிந்துகொள்வதே மிகவும் பொதுவான தவறாகும்.

Active parameters compute cost-ஐ நிர்ணயிக்கின்றன. ஒவ்வொரு token-மும் சுமார் 104B parameters வழியாகக் கணக்கிடப்படுகிறது. எனவே எதிர்பார்க்க வேண்டிய throughput, 2.8T dense model-ஐ விட 104B dense model-ஐப் போன்றதாக இருக்கும். MoE உருவாக்கப்படுவதற்கான முக்கிய காரணம் இதுவே.

Total parameters memory cost-ஐ நிர்ணயிக்கின்றன. எந்த token-க்கும் router எந்த expert-ஐ வேண்டுமானாலும் தேர்வு செய்யலாம். ஆகவே முதல் request வருவதற்கு முன் ஒவ்வொரு expert-மும் வேகமாக அணுகக்கூடிய storage-ல் வைக்கப்பட்டிருக்க வேண்டும். பயன்பாட்டில் உள்ள experts-ஐ மட்டும் VRAM-ல் வைத்து, மீதியை தேவைக்கேற்ப பெறும் முறையும் உள்ளது: llama.cpp-ன் --moe-cache-mib, இல்லையெனில் system RAM-ல் இருக்கும் experts-க்காக GPU cache-ஐ பராமரிக்கிறது. Router தேர்வு செய்யும் missing experts-ஐ அது upload செய்கிறது. ஆனால் இது total size-ஐ குறைக்காது. மீதமுள்ள experts RAM-ல் தொடர்ந்து இருக்க வேண்டும். மேலும், HBM-ன் terabytes per second bandwidth-க்கு மாறாக PCIe link-ன் வேகம் tens of gigabytes per second மட்டுமே. எனவே ஒவ்வொரு cache miss-க்கும் நேரம் செலவாகும். Model RAM-ல் பொருந்தாததால் experts-ஐ NVMe-ல் இருந்து stream செய்வது இதைவிடவும் மெதுவாக இருக்கும். Disk offloading மிகவும் மெதுவாக இயங்கும் என்று Unsloth-ன் K3 guide எச்சரிக்கிறது.

எனவே compute செய்ய இது குறைந்த செலவுடையது; store செய்ய அதிக memory தேவைப்படும். Hardware-ஐ 2.8T அடிப்படையில் தேர்வு செய்யுங்கள். Speed குறித்த எதிர்பார்ப்புகளை 104B அடிப்படையில் அமைக்கவும்.

எடைக்கான பைட்டுகள் மற்றும் டெராபைட்டுகள் எங்கிருந்து வருகின்றன

அளவுருக்களின் எண்ணிக்கை பெருக்கல் எடைக்கான பைட்டுகள். எடைகளைப் பொறுத்தவரை, இதுவே முழுமையான சூத்திரம்.

விளக்கப்படம்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-ஐ உணர்ந்து பயிற்சி அளிக்கப்பட்டது. இது MXFP4 எடைகள் மற்றும் MXFP8 ஆக்டிவேஷன்களுடன் வெளியிடப்பட்டது, எனவே 4-bit வரிசையே உண்மையானது. அதற்கு மேல் உள்ள வரிசைகள் ஒப்பீட்டிற்காக வழங்கப்பட்டுள்ளன: bf16 வடிவில் அதே மாடலுக்கு 5.6 TB தேவைப்படும். MXFP4 ஒவ்வொரு 32 எடைகள் கொண்ட தொகுப்பிற்கும் ஒரு பகிரப்பட்ட 8-bit அளவுகோலைச் சேமிக்கிறது, இது சுமார் 6 சதவீதம் கூடுதல் இடத்தைப் பிடிக்கும். மேலும், Moonshot-ன் உள்ளமைவு attention, பகிரப்பட்ட experts மற்றும் vision tower ஆகியவற்றை 4-bit வடிவத்திலிருந்து விலக்கி வைக்கிறது. இதனால், Unsloth-ன் கணக்கீட்டின்படி முழுமையான checkpoint சுமார் 1.56 TB ஆக உள்ளது, இது வெறும் 1.4 TB ஆக இல்லை.

இது வழக்கமான தப்பிக்கும் வழியை முழுமையாக மூடாமல் சுருக்குகிறது. வெளியிடப்பட்ட checkpoint ஏற்கனவே 4-bit வடிவில் இருப்பதால், எளிதான சேமிப்பு ஏற்கனவே செய்யப்பட்டுவிட்டது. இருப்பினும், இன்னும் குறைவான பிட் அளவிற்குச் செல்வது அளவை மாற்றும். 27 அக்டோபர் 2026 நிலவரப்படி, Unsloth அளவீடு செய்த K3-ன் dynamic GGUF quantisations, 2-bit UD-Q2_K_XL-க்கு 861.3 GB முதல் 1-bit UD-IQ1_S-க்கு 594 GB வரை உள்ளன. இதற்கான விலையை Unsloth வெளியிடுகிறது: முழு மாடலுடன் top-1 token உடன்பாடு UD-Q2_K_XL-ல் 90.390 சதவீதமாகவும், 711.1 GB UD-IQ2_XXS-ல் 84.127 சதவீதமாகவும், UD-IQ1_S-ல் 78.875 சதவீதமாகவும் உள்ளது. அதன் Hugging Face repo-வில் சிறிய 1-bit கோப்புகளும் உள்ளன, அவை UD-Q1_0-க்கு 466 GB வரை குறைகின்றன, ஆனால் அவற்றுடன் எந்த உடன்பாட்டு புள்ளிவிவரமும் வெளியிடப்படவில்லை. இது அளவிடக்கூடிய துல்லிய இழப்பாகும், மேலும் மிகச்சிறிய கோப்பு கூட மிகப்பெரிய ஒற்றை கார்டின் கொள்ளளவை விட சுமார் 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, அல்லது ஒரே நேரத்தில் வரும் இரண்டாவது கோரிக்கைக்கான இடம் இதில் அடங்காது. பிரிவினை சமமாக இருக்க வேண்டிய அவசியமில்லை: vLLM-ன் pipeline parallelism மாதிரியை அடுக்குகளாகப் பிரிக்கிறது மற்றும் சமமற்ற பிரிவினைகளை ஆதரிக்கிறது. SGLang-ன் K3 prefill முறைகள் 93 அடுக்குகளில் 8 மற்றும் 16 pipeline நிலைகளை இயக்குகின்றன.

வெளியிடப்பட்ட வழிகாட்டுதல்கள் இந்த குறைந்தபட்ச அளவை விட அதிகமாகவே உள்ளன. Moonshot-ன் வெளியீட்டு வழிகாட்டுதல் 64 அல்லது அதற்கு மேற்பட்ட accelerators கொண்ட supernode-ஐப் பரிந்துரைத்தது. 27 October 2026 நிலவரப்படி, SGLang cookbook நான்கு 8-GPU nodes, அதாவது 32 GPU-க்கள் மற்றும் 2,560 GB மொத்த நினைவகம் கொண்ட H100 கட்டமைப்பை வழங்குகிறது. இது 18 கார்டுகள் என்ற குறைந்தபட்ச அளவை விட அதிகம். மேலும், இது ஒரு 8-GPU B300 node மற்றும் ஒரு 8-GPU MI350X அல்லது MI355X node (ஒவ்வொரு கார்டிற்கும் 288 GB வீதம் 2,304 GB) ஆகியவற்றில் இயங்கும் single-node முறைகளையும் பட்டியலிடுகிறது. குறைந்தபட்ச அளவை விட இந்த கூடுதல் திறன் வீணானதல்ல. இது KV cache, activation memory மற்றும் ஒரே நேரத்தில் பல கோரிக்கைகளைச் செயலாக்க server-க்குத் தேவையான கூடுதல் இடமாகும். மிகவும் பொருத்தமான வரிசையான 5 GB300 வகை கார்டுகள், நடைமுறையில் சரியாக 8-GPU node-ஆக மாற்றப்படுகின்றன. இதுவே பல பயனர்கள் பயன்படுத்தும் K3 serving முறைக்கு வெளியிடப்பட்ட மிகச்சிறிய machine ஆகும்.

KV cache என்பது பலருக்கும் ஆச்சரியத்தை ஏற்படுத்தும் பகுதி

Weights என்பது நிலையான செலவு. KV (key value) cache அப்படியல்ல: அது context length அதிகரிக்கும்போது வளர்கிறது. ஒரே நேரத்தில் பயன்படுத்தும் users எண்ணிக்கை அதிகரிக்கும்போதும் அது மீண்டும் வளர்கிறது. சாதாரண attention-க்கு formula 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 தேவைப்படும். ஒரே 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-ஆகச் சுருக்குகிறது. எனவே உண்மையான token ஒன்றுக்கான செலவு மேலுள்ள எடுத்துக்காட்டைவிட மிகவும் குறையும். Moonshot வெளியிட்ட config.json-ல் அந்த latent-ன் அளவு kv_lora_rank 512 ஆகவும், 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 ஆகும். இதனுடன் நிலையான KDA state-ம் சேரும். இதை அளவீடாக அல்ல, estimate-ஆகக் கருதவும். Engines cache-ஐ தங்களது சொந்த முறைகளில் padding செய்து layout செய்யும். 8-bit cache பயன்படுத்தினால் இந்த அளவு சுமார் பாதியாகும்.

உங்கள் சொந்த deployment எவ்வளவு cache-ஐ வைத்திருக்கிறது என்பதைப் பார்க்க, --max-model-len-ஐ அதிகரிக்கும்போது nvidia-smi-ஐ monitor செய்ய வேண்டாம். vLLM தனது KV cache pool-ஐ முன்கூட்டியே allocate செய்கிறது. அதன் அளவு --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 என்று கருதவும்.

Tier 1: மணிநேர அடிப்படையில் cluster-ஐ வாடகைக்கு எடுத்தல்

ஒரே நேரத்தில் பல பயனர்களுக்கு K3-ஐ அதன் வெளியிடப்பட்ட துல்லியத்தில் (shipped precision) வழங்கும் அடுக்கு இதுவாகும். போதுமான RAM கொண்ட ஒரு machine-ல், Unsloth-ன் Q8 GGUF மூலம் K3-ஐ அதன் முழு துல்லியத்தில் (full precision lossless) இயக்க முடியும்; ஆனால் அந்த முறை ஒரு நேரத்தில் ஒரு பயனருக்கு மட்டுமே சேவை செய்யும், அது tier 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"
  }
]

இந்தக் கட்டணம் ஒரு தோராயமான மதிப்பீடு மட்டுமே, இது இறுதி விலை அல்ல. On-demand கட்டணங்கள் வழங்குநரைப் பொறுத்தும், GPU தலைமுறையைப் பொறுத்தும் மாறுபடும். ஒற்றை-node (single-node) கட்டமைப்பிற்குத் தேவையான 288 GB வசதி கொண்ட பாகங்கள் H100-ஐ விட அதிக மணிநேரக் கட்டணத்தைக் கொண்டிருக்கலாம், அதே சமயம் reserved capacity மலிவானது. உங்கள் வழங்குநரின் உண்மையான கட்டணத்தைப் பயன்படுத்தி கணக்கீட்டை மீண்டும் செய்யவும்: GPUs எண்ணிக்கை பெருக்கல் மணிநேரம் பெருக்கல் கட்டணம். இந்த அட்டவணையின் நோக்கம் விகிதத்தை (ratio) விளக்குவதே ஆகும். ஒரு நாளைக்கு நான்கு மணிநேரம் 8 GPU node-ஐப் பயன்படுத்துவது மாதத்திற்கு 2,400 USD செலவாகும், அதே சமயம் SGLang-க்கு ஏற்ற 32 GPU H100 கட்டமைப்பைத் தொடர்ந்து இயக்குவது 57,600 USD செலவாகும்.

இரண்டு பிரதான server-களும் 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

இந்த அடிப்படை command-களை அப்படியே ஒரு உண்மையான cluster-ல் இயக்கக்கூடாது. உங்கள் hardware-க்கு ஏற்றவாறு parallelism flags-களைச் சேர்க்கவும்: SGLang-ல் tensor parallel-க்கு --tp-size, pipeline parallel-க்கு --pp-size மற்றும் expert parallel-க்கு --ep-size பயன்படுத்தப்படுகின்றன. Tensor parallel மற்றும் pipeline parallel ஆகியவற்றின் பெருக்கற்பலன், உங்களிடம் உள்ள GPU-களின் எண்ணிக்கைக்குச் சமமாக இருக்க வேண்டும். Expert parallel என்பது அந்த குழுவிற்குள் உள்ள நிபுணர்களைப் பிரிக்கும், அதனால்தான் 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-ஐ ஏற்றிக்கொண்டிருக்கிறது அல்லது ஏற்கனவே வெளியேறிவிட்டது என்று பொருள், எனவே மீண்டும் முயற்சிக்கும் முன் server log-ஐப் படிக்கவும்.

தொடக்க வாரங்களில் பொதுவாக ஏற்பட்ட தோல்வி, model-ஐ விட பழைய runtime-ஐப் பயன்படுத்தியதுதான். K3, KDA மற்றும் புதிய MoE layer-உடன் வெளியிடப்பட்டது; இவை stable vLLM மற்றும் SGLang வெளியீடுகளில் தொடக்கத்தில் இல்லை. இதன் அறிகுறி, server தொடங்கும்போதே Model architectures [...] are not supported for now என்ற வடிவிலான வரியுடன் வெளியேறுவதாகும். எந்தவொரு config மாற்றமும் இதைச் சரிசெய்யாது, ஏனெனில் அந்த layer-களை இயக்குவதற்கான code உங்கள் build-ல் இல்லை. இது இப்போது மாறியுள்ளது: 27 October 2026 நிலவரப்படி, SGLang v0.5.17 முதல் K3 ஆதரவைக் கொண்டுள்ளது (v0.5.22 சமீபத்தியது), மேலும் vLLM-ன் v0.28.0 முதல் v0.32.0 வரையிலான வெளியீட்டுக் குறிப்புகள் அனைத்தும் K3 தொடர்பான பணிகளை உள்ளடக்கியுள்ளன. தற்போதைய வெளியீட்டை நிறுவவும். சில hardware-குறிப்பிட்ட பாதைகள் இன்னும் பிரத்யேக image-ஐக் குறிப்பிடுகின்றன, உதாரணமாக Blackwell-ல் SGLang-ன் NVFP4 builds, எனவே உங்கள் card-க்கான செய்முறையைச் சரிபார்க்கவும்.

பயனர்களைப் பாதிக்கும் ஒரு செலவு குறிப்பு: model தயாராகும்போது அல்ல, instance தொடங்கும்போதே கட்டணம் கணக்கிடத் தொடங்குகிறது. 1 GB/s வேகத்தில் 1.56 TB தரவிறக்கம் செய்ய, முதல் token-க்கு முன்பே சுமார் 26 நிமிடங்கள் cluster நேரம் செலவாகும். Instance-ஐ விட அதிக காலம் நீடிக்கும் volume-ல் weights-ஐச் சேமித்து வைக்கவும், அப்போதுதான் இரண்டாவது முறை சில நிமிடங்களில் தொடங்கும்.

Tier 2: ஒரு accelerator-ல் சிறிய model-ஐ இயக்குதல்

இந்த நிலையில் நீங்கள் K3-ஐ இயக்கவில்லை. இதைத் தொடங்குவதற்கு முன்பே தெளிவாகப் புரிந்துகொள்ளுங்கள், ஏனெனில் "K3-ஐ உள்ளூர் கணினியில் இயக்குவது" குறித்த பெரும்பாலான விவாதங்கள் இதை ஒப்புக்கொள்ளாமலேயே முடிந்துவிடுகின்றன.

பொருந்தும் விதி (fit rule) சிறிய அளவில் அதே சூத்திரம்தான்: 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

மேலே உள்ள ஒவ்வொரு இணைப்பும் ஒரு நேரத்தில் ஒரு கோரிக்கையை மட்டுமே கருதுகிறது. இரண்டாவது நபர் prompt அனுப்பும் தருணத்தில், ஒவ்வொரு concurrent slot-க்கும் அதன் சொந்த KV cache தேவைப்படும். இதுவே Ollama-வின் NUM_PARALLEL மற்றும் MAX_QUEUE அமைப்புகள் parallel slots, வரிசைப்படுத்தப்பட்ட கோரிக்கைகள் மற்றும் உங்களிடம் மீதமுள்ள VRAM ஆகியவற்றுக்கு இடையே செய்யும் சமரசமாகும்.

K3-ஐ ஒரு பெரிய machine-ல் இயக்குவதற்கு ஒரு வழி உள்ளது, அது இந்த நிலைக்கும் முந்தைய நிலைக்கும் இடையில் அமைகிறது. Unsloth, llama.cpp-ல் K3-ன் GGUF builds-ஐ ஆவணப்படுத்துகிறது. இவை 1-bit மற்றும் 2-bit quantisations முதல் UD-Q8_K_XL வரை உள்ளன; இதை அது full precision lossless என்று குறிப்பிடுகிறது. மேலும், இதை இயக்கக்கூடிய வன்பொருளாக NVIDIA DGX Station-ஐக் குறிப்பிடுகிறது. இதன் பொதுவான விதி என்னவென்றால், RAM மற்றும் VRAM-ன் கூட்டுத்தொகை quant size-க்கு சமமாக இருக்க வேண்டும்; இது 1-bit UD-IQ1_S build-க்கு சுமார் 610 GB முதல் Q8-க்கு சுமார் 1.6 TB வரை இருக்கும். இதற்கு குறைவாக இருந்தால், model disk-க்குச் சென்று வேகம் கடுமையாகக் குறையும். GPU விருப்பத்தேர்வு மட்டுமே: "உங்களிடம் GPU இல்லையென்றால் அல்லது CPU inference மட்டுமே வேண்டுமென்றால்" Unsloth-ன் build instructions CUDA-வை அணைக்கச் சொல்கிறது. 1-bit மற்றும் 2-bit builds என்பவை K3-ன் அதிகப்படியான quantised வடிவங்கள், இவை மேலே குறிப்பிட்ட துல்லிய இழப்பைக் கொண்டுள்ளன. Q8 build என்பது K3-ன் வெளியிடப்பட்ட துல்லியத்தில், RAM வேகத்தில் ஒரு பயனருக்குச் சேவை செய்வது. இவை இரண்டுமே சிறிய models அல்ல.

GPU இணைக்கப்பட்ட VPS-ல் செயல்படும் server-ஐப் பெறுவதற்கு Ollama மிக விரைவான வழியாகும்:

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

ollama run முதல்முறை பயன்படுத்தும்போது model-ஐப் பதிவிறக்கம் செய்து, உங்களை ஒரு prompt-க்கு அழைத்துச் செல்லும். இல்லாத ஒரு tag-ஐ உள்ளிட்டால் Error: model "..." not found என்று வரும், எனவே library பக்கத்திலிருந்து tag-களை நகலெடுக்கவும், நினைவிலிருந்து தட்டச்சு செய்ய வேண்டாம். systemd unit மற்றும் remote access உள்ளிட்ட முழுமையான வழிமுறைகள் 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 வேகம் பல மடங்கு குறையும். இந்த இரண்டு கருவிகளுக்கு இடையிலான வேறுபாடுகள் Ollama மற்றும் llama.cpp ஒப்பீடு பகுதியில் விவரிக்கப்பட்டுள்ளன.

Tier 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 சரியாக உள்ளதா, காலாவதியாகிவிட்டதா அல்லது முடக்கப்பட்டுள்ளதா என்பதைச் சரிபார்க்கவும். மேலும், header-ல் Authorization: Bearer என்பதைத் தொடர்ந்து key உள்ளதா என்பதையும் உறுதிப்படுத்தவும். model-not-found பிழை ஏற்பட்டால், பொதுவாக id மாறியிருக்கலாம் என்று அர்த்தம்; ஏனெனில், checkpoint-களுக்கு இடையில் வழங்குநர்கள் (providers) id-களை நீக்கிவிடுவார்கள்.

இப்போது, மேலே குறிப்பிட்ட வாடகை விகிதத்தைக் கொண்டு லாப-நட்ட சமநிலையை (break-even) கணக்கிடுவோம். எப்போதும் இயங்கும் 8 GPU node-க்கு மாதத்திற்கு 14,400 USD செலவாகும். ஒரு மில்லியன் output tokens-க்கு 15.00 USD என்ற விலையில், அதே பணத்திற்கு API மூலம் சுமார் 960 மில்லியன் output tokens-களைப் பெறலாம். செலவில் லாபம் பெற வேண்டுமானால், மாதத்திற்கு சுமார் ஒரு பில்லியன் output tokens-களை (தினமும் சுமார் 30 மில்லியன்) உருவாக்க வேண்டும். மேலும், cluster-ஐ எப்போதும் பயன்பாட்டில் வைத்திருக்க வேண்டும், ஏனெனில் GPU சும்மா இருந்தாலும் (idle) அதே கட்டணமே வசூலிக்கப்படும். Prompt-களை அதிகம் பயன்படுத்தும் agent பணிகளுக்கு இந்த இலக்கு இன்னும் தள்ளிச் செல்லும்: மீண்டும் மீண்டும் பயன்படுத்தப்படும் context, 3.00 USD என்ற cache-miss விகிதத்திற்குப் பதிலாக, 0.30 USD என்ற cache-hit விகிதத்திலேயே கணக்கிடப்படும்.

இந்த tier-ல் நீங்கள் self-host செய்வது model-ஐச் சுற்றியுள்ள அனைத்து அம்சங்களையும் ஆகும்: API key-ஐத் தன்னகத்தே வைத்திருக்கும் gateway (இதனால் அது client-க்குச் செல்லாது), request மற்றும் response logs, retries, rate limits, மற்றும் பயனர் வாரியான வரவுசெலவுத் திட்டங்கள் (per-user budgets). இது GPU இல்லாத ஒரு சிறிய VPS-ல் இயங்கும். இதே பிரிவினை closed weights-க்கும் பொருந்தும், அங்கு self-hosting Claude என்பது model அளவில் சாத்தியமில்லை, நீங்கள் orchestration பகுதியை மட்டுமே கட்டுப்படுத்துவீர்கள்.

எந்த serving stack எந்த அடுக்கைச் (tier) சேர்ந்தது

vLLM மற்றும் SGLang வகை server-கள் tier 1-ஐச் சேர்ந்தவை. இவை ஒரே நேரத்தில் பல கோரிக்கைகளை (requests) கையாளும் வகையில், continuous batching மற்றும் paged KV cache வசதிகளுடன் வடிவமைக்கப்பட்டுள்ளன. மேலும், இவை பல nodes-களில் tensor மற்றும் expert parallelism-ஐப் பயன்படுத்துகின்றன. இவை datacenter accelerators மற்றும் அவற்றுக்கிடையேயான அதிவேக interconnect வசதிகளை அடிப்படையாகக் கொண்டுள்ளன. ஒரு சாதாரண consumer card-ல் இவற்றை நிறுவுவது கடினம், மேலும் இதனால் பெரிய பயன் ஏதும் இருக்காது.

llama.cpp மற்றும் Ollama ஆகியவை tier 2-ஐச் சேர்ந்தவை. இவை ஒரு machine-ஐ இலக்காகக் கொண்டு, GGUF quantisation, model முழுமையாகப் பொருந்தாதபோது CPU offload, மற்றும் குறைந்த concurrency ஆகியவற்றை வழங்குகின்றன. llama.cpp ஒரு மிகப்பெரிய MoE-ஐ, அதன் expert weights-ஐ system RAM-ல் (--cpu-moe அல்லது --n-cpu-moe) வைத்திருப்பதன் மூலம் கையாளும். மேலும், --moe-cache-mib மூலம், அது பயன்படுத்தும் experts-ஐ GPU-வில் cache செய்யும்; இதுவே Unsloth-ன் K3 GGUF builds ஒரு machine-ல் இயங்குவதற்கான வழியாகும். இதன் வேகம் RAM bandwidth மற்றும் router எவ்வளவு அடிக்கடி cache-ஐத் தவறவிடுகிறது என்பதைப் பொறுத்தது. ஒருவேளை கோப்பு RAM மற்றும் VRAM-ன் கூட்டு அளவை விட அதிகமாக இருந்தால், அது disk-க்குச் சென்றுவிடும். இது ஒரு பயனர் பயன்படுத்துவதற்கு ஏற்ற அமைப்பு. பல பயனர்களை ஒரே நேரத்தில் கையாளும் service இதுவல்ல. முழுமையான ஒப்பீடு Ollama மற்றும் vLLM ஒப்பீடு பகுதியில் உள்ளது. இது model-ஐப் பொறுத்து மாறுவதில்லை: நீங்கள் பகிரப்பட்ட hardware-ல் பல பயனர்களுக்குச் சேவை செய்கிறீர்களா அல்லது உங்கள் சொந்த machine-ல் ஒரு பயனருக்குச் சேவை செய்கிறீர்களா என்பதே இங்குள்ள கேள்வி.

இந்த checkpoint-ஐத் தாண்டி நிலைத்திருக்கும் நான்கு எண்கள்

  1. மொத்த parameters-ன் எண்ணிக்கையை ஒரு weight-க்கான bytes-ஆல் பெருக்கினால் கிடைக்கும் மதிப்பே memory-ன் குறைந்தபட்ச அளவு. வழங்கப்பட்ட precision-ல் இதைவிடக் குறைந்த memory-ல் எதுவும் இயங்காது. 4-bit release-க்குக் கீழே quantise செய்வது சுமார் 70 சதவீதம் வரை சேமிப்பைத் தரும், ஆனால் இது துல்லியத்தில் பாதிப்பை ஏற்படுத்தும், பத்து மடங்கு செயல்திறனைத் தராது.
  2. Active parameters-ன் எண்ணிக்கையே throughput-ன் அளவைத் தீர்மானிக்கிறது. 104B active parameters கொண்ட 2.8T MoE மாதிரி, ஒரு 104B மாதிரி போலவே கணக்கீடுகளைச் செய்யும்.
  3. ஒரு token-க்கான KV cache, context length மற்றும் concurrency ஆகியவற்றின் பெருக்கற்பலனே, weights-க்கான கட்டணத்தைச் செலுத்திய பிறகும் தொடர்ந்து அதிகரிக்கும் செலவாகும்.
  4. ஒரு டாலருக்கு எத்தனை tokens என்பது மட்டுமே ஒரு tier-ஐத் தீர்மானிக்கும் ஒரே எண். மேலே உள்ள அனைத்தும் இதற்கான உள்ளீடுகள் மட்டுமே.

இந்த நான்கு விதிகளையும் எந்தவொரு release-க்கும் பயன்படுத்தினால், vendor guide-ஐத் திறக்கும் முன்பே உங்களுக்குச் சரியான விடை கிடைத்துவிடும். அடுத்த வெளியீடு ஏற்கனவே அறிவிக்கப்பட்டுவிட்டது: Moonshot நிறுவனம் K3-ன் அடிப்படையில் மேலும் post-training செய்யப்பட்டு உருவாக்கப்பட்ட K3.1 Pro-வை, Kimi Code-ல் 2026 அக்டோபர் 23 அன்று வெளியிட்டது. அதன் API quickstart தகவல்படி, முழுமையான weights 2026 நவம்பர் 4-க்குள் வெளியிடப்படும். எனவே, நீங்கள் குறிப்பிடும் ஒவ்வொரு புள்ளிவிவரத்திற்கும் தேதியைக் குறிப்பிடுங்கள். K3 வெளியான இரண்டு வாரங்களுக்குள்ளேயே விலைகளும், ஆதரிக்கப்படும் architecture பட்டியல்களும் மாறிவிட்டன. இந்தப் பக்கத்தில் உள்ள வெளியீட்டுத் தரவுகள் 2026 ஜூலை மாதம் வெளியிடப்பட்டன; serving recipes, runtime releases மற்றும் quantisation எண்கள் 2026 அக்டோபர் 27 அன்று மீண்டும் சரிபார்க்கப்பட்டன.

FAQ

Kimi K3-ஐ ஒரே ஒரு GPU-வில் இயக்க முடியுமா?

முடியாது. Moonshot வழங்கும் MXFP4 precision-ல் இதன் weights சுமார் 1.4 TB அளவு இருக்கும். Kimi K3-ன் மிகச்சிறிய quantisation பதிப்பான Unsloth-ன் 466 GB UD-Q1_0 கோப்பு கூட, சந்தையில் கிடைக்கும் மிகப்பெரிய accelerators-ன் 288 GB கொள்ளளவை விட 1.6 மடங்கு பெரியது. llama.cpp மூலம் experts-ஐ system RAM-ல் வைத்துக்கொண்டு, தேவையானவற்றை மட்டும் GPU-வில் cache செய்ய முடியும். ஆனால், இதற்கு quant size-க்கு இணையான RAM மற்றும் VRAM தேவைப்படும். இதைவிடக் குறைந்த வசதி இருந்தால், model disk-க்குச் சென்று மிக மெதுவாக இயங்கும். வெளியிடப்பட்டுள்ள மிகச்சிறிய serving recipes-ல் கூட ஒரு 8-GPU B300 அல்லது MI350X/MI355X node தேவைப்படுகிறது; H100 recipe-க்கு 32 GPU-க்கள் தேவை.

Kimi K3-க்கு எவ்வளவு VRAM தேவை?

Weights-க்கு மட்டும் 1.4 TB-ல் தொடங்க வேண்டும். இது 18 H100 80GB cards அல்லது 5 GB300 வகை cards-க்கு சமம். இதனுடன் KV cache மற்றும் activation memory-ஐயும் சேர்த்துக்கொள்ள வேண்டும். Moonshot-ன் வழிகாட்டுதல்படி 64 அல்லது அதற்கு மேற்பட்ட accelerators பரிந்துரைக்கப்படுகின்றன. 27 October 2026 நிலவரப்படி, SGLang cookbook 8 B300 அல்லது 8 MI350X/MI355X cards (மொத்தம் 2,304 GB) மற்றும் 32 GPU H100 configuration (மொத்தம் 2,560 GB) ஆகியவற்றிற்கான single-node recipes-ஐ வழங்குகிறது. எனவே, weights அளவை ஒரு அடிப்படைத் தேவையாக மட்டுமே கருதவும்.

Quantisation மூலம் Kimi K3-ஐ ஒரே node-ல் பொருத்த முடியுமா?

ஏற்கனவே வழங்கப்பட்ட 4-bit checkpoint, எட்டு 288 GB cards கொண்ட ஒரு node-ல் பொருந்தும் (இதுவே SGLang-ன் B300 மற்றும் MI355X recipes-ல் பயன்படுத்தப்படுகிறது). Unsloth-ன் lossless Q8 GGUF மூலம் சுமார் 1.6 TB RAM மற்றும் VRAM கொண்ட ஒரு machine-லும் இதை இயக்கலாம். இன்னும் சிறிய machines-க்கு, Unsloth-ன் dynamic GGUF builds 2-bit-ல் 861.3 GB முதல் 1-bit-ல் 594 GB வரை உள்ளன. இதன் repo-வில் 1-bit கோப்புகள் 466 GB வரை பட்டியலிடப்பட்டுள்ளன (lossless நிலையில் இது சுமார் 1.56 TB). இதன் துல்லியத்தன்மை பாதிப்பு அளவிடப்பட்டுள்ளது: முழு model-உடன் ஒப்பிடும்போது, UD-Q2_K_XL-ல் 90.390 சதவீதமும், UD-IQ1_S-ல் 78.875 சதவீதமும் top-1 agreement கிடைக்கிறது. இதில் எதுவுமே ஒரே ஒரு card-ல் பொருந்தாது.

Kimi K3 API-ஐ விட GPU-க்களை வாடகைக்கு எடுப்பது மலிவானதா?

அதிகப்படியான மற்றும் தொடர்ச்சியான பயன்பாடு இருந்தால் மட்டுமே இது மலிவானது. ஒரு GPU-விற்கு ஒரு மணி நேரத்திற்கு 2.50 USD என வைத்துக்கொண்டால், எப்போதும் இயங்கும் 8 GPU node-க்கு மாதம் 14,400 USD செலவாகும். அதே தொகையில், 15.00 USD per million என்ற API விலையில் சுமார் 960 மில்லியன் output tokens-ஐப் பெறலாம். மேலும், பயன்பாடற்ற நேரங்கள், weights தரவிறக்கம் மற்றும் cluster-ஐ நிர்வகிக்கும் பணியாளர் செலவுகளையும் நீங்கள் கவனிக்க வேண்டும். அவ்வப்போது தேவைப்படும் பயன்பாட்டிற்கு மட்டும் மணிநேர அடிப்படையில் வாடகைக்கு எடுங்கள்; ஊகங்களை விட உங்கள் பயன்பாட்டுத் தரவுகளைக் கொண்டு ஒப்பிட்டுப் பாருங்கள்.

104B active parameters என்பது வேகத்தைப் பொறுத்தவரை எதைக் குறிக்கிறது?

ஒரு token-ஐக் கணக்கிடுவதற்கான வேகம் 104B model-க்கு இணையானது என்று பொருள். எனவே, throughput வேகம் 2.8T class-ல் இல்லாமல் 104B class-ல் இருக்கும். இது memory-ஐப் பாதிக்காது: அனைத்து 2.8T parameters-ம் resident-ஆகவே இருக்கும், ஏனெனில் router எந்த token-க்கும் எந்த expert-ஐயும் அழைக்க முடியும். Tokens per second-ஐக் கணிக்க active count-ஐயும், VRAM அளவைத் தீர்மானிக்க total count-ஐயும் பயன்படுத்தவும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?

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