Kimi Code API URL: OpenAI क्लाइंटों के लिए बेस URL सेटअप

URL और प्रत्येक भाग का अर्थ

यदि आप kimi code api url की तलाश में हैं, तो आप संभवतः Kimi के अपने सेवा के पते की तलाश में हैं। इसके लिए, आपूर्तिकर्ता की दस्तावेज़ीकरण का उपयोग करें, क्योंकि मैं उसकी पुष्टि नहीं कर सकता। यह साइट एक अलग चीज़ चलाती है: एक स्वतंत्र प्रदाता द्वारा चलाए जाने वाले एक ओपन-वेट मॉडल के सामने एक होस्टेड, OpenAI-संगत API। इसका पता है:

Copyhttps://api.kimicode.cc/v1

वह स्ट्रिंग base URL है। यह वह भाग है जो प्रत्येक अनुरोध में साझा होता है। SDK शेष भाग जोड़ता है। जब आप chat.completions.create कॉल करते हैं, तो OpenAI लाइब्रेरी https://api.kimicode.cc/v1/chat/completions पर एक POST भेजती है। मॉडल सूची https://api.kimicode.cc/v1/models पर स्थित है और एक GET लेती है।

ये दोनों विधियाँ इस API द्वारा प्रदान की जाने वाली एकमात्र विधियाँ हैं: POST /v1/chat/completions और GET /v1/models। यदि आप इमेज, ऑडियो या एम्बेडिंग एंडपॉइंट्स की उम्मीद कर रहे थे, तो वे यहाँ मौजूद नहीं हैं। यह एक टेक्स्ट API है।

तीन सेटिंग्स मायने रखती हैं, और आपके मौजूदा OpenAI कोड में कुछ और बदलने की आवश्यकता नहीं है: base URL, API कुंजी, और मॉडल ID uncensored।

base URL ही एकमात्र स्विच क्यों है

OpenAI-शैली के क्लाइंट एक ही विचार पर आधारित हैं: अनुरोध प्रारूप स्थिर होता है, और होस्ट एक सेटिंग है। लाइब्रेरी में एक डिफ़ॉल्ट होस्ट होता है जो मूल विक्रेता की ओर इशारा करता है। जब आप इसे किसी अन्य बेस URL से बदलते हैं, तो वही अनुरोध बॉडी किसी अन्य स्थान पर जाती है। आपके प्रॉम्प्ट, संदेश सरणी या प्रतिक्रिया पार्सिंग में कुछ भी बदलने की आवश्यकता नहीं है।

यही कारण है कि किसी अन्य OpenAI-संगत प्रदाता से माइग्रेशन आमतौर पर तीन संपादन होते हैं: base URL, कुंजी, और मॉडल नाम। प्रतिक्रिया में फ़ील्ड्स, जैसे choices, message, finish_reason और usage, वही नाम रखते हैं, इसलिए उन्हें पढ़ने वाला कोड काम करता रहता है।

यह उन अजीब त्रुटियों को भी समझाता है जिनका सामना लोग करते हैं। यदि कोई टूल "सर्वर URL" मांगता है और आप केवल होस्ट पेस्ट करते हैं, तो पथ गायब है। यदि कोई टूल "पूर्ण एंडपॉइंट" मांगता है और आप बेस पेस्ट करते हैं, तो अनुरोध गलत स्थान पर जाता है। जब सेटिंग्स स्क्रीन अस्पष्ट हो, तो पहले बेस URL आज़माएं और वापस आने वाले स्टेटस कोड को पढ़ें। दस्तावेज़ों में क्विकस्टार्ट एक और उदाहरण के साथ उसी माइग्रेशन को चलाता है।

उन टूल्स के लिए एन्वायरनमेंट वेरिएबल्स जिन्हें आप एडिट नहीं कर सकते

कई कमांड-लाइन टूल्स और फ्रेमवर्क बिना कंस्ट्रक्टर को छुए एक OpenAI क्लाइंट बनाते हैं। वे आमतौर पर मानक एन्वायरनमेंट वेरिएबल्स पढ़ते हैं, इसलिए उन्हें सेट करना पर्याप्त है:

Copyexport OPENAI_BASE_URL="https://api.kimicode.cc/v1"
export OPENAI_API_KEY="YOUR_KEY"

कुछ पुराने टूल्स OPENAI_API_BASE की तलाश करते हैं, इसलिए यदि पहला नाम अनदेखा कर देता है, तो दूसरा आज़माएँ। सेट करने के बाद, टूल को उसी शेल सत्र में शुरू करें, क्योंकि अन्य टर्मिनल विंडो में सेट किए गए वेरिएबल्स साझा नहीं होते हैं।

टूल को अभी भी एक मॉडल नाम की आवश्यकता होगी। यदि यह एक होस्टेड मॉडल को हार्ड-कोड करता है, तो उसे सेट करने के लिए एक फ्लैग या कॉन्फ़िग लाइन खोजें, और uncensored का उपयोग करें। यदि इसे बदला नहीं जा सकता, तो टूल उपयुक्त नहीं है, और ऊपर दिए गए छोटे स्क्रिप्ट जैसे एक बेहतर मार्ग हैं।

पहले एक कुंजी प्राप्त करें

अनुरोधों को Authorization: Bearer YOUR_KEY रूप के हेडर से प्रमाणीकृत किया जाता है। हर आधिकारिक SDK api_key तर्क से उस हेडर को आपके लिए बनाता है। आप Google या ईमेल और पासवर्ड से साइन इन करने के बाद कुंजी बना सकते हैं।

नए खातों API कुंजी पृष्ठ पर एक क्लिक से $0.50 का ट्रायल क्रेडिट दावा कर सकते हैं। इसके लिए कार्ड की आवश्यकता नहीं है और यह 7 दिनों तक चलता है। यह नीचे दिए गए हर उदाहरण को कई बार चलाने के लिए पर्याप्त है। ट्रायल कुंजियाँ 2 समकालीय अनुरोधों और प्रति मिनट 60 अनुरोधों की अनुमति देती हैं, इसलिए उदाहरणों को एक-एक करके चलाएं।

कुंजी को स्रोत फ़ाइलों में रखने के बजाय एक एन्वायरनमेंट वेरिएबल में स्टोर करें। एक कुंजी जो एक सार्वजनिक रिपॉज़िटरी में कमीट हो गई है, उसे कुछ ही घंटों में कोई और खोजकर उपयोग कर लेगा, और और उसमें मौजूद क्रेडिट आपका है।

curl में पहला अनुरोध

curl URL काम करता है यह साबित करने का सबसे तेज़ तरीका है, क्योंकि यह हर लाइब्रेरी को दृश्य से हटा देता है। यदि यह कॉल सफल होती है, तो बाद में आप जिस भी समस्या का सामना करेंगे वह आपके क्लाइंट कॉन्फ़िगरेशन में है।

Copyexport KIMICODE_KEY="YOUR_KEY"

curl https://api.kimicode.cc/v1/models   -H "Authorization: Bearer $KIMICODE_KEY"

curl https://api.kimicode.cc/v1/chat/completions   -H "Authorization: Bearer $KIMICODE_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "messages": [
      {"role": "user", "content": "Say hello in five words."}
    ]
  }'

पहला कॉल मॉडल सूची लौटाता है, जिसमें uncensored शामिल होना चाहिए। दूसरा एक मानक चैट पूर्णता ऑब्जेक्ट लौटाता है। curl -i के साथ प्रतिक्रिया हेडर देखें और आपको X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests और X-RateLimit-Limit-Concurrency दिखेंगे। यदि आप किसी विशिष्ट कॉल के बारे में support से संपर्क करते हैं, तो अनुरोध ID को बनाए रखें।

OpenAI SDK के साथ Python

pip install openai से लाइब्रेरी इंस्टॉल करें, फिर क्लाइंट कंस्ट्रक्टर पर दो आर्गुमेंट बदलें।

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.kimicode.cc/v1",
    api_key=os.environ["KIMICODE_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain what a base URL is in two sentences."},
    ],
    temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage)

temperature, top_p, stop, seed जैसे पैरामीटर और फ्रीक्वेंसी व प्रेजेंस पेनल्टीज़ मॉडल को पास की जाती हैं। max_tokens वैल्यू ऑप्शनल है। इसके बिना, कम्प्लीशन 100,000-टोकन विंडो की बची हुई मात्रा का उपयोग कर सकती है, जो प्रॉम्प्ट और कम्प्लीशन को मिलाकर है।

यदि आप आर्गुमेंट पास नहीं करते हैं, तो SDK दो एनवायरनमेंट वेरिएबल भी पढ़ता है: OPENAI_BASE_URL और OPENAI_API_KEY। यह उन टूल्स के लिए उपयोगी है जिन्हें आप एडिट नहीं कर सकते। दोनों सेट करें, टूल लॉन्च करें, और वह इस API से बात करेगा।

Node, स्ट्रीमिंग और JSON मोड

Node सेटअप Python जैसा ही है। npm install openai से इंस्टॉल करें।

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.kimicode.cc/v1",
  apiKey: process.env.KIMICODE_KEY,
});

// Streaming over SSE
const stream = await client.chat.completions.create({
  model: "uncensored",
  stream: true,
  messages: [{ role: "user", content: "Write a four-line poem about routers." }],
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

// JSON mode
const json = await client.chat.completions.create({
  model: "uncensored",
  response_format: { type: "json_object" },
  messages: [
    { role: "system", content: "Reply with a JSON object only." },
    { role: "user", content: "Give me keys name and port for a local dev server." },
  ],
});
console.log(JSON.parse(json.choices[0].message.content));

स्ट्रीमिंग सर्वर-सेंट इवेंट्स का उपयोग करती है और उपयोग स्ट्रीम के अंत में रिपोर्ट किया जाता है। एक स्ट्रीम किए गए अनुरोध में उसका समकालीय अनुरोध स्लॉट तब तक बनी रहती है जब तक कि स्ट्रीम समाप्त न हो जाए, इसलिए एक क्लाइंट जो स्ट्रीम खोलता है और उसे कभी नहीं पढ़ता, वह एक स्लॉट को ब्लॉक कर देगा। JSON मोड में, प्रॉम्प्ट में मॉडल को JSON में उत्तर देने के लिए अभी भी बताएं। फ्लैग आउटपुट फॉर्मेट को बाध्य करता है, लेकिन एक स्पष्ट निर्देश आपको बेहतर फ़ील्ड नाम देता है।

टूल कॉलिंग

टूल्स सामान्य OpenAI संरचना का उपयोग करते हैं: एक tools सूची, एक वैकल्पिक tool_choice, और टूल परिणाम role: "tool" वाले संदेशों के रूप में वापस भेजे जाते हैं। स्ट्रीमिंग के दौरान, tool_calls चंक्स के बीच टुकड़ों में आते हैं।

Copyimport json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.kimicode.cc/v1", api_key=os.environ["KIMICODE_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_port",
        "description": "Look up the port of a named local service",
        "parameters": {
            "type": "object",
            "properties": {"service": {"type": "string"}},
            "required": ["service"],
        },
    },
}]

messages = [{"role": "user", "content": "Which port does the api service use?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]

messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": call.id,
    "content": json.dumps({"service": "api", "port": 8080}),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)

मॉडल से आने वाले तर्कों को अविश्वसनीय इनपुट मानें। कुछ भी चलाने से पहले उन्हें सत्यापित करें। मॉडल एक टूल कॉल छोड़ सकता है या किसी भी मॉडल की तरह इसे गलत फ़ील्ड के साथ कॉल कर सकता है, इसलिए अपने लूप में एक फॉलबैक पाथ रखें।

जब URL विफल हो जाए

अधिकांश विफलताएं एक छोटी सूची में आती हैं।

• 404 नहीं मिला। पथ गलत है। सामान्य कारण: बेस URL को https://api.kimicode.cc पर सेट किया गया था, /v1 के बिना, या https://api.kimicode.cc/v1/chat/completions पर, जिससे क्लाइंट पथ को दो बार जोड़ देता है। ऊपर दिए गए बेस URL का ही उपयोग करें।
• 401 अनधिकृत। कुंजी गायब है, उसमें अतिरिक्त स्पेस या न्यूलाइन है, या हेडर Bearer टोकन नहीं है। जाँच करने के लिए वेरिएबल की लंबाई प्रिंट करें।
• 429 कोड rate_limited के साथ। आपने प्रति मिनट की सीमा पार कर दी: पूर्ण कुंजी के लिए 300 अनुरोध और परीक्षण कुंजी के लिए 60।
• 429 कोड के साथ concurrency। एक साथ बहुत सारे अनुरोध: फुल कुंजी के लिए 8, ट्रायल कुंजी के लिए 2।
• हेडर Retry-After: 5 के साथ 429। अस्थायी ओवरलोड। पांच सेकंड प्रतीक्षा करें और पुनः प्रयास करें।
• अनुरोध बहुत बड़ा है। बॉडी की सीमा 8 MB है, और प्रॉम्प्ट और कम्प्लीशन को 100,000 टोकन में फिट होना चाहिए।

एक रीट्राई लूप जो Retry-After का सम्मान करता है और अन्य दो कोड पर बैकऑफ़ करता है, इसका लगभग सभी हिस्सा संभाल लेता है। कॉल का खर्च कम है; मूल्य निर्धारण पृष्ठ में प्रति टोकन दरें हैं, और दस्तावेज़ीकरण क्विकस्टार्ट में किसी अन्य OpenAI-शैली के प्रोवाइडर से माइग्रेशन स्टेप्स दिखाए गए हैं।

रीट्राई और उत्पादन आदतें

एक बार जब पहली कॉल काम कर लेती है, तो शिप करने से पहले एक रीट्राई व्रैपर जोड़ें। जब यह मौजूद हो तो Retry-After हेडर का सम्मान करें और अन्यथा एक छोटे यादृच्छिक विलंब के साथ बैकऑफ़ करें।

Copyimport os, time, random
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.kimicode.cc/v1", api_key=os.environ["KIMICODE_KEY"])

def ask(messages, tries=5):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as err:
            retry_after = 5
            if getattr(err, "response", None) is not None:
                retry_after = int(err.response.headers.get("retry-after", 5))
            time.sleep(retry_after + random.random())
    raise RuntimeError("still rate limited after retries")

अपनी समकालीयता को अपनी कुंजी से मेल खाने के लिए कैप करें: फुल कुंजी के लिए 8 का थ्रेड पूल, ट्रायल कुंजी के लिए 2। यह concurrency त्रुटि को शुरू होने से पहले ही रोक देता है, और यह आपको प्रति मिनट 300 अनुरोध की सीमा के भीतर भी रखता है, जब हर कॉल में कुछ सेकंड से अधिक समय लगे।

अंत में, यह याद रखें कि आप प्रति टोकन के लिए भुगतान करते हैं। हर कॉल के लिए usage ऑब्जेक्ट लॉग करें, और X-Balance-USD हेडर पर नज़र रखें। 1M इनपुट टोकन के लिए $0.15 और 1M आउटपुट टोकन के लिए $0.50 पर, एक सामान्य चैट टर्न एक सेंट का अंश होता है, लेकिन लूप और लंबे इतिहास जुड़ जाते हैं, और लॉग आपको बताता है कि कहाँ।

अधिक गाइड

• Kimi Code API मूल्य निर्धारण बनाम उपयोग-आधारित टोकन
• Cursor में Kimicode वैकल्पिक: कस्टम एंडपॉइंट सेटअप
• Groq API: बिना सेंसर LLMs के लिए मिथक बनाम तथ्य