API दस्तावेज़

अवलोकन

kimrel.com, Kimi K2 और संबंधित मॉडलों तक पहुँच के लिए एक स्वतंत्र, OpenAI- और Anthropic-compatible API interface प्रदान करता है। Kimi K2 को Moonshot AI ने विकसित किया है, और kimrel.com का Moonshot AI से कोई संबंध नहीं है तथा यह Moonshot AI द्वारा अनुमोदित, समर्थित या प्रायोजित नहीं है।

बेस URL

https://kimrel.com/api

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

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

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

kimrel.com API शुरू करने के लिए तीन सरल चरण:

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

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

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

AI कोडिंग टूल्स

kimrel.com OpenAI‑compatible (chat completions) और Claude‑compatible (messages) दोनों endpoints उपलब्ध कराता है, इसलिए supported models को लोकप्रिय AI coding tools में आसानी से जोड़ा जा सकता है।

मॉडल सपोर्ट: kimi-k2, kimi-k2-0905, kimi-k2-thinking, kimi-k2.5, और kimi-k2.6 routes kimrel.com के माध्यम से उपलब्ध हैं। Kimi K2 को Moonshot AI ने विकसित किया है; kimrel.com एक independent interface है और इसका Moonshot AI से कोई संबंध नहीं है तथा यह Moonshot AI द्वारा अनुमोदित, समर्थित या प्रायोजित नहीं है। यदि आपको image understanding, thinking mode और tool-enabled workflows चाहिए, तो kimi-k2.6 प्राथमिक विकल्प है।

Claude Code (Recommended)

Claude Code ~/.claude/settings.json से कॉन्फ़िगरेशन पढ़ता है। env सेक्शन में नीचे दिया गया कॉन्फ़िग जोड़ें या अपडेट करें:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://kimrel.com/api",
    "ANTHROPIC_AUTH_TOKEN": "<KIMREL_API_KEY>",
    "API_TIMEOUT_MS": "3000000",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": 1,
    "ANTHROPIC_MODEL": "kimi-k2.5",
    "ANTHROPIC_SMALL_FAST_MODEL": "kimi-k2",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "kimi-k2.5",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "kimi-k2.5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "kimi-k2"
  }
}

सेव करने के बाद Claude Code रीस्टार्ट करें। रिक्वेस्ट https://kimrel.com/api/v1/messages पर जाएगी।

Codex

Codex CLI इंस्टॉल करें:

npm i -g @openai/codex

~/.codex/config.toml में kimrel.com कॉन्फ़िग जोड़ें:

[model_providers.kimi-k2]
name = "kimrel.com Chat Completions API"
base_url = "https://kimrel.com/api/v1"
env_key = "KIMREL_API_KEY"
wire_api = "chat"
requires_openai_auth = false
request_max_retries = 4
stream_max_retries = 10
stream_idle_timeout_ms = 300000

[profiles.k2]
model = "kimi-k2"
model_provider = "kimi-k2"

[profiles.k2.5]
model = "kimi-k2.5"
model_provider = "kimi-k2"

API key सेट करें और Codex चलाएँ:

export KIMREL_API_KEY="<YOUR_API_KEY>"

codex --profile k2.5

प्रमाणीकरण

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
}

मॉडल

kimrel.com नीचे दिए गए supported model routes के लिए ये model IDs उपलब्ध कराता है। Kimi K2 family models को Moonshot AI ने विकसित किया है; kimrel.com एक independent access layer प्रदान करता है, न कि model developer की official product branding।

उपलब्ध मॉडल

मॉडल चयन

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

• 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.6: kimrel.com पर नवीनतम K2.6 route के लिए recommended। यह text + image understanding, thinking mode और tool calling को सपोर्ट करता है। इस सेवा पर video input समर्थित नहीं है।

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

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

Kimi K2.6 त्वरित शुरुआत

kimi-k2.6 kimrel.com पर उपलब्ध नवीनतम K2.6 route है। यदि आपको बेहतर reasoning, image understanding और tool-enabled workflows चाहिए, तो यह इस सेवा का सबसे उपयुक्त विकल्प है। kimrel.com पर K2.6, 256K context window, text + image inputs, tool calling, और OpenAI-compatible /v1/chat/completions endpoint पर thinking mode सपोर्ट करता है। इस सेवा पर video input समर्थित नहीं है।

जब आप kimi-k2.6 को images भेजते हैं, तो आप या तो data:image/...;base64,... URL सीधे दे सकते हैं, या remote http(s) image URL भेज सकते हैं। kimrel.com server-side image fetch करता है, उसे validate करता है, base64 में convert करता है, और फिर upstream request भेजता है। इससे screenshot understanding और image reasoning workflows को existing clients में जोड़ना आसान हो जाता है।

OpenAI-compatible: K2.6 with thinking

{
  "model": "kimi-k2.6",
  "messages": [
    {
      "role": "user",
      "content": "कृपया पहले गहराई से सोचें, फिर सबसे अच्छा migration plan बताएं।"
    }
  ],
  "thinking": { "type": "enabled" },
  "max_completion_tokens": 2048
}

OpenAI-compatible: K2.6 image understanding

{
  "model": "kimi-k2.6",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "image_url",
          "image_url": {
            "url": "https://example.com/demo-ui.png"
          }
        },
        {
          "type": "text",
          "text": "चित्र का वर्णन करें और मुख्य UI elements की सूची दें।"
        }
      ]
    }
  ],
  "max_completion_tokens": 2048
}

kimi-k2.6 के लिए kimrel.com remote http(s) image URLs स्वीकार करता है और request upstream भेजने से पहले server-side उन्हें base64 में बदल देता है। यदि आपके पास पहले से data:image/...;base64,... URL है, तो उसे सीधे भेज सकते हैं। Video URLs इस सेवा द्वारा reject किए जाते हैं।

Kimrel पर image input limits:

• अधिकतम original image size: 6MB
• conversion के बाद अधिकतम encoded image payload: 8MB
• समर्थित image types: PNG, JPEG/JPG, WEBP, GIF
• Remote image URLs http(s) होने चाहिए और upstream भेजने से पहले server-side fetch किए जाते हैं
• Video inputs समर्थित नहीं हैं

Anthropic-compatible: K2.6 image input

{
  "model": "kimi-k2.6",
  "max_tokens": 2048,
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "image",
          "source": {
            "type": "url",
            "url": "https://example.com/demo-ui.png"
          }
        },
        {
          "type": "text",
          "text": "चित्र की सामग्री का वर्णन करें।"
        }
      ]
    }
  ]
}

Anthropic-compatible /v1/messages endpoint existing base64 image blocks को भी सपोर्ट करता है। Remote image URL fetching अभी केवल kimi-k2.6 के लिए enabled है, ताकि सेवा व्यवहार स्पष्ट और स्थिर रहे।

K2.6 tool calling example

{
  "model": "kimi-k2.6",
  "messages": [
    {
      "role": "user",
      "content": "मौसम tool का उपयोग करके Beijing और Shanghai की तुलना करें।"
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "किसी शहर का वर्तमान मौसम प्राप्त करें",
        "parameters": {
          "type": "object",
          "properties": {
            "city": { "type": "string" }
          },
          "required": ["city"]
        }
      }
    }
  ],
  "tool_choice": "auto",
  "max_completion_tokens": 1024
}

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

रेट लिमिट्स

रेट लिमिट्स 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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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://kimrel.com/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 क्रेडिट
• kimi-k2.6: प्रति API अनुरोध 3 क्रेडिट
• सफल 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://kimrel.com/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://kimrel.com/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 प्रमाणीकरण विधि पेश की गई