Kimi K3: फीचर्स, बेंचमार्क, API, और 5 हैंड्स-ऑन उदाहरण

जाने कि Kimi K3 क्या है, इसे कैसे एक्सेस करें, और यह पाँच हैंड्स-ऑन उदाहरणों में रीजनिंग, टूल्स, लंबा कॉन्टेक्स्ट, और विज़न को कैसे संभालता है।

अद्यतन 21 जुल॰ 2026 · 12 मि॰ पढ़ना

AI के साथ खोजें

ChatGPT में खोलें Claude में खोलें Perplexity में खोलें

ओपन मॉडल रेस 16 जुलाई, 2026 को फिर आगे बढ़ी, जब Moonshot AI ने Kimi K3 जारी किया—2.8 ट्रिलियन पैरामीटर वाला मॉडल, जिसमें 1-मिलियन-टोकन का कॉन्टेक्स्ट विंडो और नेटिव विज़न है। यह Moonshot का अब तक का सबसे बड़ा ओपन मॉडल है, आकार में Kimi K2 से काफी आगे, और पहला जिसे वे 3-ट्रिलियन-पैरामीटर क्लास तक पहुंचता बताते हैं।

यदि आप लॉन्च की कहानी, आर्किटेक्चर डीप डाइव, बेंचमार्क चार्ट, Claude, GPT, और अन्य चीनी लैब्स के साथ तुलना, तथा Moonshot की अपनी सीमाओं की सूची चाहते हैं, तो हमारा Kimi K3 ब्लॉग पोस्ट यह सब कवर करता है। यह ट्यूटोरियल हैंड्स-ऑन पक्ष है—कैसे एक्सेस करें और इस्तेमाल करने पर यह कैसा व्यवहार करता है। मैं पाँच छोटे उदाहरणों से गुजरूँगा—चार API के ज़रिए, जहाँ मैं असली टोकन उपयोग और लागत दिखाऊँगा—और दो kimi.com वेब ऐप में। साथ मिलकर, वे दिखाते हैं कि K3 इन बातों को कैसे संभालता है:

टूल कॉल करना और सख्त JSON लौटाना
उड़ते-उड़ते टूल डेफिनिशन लोड करना
ऑटोमैटिक कैशिंग से लॉन्ग-कॉन्टेक्स्ट की लागत काटना
स्क्रीनशॉट पढ़ना और लेआउट सुधारना
एक ही प्रॉम्प्ट से इंटरैक्टिव डैशबोर्ड बनाना

चारों API उदाहरण 17 जुलाई, 2026 को kimi-k3 मॉडल पर चले, और कोल्ड रन पर लगभग 11 सेंट, या कैशिंग शुरू होने के बाद कुछ सेंट पड़े।

Kimi K3 तक कैसे पहुँचें

मॉडल आज़माने का सबसे तेज़ तरीका है kimi.com, जहाँ वेब ऐप और मोबाइल ऐप बिना किसी सेटअप के सामान्य एजेंट कार्यों के लिए Kimi K3 चलाते हैं।

रिपोर्ट्स और डैशबोर्ड जैसे भारी काम के लिए Kimi Work, एक डेस्कटॉप ऐप, उपलब्ध है।

यदि आप टर्मिनल में रहते हैं, तो Kimi Code एक कोडिंग एजेंट है जिसे आप npm से @moonshot-ai/kimi-code के रूप में इंस्टॉल करते हैं, और वहाँ /model कमांड से मॉडल चुनते हैं। Kimi Code में K3 का उपयोग करने के लिए पेड मेंबरशिप चाहिए, और पूरे 1-मिलियन-टोकन विंडो के लिए ऊँचा टियर आवश्यक है।

यह ट्यूटोरियल रॉ API और वेब ऐप पर केंद्रित है, लेकिन यदि आप चाहें तो टर्मिनल एजेंट मौजूद है।

हालाँकि, K3 अपने सिब्लिंग्स की जगह नहीं लेता। नीचे दी गई तालिका दिखाती है कि वर्तमान लाइनअप कैसे बँटा हुआ है।

मॉडल	कॉन्टेक्स्ट विंडो	किसके लिए सबसे उपयुक्त
`kimi-k3`	1,048,576 टोकन	फ़्लैगशिप काम: लंबा कोडिंग, विज़न, नॉलेज टास्क
`kimi-k2.7-code`	262,144 टोकन	समर्पित कोडिंग, साथ में तेज़ हाई-स्पीड विकल्प
`kimi-k2.6`	262,144 टोकन	सामान्य टेक्स्ट, इमेज, और वीडियो चैट

संक्षेप में, जब काम में कोड, टूल्स, दस्तावेज़ और इमेज मिलते-जुलते हों, या जब आपको सचमुच 1-मिलियन-टोकन विंडो चाहिए, तो K3 शुरू करने के लिए सही मॉडल है। जहाँ शुद्ध कोड जेनरेशन में गति संदर्भ से अधिक मायने रखती है, वहाँ kimi-k2.7-code अब भी अधिक समझदार विकल्प है, इसलिए यह न मानें कि हर बार नया मॉडल ही सही होगा।

Kimi K3 API सेटअप करना

API OpenAI SDK के साथ संगत है, इसलिए यदि आपने वह पहले इस्तेमाल किया है, तो यहाँ लगभग सब कुछ परिचित लगेगा। आपको Python 3.9 या बाद का संस्करण और एक API कुंजी चाहिए।

चरण 1: API कुंजी बनाना

पहले, Kimi प्लेटफ़ॉर्म में साइन इन करें और कंसोल में API Keys पेज खोलें। एक कुंजी बनाएँ, उसे एक बार कॉपी करें, और कहीं सुरक्षित रख दें, क्योंकि आप उसे फिर नहीं देखेंगे। कॉल करने के लिए खाते में थोड़ा बैलेंस भी चाहिए—इस पूरे ट्यूटोरियल के लिए कुछ डॉलर पर्याप्त हैं।

Kimi K3 API कुंजी बनाना। चित्र: लेखक।

चरण 2: SDK इंस्टॉल करना

अब, OpenAI SDK अपने पर्यावरण में इंस्टॉल करें। एक ही कमांड पर्याप्त है।

python -m pip install --upgrade "openai>=1.0"

यह वही क्लाइंट लाइब्रेरी लाता है जिसका उपयोग बाकी उदाहरण करते हैं, और Kimi-विशेष कुछ भी इंस्टॉल करने की ज़रूरत नहीं है।

चरण 3: कुंजी स्टोर करना और क्लाइंट इनिशियलाइज़ करना

कुंजी को कोड में पेस्ट करने के बजाय एनवायरनमेंट वेरिएबल से पढ़ना बेहतर है। अपने शेल या किसी .env फ़ाइल में MOONSHOT_API_KEY सेट करें, फिर क्लाइंट को Moonshot के बेस URL पर पॉइंट करें।

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

स्टैंडर्ड OpenAI सेटअप से केवल दो चीज़ें अलग हैं: base_url और मॉडल का नाम, जो है kimi-k3। यह हो जाने पर, आप कॉल करने के लिए तैयार हैं।

चरण 4: अपनी पहली कॉल करना

अब पहली रिक्वेस्ट। मैंने मॉडल से अपने बारे में एक वाक्य में परिचय देने को कहा, जो एक ईमानदार-सा पल बन गया।

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Introduce Kimi K3 in one sentence."}],
    max_completion_tokens=800,
)
print(completion.choices[0].message.content)

जवाब शालीन इनकार था—अनुमान लगाने से मना करते हुए मॉडल ने कहा कि उसके पास Kimi K3 के बारे में विश्वसनीय जानकारी नहीं है, क्योंकि उसका प्रशिक्षण अपनी ही रिलीज़ से पहले हुआ था, और उसने Moonshot की घोषणाओं की ओर इशारा किया। यह उपयोगी याद दिलाता है कि मॉडल खुद के बारे में नहीं जानता। यह API कॉल लगभग 0.7 सेंट पड़ी। ध्यान दें

max_completion_tokens की सीमा—मैंने इस ट्यूटोरियल में हर कॉल पर इसे सेट किया ताकि लंबा-चौड़ा आउटपुट बिल न बढ़ा दे।

Kimi K3 की पहली API कॉल का आउटपुट। चित्र: लेखक।

उदाहरण 1: स्ट्रीमिंग रीजनिंग और अंतिम उत्तर

K3 हमेशा तर्क करता है, और API उस तर्क को उत्तर से अलग चैनल पर लौटाती है। जब आप स्ट्रीम करते हैं, तो हर चंक में reasoning_content, अंतिम content, या दोनों हो सकते हैं, ताकि आप सोच-विचार और उत्तर अलग-अलग दिखा सकें।

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "A bat and a ball cost $1.10 together. The bat costs $1.00 more than the ball. How much is the ball?"}],
    max_completion_tokens=1200,
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    reasoning = getattr(delta, "reasoning_content", None)
    if reasoning:
        print(reasoning, end="", flush=True)
    if delta.content:
        print(delta.content, end="", flush=True)

मॉडल ने पहले अपना काम स्ट्रीम किया: उसने बैट-एंड-बॉल सवाल को क्लासिक Cognitive Reflection Test के रूप में पहचाना, सहज लेकिन गलत जवाब $0.10 को चिन्हित किया, फिर बीजगणित करके गेंद की कीमत $0.05 निकाली और जाँचा कि $1.05 प्लस $0.05 मिलकर $1.10 होते हैं। काम की चीज़ यह विभाजन है: वास्तविक ऐप में आप उपयोगकर्ताओं को content दिखाते हैं और reasoning_content लॉग्स के लिए रखते हैं, क्योंकि प्रोडक्शन में कच्चा तर्क दिखाना क्वचित ही सही रहता है। इस कॉल में 488 आउटपुट टोकन लगे और लागत एक सेंट से कम रही।

पहले तर्क, फिर अंतिम उत्तर की स्ट्रीमिंग। चित्र: लेखक।

उदाहरण 2: स्ट्रक्चर्ड आउटपुट के साथ टूल कॉलिंग

Kimi K3 लाइनअप का वह मॉडल है जो tool_choice="required" सपोर्ट करता है, जो एक टर्न में कम-से-कम एक टूल कॉल को बाध्य करता है। यह तब उपयोगी है जब आप चाहते हैं कि मॉडल अनुमान लगाने के बजाय पहले डेटा लाए। यहाँ मैंने उसे दो मॉक टूल दिए—प्राइस लुकअप और स्टॉक चेक—टूल कॉल को बाध्य किया, टूल्स को लोकली चलाया, और फिर response_format के जरिए सख्त JSON में परिणाम माँगा।

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=TOOLS,
    tool_choice="required",
    max_completion_tokens=2500,
)
assistant_message = first.choices[0].message
messages.append(assistant_message)

for tool_call in assistant_message.tool_calls or []:
    args = json.loads(tool_call.function.arguments)
    messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": run_tool(tool_call.function.name, args)})

मॉडल ने दोनों टूल्स को सही प्रोडक्ट कोड के साथ कॉल किया, फिर एक साफ़ ऑर्डर समरी JSON में लौटाई: पाँच मैकेनिकल कीबोर्ड $89 प्रति इकाई, कुल $445, और स्टॉक फ्लैग true। दो बातें इसे व्यवहार में सही चलाती हैं। आपको टूल रिज़ल्ट जोड़ने से पहले पूरी असिस्टेंट मैसेज वापस बातचीत में जोड़नी चाहिए, और JSON के लिए केवल content ही पार्स करना चाहिए—कभी भी reasoning फ़ील्ड नहीं। इन दो कॉल्स की संयुक्त लागत एक सेंट से कम रही।

टूल कॉल्स और स्ट्रक्चर्ड JSON आउटपुट। चित्र: लेखक।

उदाहरण 3: टूल्स को डायनेमिक रूप से लोड करना

यदि आपके पास दर्जनों टूल हों, तो हर रिक्वेस्ट में उनकी सभी डेफिनिशन भेजना टोकन बर्बाद करता है और प्रॉम्प्ट को भर देता है। Kimi K3 आपको बातचीत के बीच में एक system मैसेज के साथ टूल डेफिनिशन इंजेक्ट करने देता है, जिसमें tools फ़ील्ड हो और content न हो। टूल उसी बिंदु से उपलब्ध हो जाता है, जिससे बड़े टूल कैटलॉग आपके कैश्ड प्रीफिक्स से बाहर रहते हैं, जब तक कि टूल सच में ज़रूरत न हो।

messages = [
    {"role": "user", "content": "Convert 100 US dollars to euros at a rate of 0.92."},
    {"role": "system", "tools": [{
        "type": "function",
        "function": {
            "name": "convert_currency",
            "description": "Convert an amount from one currency to another",
            "parameters": {
                "type": "object",
                "properties": {"amount": {"type": "number"}, "rate": {"type": "number"}},
                "required": ["amount", "rate"],
            },
        },
    }]},
]
completion = client.chat.completions.create(model="kimi-k3", messages=messages)
print(completion.choices[0].message.tool_calls)

K3 ने ताज़ा लोड हुए टूल को पकड़ा और convert_currency को 100 राशि और 0.92 रेट के साथ कॉल किया—ठीक वैसे ही जैसे इरादा था। याद रखने योग्य बात यह है कि सर्वर आपके लिए यह डेफिनिशन अपने पास नहीं रखता, इसलिए यदि आप टूल को उपलब्ध रखना चाहते हैं तो बाद की रिक्वेस्ट में यह सिस्टम मैसेज फिर भेजें। यह सेट का सबसे सस्ता कॉल था—लगभग 0.2 सेंट।

डायनेमिकली लोडेड करेंसी टूल को कॉल करना। चित्र: लेखक।

उदाहरण 4: कैशिंग से लॉन्ग-कॉन्टेक्स्ट की लागत घटाना

यही वह उदाहरण है जहाँ 1-मिलियन-टोकन विंडो व्यावहारिक हो जाती है। कॉन्टेक्स्ट कैशिंग ऑटोमैटिक है—न कोई कैश ID, न कोई टाइम-टु-लिव मैनेज करना। आप बड़ा प्रीफिक्स भेजते हैं, बाद की रिक्वेस्ट में उसे बाइट-टू-बाइट समान रखते हैं, और दोहराया हिस्सा कैश-मिस रेट की जगह कैश-हिट रेट पर बिल होता है। फर्क दिखाने के लिए मैंने लगभग 33,000 टोकन की नॉलेज बेस ली और उस पर एक सवाल पूछा।

knowledge = Path("knowledge_base.md").read_text(encoding="utf-8")
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": knowledge},
        {"role": "user", "content": "What is the rated payload of the Atlas robot?"},
    ],
    max_completion_tokens=600,
)

पहली बार जब मैंने वह प्रीफिक्स भेजा, उसका कुछ भी कैश में नहीं था, और रिक्वेस्ट की लागत लगभग 9.9 सेंट पड़ी—करीब 33,000 इनपुट टोकन के लिए। प्रीफिक्स देखे जाने के बाद, वही रिक्वेस्ट सभी 32,512 प्रीफिक्स टोकनों पर कैश हिट हुई और लगभग 1.1 सेंट पड़ी—करीब नौ गुना गिरावट। वजह है दाम का फासला: कैश्ड इनपुट $0.30 प्रति मिलियन टोकन है, जबकि अनकैश्ड $3.00। एक पेच जो मुझे दिखा, वह यह कि कैश राइट्स एसिंक्रोनस हैं, इसलिए तुरंत बैक-टु-बैक कॉल पर हिट नहीं दिखती। यह बाद की रिक्वेस्ट पर दिखती है, तो एक मिनट के अंतर पर स्क्रिप्ट दो बार चलाने से पहले मिस और फिर हिट दिखेगी।

कैश मिस बनाम कैश हिट लागत। चित्र: लेखक।

उदाहरण 5: स्क्रीनशॉट में लेआउट बग पकड़ना

K3 में विज़न नेटिव है, और API इसे इस्तेमाल करने का साफ़ तरीका है, हालाँकि यह किसी पब्लिक इमेज URL को नहीं लेगा। आप इमेज को base64 डेटा URL के रूप में भेजते हैं और मैसेज के content को ऑब्जेक्ट्स की एक ऐरे बनाते हैं—एक भाग इमेज के लिए, एक भाग टेक्स्ट के लिए। मैंने कुछ जानबूझकर लेआउट बग के साथ एक छोटा डैशबोर्ड रेंडर किया, स्क्रीनशॉट सेव किया, और K3 से पूछा कि क्या गलत है।

जानबूझकर लेआउट बग वाला डैशबोर्ड। चित्र: लेखक।

import base64
from pathlib import Path

image_data = base64.b64encode(Path("broken_dashboard.png").read_bytes()).decode()
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[{
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}},
            {"type": "text", "text": "List the layout and alignment problems you can see, and give a short CSS fix for each."},
        ],
    }],
    max_completion_tokens=3500,
)
print(completion.choices[0].message.content)

K3 ने इमेज अच्छी तरह पढ़ी। उसने उस कार्ड को पकड़ा जो पंक्ति से नीचे बैठा है और पड़ोसी पर ओवरलैप करता है, नंबर के ऊपर टिके बैज को (उसने ढके हुए 3,910 को 5,910 भी पढ़ लिया—जो बग खुद साबित करता है), आख़िरी कार्ड से पहले का असमान गैप, ऊपर वाले कार्ड में घुसती बार, और बार्स पर बैठा टूलटिप—और हर एक के लिए छोटा CSS सुधार दिया, जैसे कार्ड्स को एक ग्रिड में ले जाना। हालाँकि, उसने लगभग-अदृश्य लो-कॉन्ट्रास्ट सबटाइटल छोड़ दिया, तो विज़न आँख को उभरकर दिखने वाली चीज़ें ज़्यादा पकड़ता है, हल्की-फुल्की डिटेल कम। कॉल की लागत लगभग दो सेंट रही।

Kimi K3 की सीमाएँ

API उदाहरण अच्छे रहे, पर कुछ खुरदुरे किनारे नाम लेने लायक हैं ताकि आप चौंकें नहीं। इनमें से अधिकतर से मैं सीधे गुज़रा।

फिलहाल केवल reasoning_effort="max" उपलब्ध है, इसलिए आप सोचना घटाकर पैसे नहीं बचा सकते।
सैंपलिंग सेटिंग्स फिक्स्ड हैं। temperature, top_p और पेनल्टी जैसे मान लॉक हैं, इसलिए उन्हें ट्यून करने के बजाय रिक्वेस्ट से हटा दें।
आउटपुट लंबा और महँगा हो सकता है। max_completion_tokens को कैप करें, जैसा कि उदाहरणों में है, और किसी भी एजेंट लूप को वैलिडेट करें।
API के माध्यम से पब्लिक इमेज URLs समर्थित नहीं हैं, इसलिए वहाँ विज़न के लिए base64 या अपलोडेड फ़ाइलों की योजना बनाएँ।

ये सब डीलब्रेकर्स नहीं हैं, लेकिन ये तय करते हैं कि आप मॉडल का उपयोग कैसे करेंगे। आउटपुट लागत वह चीज़ है जिस पर मैं सबसे ज़्यादा नज़र रखूँगा।

निष्कर्ष

मेरे रन में दो बातें उभरीं। टूल कॉलिंग और स्ट्रक्चर्ड आउटपुट को कोई रिट्राई नहीं चाहिए थे, और कैशिंग उम्मीद से ज़्यादा मायने रखती थी—क्योंकि एक ही लंबा प्रीफिक्स दोबारा भेजना बड़ी रिक्वेस्ट को सस्ता बना देता है। इसलिए रिपॉज़िटरी-स्केल विश्लेषण, दोहराए जाने वाले लॉन्ग-कॉन्टेक्स्ट कॉल्स, या मल्टीमोडल इंजीनियरिंग के लिए K3 एक उचित डिफ़ॉल्ट है; तेज़, कम-लागत चैट या सटीक सैंपलिंग कंट्रोल के लिए छोटा मॉडल आसान चुनाव है। पहले बताए गए ओपन-वेट और लाइसेंस विवरण 27 जुलाई की रिलीज़ के बाद और स्पष्ट होने चाहिए।

इन उदाहरणों में इस्तेमाल पैटर्न्स की पृष्ठभूमि के लिए, हमारा Developing AI Systems with the OpenAI API कोर्स Python में फ़ंक्शन कॉलिंग और मॉडल्स को बाहरी टूल्स से वायर करना कवर करता है।

विषय