API दस्तावेज़

अवलोकन

Kimi K2 API, Kimi K2 भाषा मॉडल तक प्रोग्रामेटिक एक्सेस देता है। यह API OpenAI और Anthropic दोनों मैसेज फॉर्मैट्स को सपोर्ट करता है, जिससे मौजूदा ऐप्स में सहज एकीकरण हो सके।

बेस URL

https://kimi-k2.ai/api

समर्थित प्रोटोकॉल

• HTTPS पर REST API
• JSON अनुरोध और प्रतिक्रिया बॉडी
• UTF-8 कैरेक्टर एन्कोडिंग
• ब्राउज़र‑आधारित ऐप्स के लिए CORS सपोर्ट

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

Kimi K2 API शुरू करने के लिए तीन सरल चरण:

1. अकाउंट बनाएं और 100 मुफ्त क्रेडिट प्राप्त करें
2. अपने डैशबोर्ड से API key जनरेट करें
3. अपना पहला अनुरोध भेजें (अधिकांश मॉडल प्रति अनुरोध 1 क्रेडिट लेते हैं; kimi-k2.5 प्रति अनुरोध 2 क्रेडिट लेता है)

उदाहरण अनुरोध

curl https://kimi-k2.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2-0905",
    "messages": [{"role": "user", "content": "नमस्ते"}]
  }'

प्रमाणीकरण

API कुंजियाँ

API keys का उपयोग करके प्रमाणीकरण करें। अनुरोध हेडर में अपनी API key शामिल करें:

Authorization: Bearer YOUR_API_KEY

या Anthropic‑compatible endpoints के लिए:

X-API-Key: YOUR_API_KEY

प्रमाणीकरण तरीके

API संदर्भ

मॉडल सूची

API के साथ उपयोग किए जा सकने वाले सभी उपलब्ध मॉडल सूचीबद्ध करें।

उपलब्ध मॉडल सूची

GET /v1/models

API के लिए उपलब्ध मॉडलों की सूची लौटाता है।

प्रतिक्रिया प्रारूप

{
  "object": "list",
  "data": [
    {
      "id": "kimi-k2",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2",
      "parent": null
    },
    {
      "id": "kimi-k2-0905",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2-0905",
      "parent": null
    },
    {
      "id": "kimi-k2-thinking",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2-thinking",
      "parent": null
    }
  ]
}

प्रतिक्रिया फ़ील्ड

चैट कम्प्लीशन्स

Chat Completions API बातचीत के लिए मॉडल प्रतिक्रियाएँ जनरेट करता है। यह endpoint OpenAI के API फ़ॉर्मेट के साथ संगत है।

कम्प्लीशन बनाएं

POST /v1/chat/completions

दिए गए संवाद के लिए मॉडल प्रतिक्रिया जनरेट करता है।

अनुरोध प्रारूप

{
  "model": "kimi-k2-0905",
  "messages": [
    {
      "role": "system",
      "content": "आप एक सहायक असिस्टेंट हैं।"
    },
    {
      "role": "user", 
      "content": "क्वांटम कंप्यूटिंग समझाएं"
    }
  ],
  "temperature": 0.7,
  "max_tokens": 2048,
  "top_p": 1.0,
  "frequency_penalty": 0,
  "presence_penalty": 0,
  "stream": false,
  "n": 1
}

पैरामीटर्स

संदेश ऑब्जेक्ट

प्रतिक्रिया प्रारूप

{
  "id": "chatcmpl-9d4c2f68-5e3a-4b2f-a3c9-7d8e6f5c4b3a",
  "object": "chat.completion",
  "created": 1709125200,
  "model": "kimi-k2-0905",
  "system_fingerprint": "fp_a7c4d3e2",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "क्वांटम कंप्यूटिंग क्वांटम मैकेनिक्स के सिद्धांतों का उपयोग करती है..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 25,
    "completion_tokens": 189,
    "total_tokens": 214
  }
}

प्रतिक्रिया फ़ील्ड

समाप्ति कारण

स्ट्रीमिंग

stream: true होने पर Server‑Sent Events फ़ॉर्मेट:

data: {"id":"chatcmpl-...","choices":[{"delta":{"content":"नमस्ते"},"index":0}]}

data: {"id":"chatcmpl-...","choices":[{"delta":{"content":" वहाँ"},"index":0}]}

data: [DONE]

संदेश

Messages API, Anthropic‑compatible मैसेज जनरेशन प्रदान करता है।

संदेश बनाएं

POST /v1/messages

Messages फ़ॉर्मेट के साथ मॉडल प्रतिक्रिया बनाता है।

अनुरोध प्रारूप

{
  "model": "kimi-k2-0905",
  "messages": [
    {
      "role": "user",
      "content": "फ्रांस की राजधानी क्या है?"
    }
  ],
  "max_tokens": 1024,
  "system": "आप एक जानकार भूगोल सहायक हैं।",
  "temperature": 0.7,
  "top_p": 1.0,
  "stop_sequences": ["\n\nHuman:"]
}

पैरामीटर्स

प्रतिक्रिया प्रारूप

{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "फ्रांस की राजधानी पेरिस है।"
    }
  ],
  "model": "kimi-k2-0905",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 15,
    "output_tokens": 9
  }
}

प्रतिक्रिया फ़ील्ड

सिस्टम प्रॉम्प्ट

Messages API में सिस्टम प्रॉम्प्ट अलग से निर्दिष्ट किए जाते हैं:

{
  "system": "आप Claude हैं, Anthropic द्वारा बनाया गया AI सहायक।",
  "messages": [
    {"role": "user", "content": "नमस्ते"}
  ],
  "max_tokens": 1024
}

मॉडल

उपलब्ध मॉडल

मॉडल चयन

अपने उपयोग‑केस के आधार पर सही मॉडल चुनें:

• kimi-k2: सामान्य conversational AI, कंटेंट जनरेशन और standard tasks के लिए सर्वश्रेष्ठ
• kimi-k2-0905: लंबे कॉन्टेक्स्ट (256K तक) की जरूरत वाले कार्यों के लिए, जैसे पूरे दस्तावेज़ या लंबे संवाद का विश्लेषण
• kimi-k2-thinking: जटिल reasoning कार्यों के लिए optimized:
  • गणितीय प्रमाण और प्रतियोगिता‑स्तर के प्रश्न
  • रिसर्च विश्लेषण और literature review
  • लॉजिकल reasoning के साथ multi‑step समस्या‑समाधान
  • उन्नत tool orchestration (200-300 sequential tool calls)
  • जटिल UI आवश्यकताओं के साथ फ्रंटएंड डेवलपमेंट
  • स्वायत्त नेविगेशन वाले agentic search tasks
• kimi-k2.5: Native multimodal, agentic मॉडल, 256K कॉन्टेक्स्ट के साथ tool use और reasoning के लिए optimized

Kimi-K2.5 प्रमुख स्पेक्स: MoE आर्किटेक्चर (1T कुल पैरामीटर, 32B सक्रिय), 256K कॉन्टेक्स्ट, और MoonViT vision encoder।

Thinking मॉडल अपना reasoning प्रक्रिया step‑by‑step दिखाता है, जिससे यह शिक्षा और पारदर्शिता‑आधारित अनुप्रयोगों के लिए आदर्श है।

अनुरोध सीमाएँ

रेट लिमिट्स

रेट लिमिट्स API key के क्रेडिट बैलेंस के आधार पर लागू होती हैं:

रेट लिमिट हेडर्स:

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 59
X-RateLimit-Reset: 1709125800

टोकन सीमाएँ

टाइमआउट सेटिंग्स

त्रुटि कोड

HTTP स्थिति कोड

त्रुटि प्रकार

OpenAI फ़ॉर्मेट त्रुटियाँ

{
  "error": {
    "message": "Invalid API key provided",
    "type": "invalid_request_error",
    "code": "invalid_api_key"
  }
}

Anthropic फ़ॉर्मेट त्रुटियाँ

{
  "type": "error",
  "error": {
    "type": "authentication_error",
    "message": "Invalid API key"
  }
}

त्रुटि हैंडलिंग

Retries के लिए jitter के साथ exponential backoff लागू करें:

import time
import random

def retry_with_backoff(
    func, 
    max_retries=3,
    base_delay=1,
    max_delay=60
):
    for attempt in range(max_retries):
        try:
            return func()
        except RateLimitError:
            if attempt == max_retries - 1:
                raise
            
            delay = min(
                base_delay * (2 ** attempt) + random.uniform(0, 1),
                max_delay
            )
            time.sleep(delay)

क्लाइंट लाइब्रेरीज़

Python

इंस्टॉलेशन

pip install openai
# या
pip install anthropic

OpenAI क्लाइंट

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://kimi-k2.ai/api/v1"
)

# उपलब्ध मॉडल सूचीबद्ध करें
models = client.models.list()
for model in models.data:
    print(f"मॉडल ID: {model.id}")

# चैट कम्प्लीशन बनाएं
response = client.chat.completions.create(
    model="kimi-k2-0905",
    messages=[
        {"role": "user", "content": "नमस्ते"}
    ]
)

Anthropic क्लाइंट

from anthropic import Anthropic

client = Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://kimi-k2.ai/api/v1"
)

response = client.messages.create(
    model="kimi-k2-0905",
    messages=[
        {"role": "user", "content": "नमस्ते"}
    ],
    max_tokens=1024
)

Node.js

इंस्टॉलेशन

npm install openai
# या
npm install @anthropic-ai/sdk

OpenAI क्लाइंट

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  baseURL: 'https://kimi-k2.ai/api/v1',
});

// उपलब्ध मॉडल सूचीबद्ध करें
const models = await openai.models.list();
for (const model of models.data) {
  console.log(`मॉडल ID: ${model.id}`);
}

// चैट कम्प्लीशन बनाएं
const response = await openai.chat.completions.create({
  model: 'kimi-k2-0905',
  messages: [{ role: 'user', content: 'नमस्ते' }],
});

Anthropic क्लाइंट

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic({
  apiKey: process.env.KIMI_API_KEY,
  baseURL: 'https://kimi-k2.ai/api/v1',
});

const response = await anthropic.messages.create({
  model: 'kimi-k2-0905',
  messages: [{ role: 'user', content: 'नमस्ते' }],
  max_tokens: 1024,
});

Go

इंस्टॉलेशन

go get github.com/sashabaranov/go-openai

उदाहरण

package main

import (
    "context"
    "fmt"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    config := openai.DefaultConfig("YOUR_API_KEY")
    config.BaseURL = "https://kimi-k2.ai/api/v1"
    
    client := openai.NewClientWithConfig(config)
    
    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "kimi-k2",
            Messages: []openai.ChatCompletionMessage{
                {
                    Role:    openai.ChatMessageRoleUser,
                    Content: "नमस्ते",
                },
            },
        },
    )
    
    if err != nil {
        panic(err)
    }
    
    fmt.Println(resp.Choices[0].Message.Content)
}

REST API

बिना क्लाइंट लाइब्रेरी के सीधे HTTP अनुरोध:

cURL

curl -X POST https://kimi-k2.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2",
    "messages": [
      {"role": "user", "content": "नमस्ते"}
    ]
  }'

Python (requests)

import requests

response = requests.post(
    "https://kimi-k2.ai/api/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "kimi-k2",
        "messages": [{"role": "user", "content": "नमस्ते"}]
    }
)

Node.js (fetch)

const response = await fetch('https://kimi-k2.ai/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'kimi-k2-0905',
    messages: [{ role: 'user', content: 'नमस्ते' }],
  }),
});

बिलिंग

क्रेडिट सिस्टम

API उपयोग क्रेडिट सिस्टम के माध्यम से बिल किया जाता है:

• अधिकांश मॉडल: प्रति API अनुरोध 1 क्रेडिट
• kimi-k2.5: प्रति API अनुरोध 2 क्रेडिट
• सफल completion के बाद क्रेडिट घटते हैं
• विफल अनुरोध (4xx) पर शुल्क नहीं लगता
• सर्वर त्रुटि (5xx) पर शुल्क नहीं लगता
• नए यूज़र को रजिस्ट्रेशन पर 100 मुफ्त क्रेडिट मिलते हैं
• इनवाइट रिवॉर्ड्स:
  • 50 क्रेडिट जब कोई आपके इनवाइट कोड से रजिस्टर करे
  • 500 क्रेडिट जब आमंत्रित यूज़र पहला भुगतान करे

क्रेडिट पैकेज

उपयोग ट्रैकिंग

अपना उपयोग यहाँ ट्रैक करें:

1. Response headers: X-Credits-Remaining: 4523
2. डैशबोर्ड: रियल‑टाइम उपयोग आँकड़े /my-credits
3. API endpoint: GET /api/user/credits

उपयोग डेटा में शामिल है:

• कुल क्रेडिट खपत
• शेष क्रेडिट
• दिन/घंटे के अनुसार उपयोग
• प्रति अनुरोध औसत टोकन

माइग्रेशन गाइड

OpenAI से

OpenAI API से माइग्रेशन में न्यूनतम बदलाव चाहिए:

1. Base URL अपडेट करें:

   # पहले
   client = OpenAI(api_key="sk-...")
   
   # बाद में
   client = OpenAI(
       api_key="sk-...",
       base_url="https://kimi-k2.ai/api/v1"
   )
   

2. मॉडल नाम अपडेट करें:

   # पहले
   model="gpt-4"
   
   # बाद में
   model="kimi-k2-0905"
   

3. अन्य किसी बदलाव की जरूरत नहीं — API पूरी तरह संगत है

Anthropic से

Anthropic API से माइग्रेशन:

1. Base URL अपडेट करें:

   # पहले
   client = Anthropic(api_key="sk-ant-...")
   
   # बाद में
   client = Anthropic(
       api_key="sk-...",
       base_url="https://kimi-k2.ai/api/v1"
   )
   

2. प्रमाणीकरण अपडेट करें:

   • Kimi K2 डैशबोर्ड से API key जनरेट करें
   • Anthropic API key को replace करें

3. मॉडल संगतता:

   • Kimi K2 समर्थित है

चेंज लॉग

2025-11-10

• kimi-k2-thinking मॉडल जोड़ा गया
• जटिल reasoning कार्यों के लिए विशेषज्ञ मॉडल
• step‑by‑step reasoning प्रक्रिया दिखाने का समर्थन
• गणितीय प्रमाण, रिसर्च विश्लेषण और multi‑step समस्या‑समाधान के लिए सपोर्ट
• एडवांस्ड tool orchestration क्षमताएँ (200-300 sequential tool calls)

2025-09-05

• 256K कॉन्टेक्स्ट विंडो सपोर्ट
• kimi-k2-0905 मॉडल सपोर्ट

2025-01-30

• Anthropic Messages API संगतता जोड़ी गई
• X-API-Key प्रमाणीकरण विधि पेश की गई