Kimi K2.5

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

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

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

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

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

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

• 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.0+	12.0+

Clore.ai सिफारिश: पूर्ण-प्रिसिजन सर्विंग के लिए, 8× H200 किराये पर लें (~$24–48/दिन)। क्वांटाइज़्ड स्थानीय इन्फरेंस के लिए, एकल 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

नोट: GGUF/llama.cpp में K2.5 के लिए विज़न अभी समर्थित नहीं है। बहु-मॉडल फ़ीचर्स के लिए 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/cu129 \
  --index-strategy unsafe-best-match

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

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 प्लेटफ़ॉर्म — 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 त्वरित शुरुआत

# vLLM Docker का उपयोग करते हुए 8 GPUs के साथ
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 (~$24–48/दिन) की आवश्यकता करता है। Moonshot का API फ्री-टियर या पे-पर-टोकन है — खोज के लिए API का उपयोग करें, निरंतर उत्पादन लोड के लिए स्वयं-होस्ट करें।

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

• बजट सेटअप के लिए केवल-टेक्स्ट 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 serve कमांड में।

अधिक पढ़ने के लिए

• HuggingFace पर Kimi K2.5

• Kimi K2.5 टेक ब्लॉग

• Kimi K2.5 पेपर

• vLLM K2.5 रेसिपी

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

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

• Kimi K2 GitHub