Kimi K2.5

Clore.ai GPUs पर Moonshot AI द्वारा Kimi K2.5 (1T MoE मल्टिमोडल) डिप्लॉय करें

Moonshot AI द्वारा 27 जनवरी 2026 को जारी Kimi K2.5 एक 1-ट्रिलियन पैरामीटर वाला Mixture-of-Experts बहु-मोडीय मॉडल प्रति टोकन 32B सक्रिय पैरामीटरों के साथ। Kimi-K2-Base के ऊपर ~15 ट्रिलियन मिश्रित विज़ुअल और टेक्स्ट टोकनों पर सतत प्री-ट्रेनिंग के माध्यम से निर्मित, यह मूल रूप से टेक्स्ट, छवियों और वीडियो को समझता है। K2.5 प्रस्तुत करता है एजेंट स्वॉर्म तकनीक — एक साथ 100 तक विशेषीकृत AI एजेंटों का समन्वय करती है — और कोडिंग (76.8% SWE-bench Verified), विज़न और एजेंटिक कार्यों में अग्रणी-स्तर का प्रदर्शन हासिल करती है। एक के अंतर्गत उपलब्ध ओपन-वेट लाइसेंस HuggingFace पर।

मुख्य विशेषताएँ

• कुल 1T / 32B सक्रिय — MLA अटेंशन और SwiGLU के साथ 384-विशेषज्ञ MoE आर्किटेक्चर

• नेटिव मल्टीमोडल — विज़न–भाषा टोकनों पर प्री-ट्रेंड; छवियाँ, वीडियो और टेक्स्ट समझता है

• एजेंट स्वॉर्म — गतिशील रूप से उत्पन्न एजेंटों के माध्यम से जटिल कार्यों को समानांतर उप-कार्यों में विभाजित करता है

• 256K संदर्भ विंडो — पूरे कोडबेस, लंबे दस्तावेज़ और वीडियो ट्रांसक्रिप्ट संसाधित करें

• हाइब्रिड रीजनिंग — इंस्टेंट मोड (तेज़) और थिंकिंग मोड (गहन तर्क) दोनों का समर्थन करता है

• मज़बूत कोडिंग — 76.8% SWE-bench Verified, 73.0% SWE-bench Multilingual

आवश्यकताएँ

Kimi K2.5 एक विशाल मॉडल है — FP8 चेकपॉइंट ~630GB का है। सेल्फ-होस्टिंग के लिए गंभीर हार्डवेयर की आवश्यकता होती है।

घटक	क्वांटाइज़्ड (GGUF Q2)	FP8 पूर्ण
GPU	1× RTX 4090 + 256GB RAM	8× H200 141GB
VRAM	24GB + CPU ऑफलोड	1,128GB
RAM	256GB+	256GB
डिस्क	400GB SSD	700GB NVMe
CUDA	12.8+	12.8+

Clore.ai अनुशंसा: पूर्ण-सटीक सर्विंग के लिए, 8× H200 किराए पर लें (bare metal). क्वांटाइज़्ड स्थानीय इन्फेरेंस के लिए, एकल H100 80GB या यहाँ तक कि RTX 4090 + भारी CPU ऑफलोडिंग कम गति पर काम करता है.

llama.cpp के साथ क्विक स्टार्ट (क्वांटाइज़्ड)

K2.5 को स्थानीय रूप से चलाने का सबसे सुलभ तरीका — Unsloth की GGUF क्वांटाइज़ेशन का उपयोग करके:

# llama.cpp को क्लोन और बिल्ड करें
git clone https://github.com/ggml-org/llama.cpp && cd llama.cpp
cmake -B build -DGGML_CUDA=ON && cmake --build build --config Release -j

# क्वांटाइज़्ड मॉडल डाउनलोड करें (Q2_K_XL — 375GB, गुणवत्ता/आकार का अच्छा संतुलन)
huggingface-cli download unsloth/Kimi-K2.5-GGUF \\
  Kimi-K2.5-UD-Q2_K_XL-00001-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00002-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00003-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00004-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00005-of-00005.gguf \\
  --local-dir ./models

# इन्फेरेंस चलाएँ (अपनी VRAM के अनुसार --n-gpu-layers समायोजित करें)
./build/bin/llama-server \
  -m ./models/Kimi-K2.5-UD-Q2_K_XL-00001-of-00005.gguf \\
  --n-gpu-layers 10 \\
  --threads 32 \\
  --ctx-size 16384 \\
  --host 0.0.0.0 --port 8080

नोट: K2.5 के लिए GGUF/llama.cpp में विज़न अभी समर्थित नहीं है। बहु-मोडीय सुविधाओं के लिए vLLM का उपयोग करें.

vLLM सेटअप (प्रोडक्शन — पूर्ण मॉडल)

पूर्ण बहु-मोडीय समर्थन के साथ प्रोडक्शन सर्विंग के लिए:

# vLLM नाइटली इंस्टॉल करें (K2.5 को नवीनतम संस्करण चाहिए)
pip install -U vllm --pre \\
  --extra-index-url https://wheels.vllm.ai/nightly/cu129 \\
  --extra-index-url https://download.pytorch.org/whl/cu128 \\
  --index-strategy unsafe-best-match

8× H200 GPU पर सर्व करें

vllm serve moonshotai/Kimi-K2.5 \\
  -tp 8 \\
  --mm-encoder-tp-mode data \\
  --tool-call-parser kimi_k2 \\
  --reasoning-parser kimi_k2 \\
  --trust-remote-code \
  --gpu-memory-utilization 0.90

टेक्स्ट के साथ क्वेरी करें

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[
        {"role": "system", "content": "आप Kimi हैं, Moonshot AI द्वारा बनाया गया एक AI सहायक।"},
        {"role": "user", "content": "WebSocket समर्थन के साथ रीयल-टाइम चैट के लिए एक FastAPI सेवा लिखें"}
    ],
    temperature=0.6,
    max_tokens=4096
)
print(response.choices[0].message.content)

छवि के साथ क्वेरी करें (बहु-मोडीय)

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY", timeout=3600)

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image_url",
                "image_url": {"url": "https://example.com/diagram.png"}
            },
            {
                "type": "text",
                "text": "इस आरेख का विस्तार से वर्णन करें और सभी पाठ निकालें."
            }
        ]
    }],
    max_tokens=2048
)
print(response.choices[0].message.content)

API एक्सेस (GPU की आवश्यकता नहीं)

यदि सेल्फ-होस्टिंग ज़रूरत से ज़्यादा हो, तो Moonshot का आधिकारिक API उपयोग करें:

from openai import OpenAI

# Moonshot Platform — OpenAI-संगत API
client = OpenAI(
    api_key="your-moonshot-api-key",
    base_url="https://api.moonshot.ai/v1"
)

response = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[
        {"role": "user", "content": "Kimi K2.5 में Agent Swarm आर्किटेक्चर समझाइए"}
    ],
    temperature=0.6,
    max_tokens=2048
)
print(response.choices[0].message.content)

टूल कॉलिंग

K2.5 एजेंटिक टूल उपयोग में उत्कृष्ट है:

import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

tools = [{
    "type": "function",
    "function": {
        "name": "search_code",
        "description": "प्रासंगिक फ़ाइलों और फ़ंक्शनों के लिए कोडबेस खोजें",
        "parameters": {
            "type": "object",
            "required": ["query"],
            "properties": {
                "query": {"type": "string", "description": "खोज क्वेरी"}
            }
        }
    }
}]

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[{"role": "user", "content": "प्रोजेक्ट में प्रमाणीकरण-संबंधी सभी कोड खोजें"}],
    tools=tools,
    tool_choice="auto",
    temperature=0.6
)

for tool_call in response.choices[0].message.tool_calls:
    print(f"Function: {tool_call.function.name}")
    print(f"Args: {json.loads(tool_call.function.arguments)}")

Docker त्वरित शुरुआत

# 8 GPU के साथ vLLM Docker का उपयोग
docker run --gpus all -p 8000:8000 \\
  --ipc=host \
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  vllm/vllm-openai:latest \
  --model moonshotai/Kimi-K2.5 \\
  --tensor-parallel-size 8 \\
  --mm-encoder-tp-mode data \\
  --tool-call-parser kimi_k2 \\
  --reasoning-parser kimi_k2 \\
  --trust-remote-code

Clore.ai उपयोगकर्ताओं के लिए सुझाव

• API बनाम सेल्फ-होस्टिंग का ट्रेड-ऑफ़: पूर्ण K2.5 के लिए 8× H200 पर bare metal. Moonshot का API फ़्री-टियर या पे-पर-टोकन है — अन्वेषण के लिए API का उपयोग करें, और निरंतर प्रोडक्शन लोड के लिए सेल्फ-होस्ट करें.

• एकल GPU पर क्वांटाइज़्ड: Unsloth GGUF Q2_K_XL (~375GB) CPU ऑफलोडिंग के माध्यम से 256GB RAM के साथ RTX 4090 ($0.14–0.42/घंटा) पर चल सकता है — ~5–10 tok/s की अपेक्षा करें। व्यक्तिगत उपयोग और विकास के लिए पर्याप्त है.

• बजट सेटअप के लिए केवल-टेक्स्ट K2: यदि आपको विज़न की आवश्यकता नहीं है, moonshotai/Kimi-K2-Instruct यह केवल-टेक्स्ट पूर्ववर्ती है — वही 1T MoE, लेकिन डिप्लॉय करने में हल्का (विज़न एन्कोडर का ओवरहेड नहीं).

• तापमान सही सेट करें: उपयोग करें temperature=0.6 इंस्टेंट मोड के लिए, temperature=1.0 थिंकिंग मोड के लिए। गलत तापमान से पुनरावृत्ति या असंगति होती है.

• थ्रूपुट के लिए एक्सपर्ट पैरेललिज़्म: मल्टी-नोड सेटअप पर, उपयोग करें --enable-expert-parallel उच्च थ्रूपुट के लिए vLLM में। EP कॉन्फ़िगरेशन के लिए vLLM दस्तावेज़ देखें.

समस्या निवारण

समस्या	समाधान
OutOfMemoryError पूर्ण मॉडल के साथ	8× H200 (कुल 1128GB) की आवश्यकता है। FP8 वज़न का उपयोग करें, सेट करें --gpu-memory-utilization 0.90.
GGUF इन्फेरेंस बहुत धीमा	क्वांट आकार के लिए पर्याप्त RAM सुनिश्चित करें। Q2_K_XL को लगभग 375GB RAM+VRAM संयुक्त रूप से चाहिए.
llama.cpp में विज़न काम नहीं कर रहा	K2.5 GGUF के लिए विज़न समर्थन अभी उपलब्ध नहीं है — बहु-मोडीय के लिए vLLM का उपयोग करें.
दोहराव वाला आउटपुट	सेट करें temperature=0.6 (तुरंत) या 1.0 (थिंकिंग). जोड़ें min_p=0.01.
मॉडल डाउनलोड होने में बहुत समय लगता है	~630GB FP8 चेकपॉइंट। उपयोग करें huggingface-cli download के साथ --resume-download.
टूल कॉल्स पार्स नहीं हुए	जोड़ें --tool-call-parser kimi_k2 --enable-auto-tool-choice को vLLM सर्व कमांड में जोड़ें.

अधिक पढ़ें

• HuggingFace पर Kimi K2.5

• Kimi K2.5 तकनीकी ब्लॉग

• Kimi K2.5 शोध-पत्र

• vLLM K2.5 रेसिपी

• Unsloth GGUF क्वांटाइज़ेशन

• Moonshot API प्लेटफ़ॉर्म

• Kimi K2 GitHub