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. अकाउंट बनाएं और 10 मुफ्त क्रेडिट प्राप्त करें
2. अपने डैशबोर्ड से API key जनरेट करें
3. अपना पहला अनुरोध भेजें (usage आपके credits से input और output tokens के आधार पर bill होता है, और हर model का minimum charge होता है)

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

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.5, kimi-k2.6, kimi-k2.7-code, और kimi-k3 routes kimrel.com पर उपलब्ध हैं। ये models Moonshot AI ने विकसित किए हैं; kimrel.com एक independent interface है और Moonshot AI से संबद्ध, endorsed या sponsored नहीं है। 1M context, image understanding, long-horizon coding और advanced tool workflows के लिए kimi-k3 चुनें; kimi-k2.7-code coding-focused K2 route है।

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.5",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2.5",
      "parent": null
    },
    {
      "id": "kimi-k2.6",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2.6",
      "parent": null
    },
    {
      "id": "kimi-k2.7-code",
      "object": "model",
      "created": 1735785600,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k2.7-code",
      "parent": null
    },
    {
      "id": "kimi-k3",
      "object": "model",
      "created": 1784160000,
      "owned_by": "moonshot-ai",
      "permission": [...],
      "root": "kimi-k3",
      "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.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.7-code: long-horizon coding, coding agents, repository work और tool-assisted software engineering के लिए recommended। इस सेवा पर K2.7 Code text और image input सपोर्ट करता है, video input नहीं।
• kimi-k3: demanding long-context agents, repository-scale engineering, visual reasoning, structured output और advanced tool workflows के लिए recommended। K3 हमेशा reason करता है; K2.x के thinking object की जगह top-level reasoning_effort: "max" भेजें। Kimrel text और images सपोर्ट करता है, video नहीं।

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

kimi-k2.6 thinking mode को सपोर्ट करता है, जो स्पष्ट reasoning traces और tool-assisted problem solving वाले workflows में उपयोगी है।

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

Moonshot AI के 2.8T flagship model, 1M-token context, native image understanding, long-horizon coding और tool calling के लिए kimi-k3 उपयोग करें। K3 हमेशा reason करता है। OpenAI-compatible endpoint पर top-level reasoning_effort field भेजें; K2.x का thinking object न भेजें।

OpenAI-compatible K3 reasoning request

{
  "model": "kimi-k3",
  "messages": [
    {
      "role": "user",
      "content": "इस migration plan को review करें, सबसे risky assumption बताएँ और verification sequence सुझाएँ।"
    }
  ],
  "reasoning_effort": "max",
  "max_completion_tokens": 4096
}

OpenAI-compatible K3 image request

{
  "model": "kimi-k3",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "image_url",
          "image_url": {
            "url": "https://example.com/interface.png"
          }
        },
        {
          "type": "text",
          "text": "Interface का वर्णन करें और सबसे संभावित accessibility issues बताएँ।"
        }
      ]
    }
  ],
  "reasoning_effort": "max",
  "max_completion_tokens": 4096
}

Anthropic-compatible /v1/messages endpoint पर model को kimi-k3 रखें और required max_tokens दें; K3 default रूप से max reasoning उपयोग करता है। Multi-turn tool workflows में अगली request के साथ complete assistant message वापस भेजें, ताकि reasoning और tool-call history preserve रहे।

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, kimi-k2.7-code, और kimi-k3 के लिए 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, kimi-k2.7-code, और kimi-k3 के लिए enabled है, जो current service behavior से मेल खाता है।

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 उपयोग credit wallet के माध्यम से bill किया जाता है:

• Credits input और output token usage के आधार पर dynamically charge होते हैं
• Minimum charge: अधिकांश models में हर successful request के लिए minimum 1 credit
• kimi-k2.5: हर successful request के लिए minimum 2 credits
• kimi-k2.6: हर successful request के लिए minimum 3 credits
• kimi-k2.7-code: हर successful request के लिए minimum 3 credits
• kimi-k3: हर successful request के लिए minimum 3 credits
• Successful completion के बाद actual token usage के आधार पर final credits deduct होते हैं
• विफल अनुरोध (4xx) पर शुल्क नहीं लगता
• सर्वर त्रुटि (5xx) पर शुल्क नहीं लगता
• नए यूज़र को रजिस्ट्रेशन पर 10 मुफ्त क्रेडिट मिलते हैं
• इनवाइट रिवॉर्ड्स:
  • 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-09-05

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

2025-01-30

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