कुछ भी चलाने से पहले
आपको एक कुंजी की आवश्यकता है और कुछ नहीं। API कुंजी पृष्ठ पर एक बनाएं; नए खातों में एक क्लिक से बिना कार्ड के $0.50 का मुफ़्त ट्रायल क्रेडिट क्लेम कर सकते हैं। इसे निर्यात करें ताकि उदाहरण इसे पढ़ सकें:
export API_KEY="YOUR_KEY"
pip install openai
npm install openai
API OpenAI चैट पूर्णता प्रारूप का पालन करता है। यह POST /v1/chat/completions और GET /v1/models को उजागर करता है, Authorization: Bearer स्वीकार करता है, और uncensored ID वाले एकल मॉडल को सेवा देता है। वह मॉडल एक स्वतंत्र प्रदाता द्वारा चलाया जाने वाला एक ओपन-वेट मॉडल है और कानूनी वयस्क उपयोग के लिए बिना सेंसर उत्तर देने के लिए ट्यून्ड किया गया है। यह किसी मॉडल विक्रेता की आधिकारिक API नहीं है। यह केवल पाठ संभालता है: कोई छवि, ऑडियो, एम्बेडिंग या फाइन-ट्यूनिंग नहीं।
नीचे दिए गए उदाहरण सबसे सरल कॉल से लेकर फ़ंक्शन कॉलिंग तक जाते हैं। यदि आपको केवल यह जांचने के लिए सबसे छोटा संभव परीक्षण चाहिए कि आपकी कुंजी काम कर रही है, तो पहला curl कमांड पर्याप्त है।
curl के साथ एक प्रारंभिक अनुरोध, और मायने रखने वाले पैरामीटर
curl https://api.glmapikey.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "What is a mutex, in one sentence?"}
],
"temperature": 0.3,
"max_tokens": 80
}'
प्रतिक्रिया एक JSON ऑब्जेक्ट है जिसमें choices[0].message.content उत्तर रखता है और एक usage ऑब्जेक्ट जिसमें prompt_tokens और completion_tokens हैं। प्रतिक्रिया हेडर में X-Request-Id, X-Balance-USD और दो X-RateLimit-Limit हेडर शामिल हैं। उन्हें देखने के लिए curl में -i जोड़ें।
temperature, top_p, stop, seed फ़ील्ड और उपस्थिति व आवृत्ति पेनल्टी मॉडल को पास की जाती हैं। max_tokens वैकल्पिक है। इसके बिना, पूरा होने वाले टेक्स्ट में आपकी प्रॉम्प्ट के बाद 100,000-टोकन विंडो में जो कुछ भी बचा है, उसे उपयोग किया जा सकता है।
चैट पूर्णता बॉडी में कई वैकल्पिक फ़ील्ड हैं, लेकिन पांच सबसे ज्यादा काम करते हैं। सभी को मॉडल को पास किया जाता है।
| फ़ील्ड | यह क्या करता है | सामान्य उपयोग |
|---|---|---|
temperature | उच्च मान अधिक विविध शब्दावली देते हैं | निकालने के लिए 0.2, कथा के लिए 0.8 |
top_p | सैंपलिंग को सबसे संभावित टोकन तक सीमित करता है | जब तक आप इसे ट्यून न करें, डिफ़ॉल्ट पर छोड़ दें |
stop | जब एक स्ट्रिंग मिलती है तो उत्तर समाप्त करता है | एक विभाजक जैसे कि एक खाली पंक्ति पर काटें |
seed | बेस्ट-एफ़र्ट आधार पर सैंपलिंग को दोहराने योग्य बनाता है | दो प्रॉम्प्ट संस्करणों की तुलना |
presence_penalty, frequency_penalty | टोकन के दोहराव को कमजोर करता है | छोटे मान जैसे 0.3 जब पाठ लूप होता है |
एक बार में एक मान बदलें और प्रॉम्प्ट को समान रखें, अन्यथा आप यह नहीं बता सकते कि किस बदलाव ने मदद की। किसी भी कोड इनपुट वाले कार्य के लिए, जैसे वर्गीकरण या निकालना, एक निम्न तापमान और एक स्थिर बीज का उपयोग करें ताकि आप एक परीक्षण को पुनः चला सकें और समान परिणाम देख सकें। रचनात्मक लेखन के लिए, तापमान बढ़ाएं और पेनल्टी को दोहराव संभालने दें।
यहाँ max_tokens क्षेत्र वैकल्पिक है। जब आप इसे छोड़ देते हैं, तो प्रतिक्रिया 100,000-टोकन विंडो में बचे पूरे स्थान का उपयोग कर सकती है, जो एक एक-लाइन उत्तर के लिए आमतौर पर आपकी इच्छा नहीं होती है। जब आप जानते हैं कि उत्तर कितना लंबा होना चाहिए, तो इसे सेट करें।
Python: स्मृति के साथ एक संवाद
API स्टेटलेस है, इसलिए आप संवाद स्वयं रखते हैं और हर बार उसे भेजते हैं। यह लूप संदेशों की एक सूची रखता है और दोनों पक्षों को जोड़ता है:
from openai import OpenAI
client = OpenAI(
base_url="https://api.glmapikey.com/v1",
api_key="YOUR_KEY",
)
messages = [{"role": "system", "content": "You are a helpful assistant."}]
while True:
user = input("you> ")
if not user:
break
messages.append({"role": "user", "content": user})
resp = client.chat.completions.create(model="uncensored", messages=messages)
reply = resp.choices[0].message.content
messages.append({"role": "assistant", "content": reply})
print("bot>", reply)
चूंकि प्रत्येक कॉल पूरी सूची फिर से भेजती है, इनपुट टोकन चैट की लंबाई के साथ बढ़ते हैं। 1M इनपुट टोकन के लिए $0.15 की दर से यह सस्ता है, लेकिन लंबे सत्रों में यह जुड़ जाता है, इसलिए उस साइज तक पहुंचने पर पुराने संदेश काट दें जितने के लिए आप भुगतान करना चाहते हैं। मूल्य निर्धारण पृष्ठ पर काम करने वाले उदाहरण दिए गए हैं।
Python और Node में स्ट्रीमिंग
stream: true सेट करें और सर्वर टोकन को तभी भेजता है जब वे उत्पन्न होते हैं, SSE के माध्यम से। Python में:
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write four lines about the sea."}],
stream=True,
)
text = ""
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
text += piece
print(piece, end="", flush=True)
if getattr(chunk, "usage", None):
print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
स्ट्रीम उपयोग जानकारी के साथ समाप्त होती है, इसलिए लूप उसकी जांच करता है। Node में वही:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.glmapikey.com/v1",
apiKey: process.env.API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Write four lines about the sea." }],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
सीमाओं के बारे में एक विवरण: स्ट्रीम किया गया अनुरोध स्ट्रीम समाप्त होने तक अपना कॉन्करेंसी स्लॉट रखता है। यदि आप एक स्ट्रीम शुरू करते हैं और कभी अंत तक नहीं पढ़ते, तो वह स्लॉट व्यस्त रहता है। हमेशा स्ट्रीम को उपभोग करें या बंद करें।
संरचित आउटपुट के लिए JSON मोड
जब आपके कोड को उत्तर को पार्स करने की आवश्यकता हो, तो response_format के साथ एक JSON ऑब्जेक्ट मांगें। साथ ही प्रॉम्प्ट में बताएं कि आप कौन सी संरचना चाहते हैं, क्योंकि फॉर्मेट फ्लैग वैध JSON सिंटैक्स की गारंटी देता है, आपका विशिष्ट स्कीमा नहीं।
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}."},
{"role": "user", "content": "Suggest a title and three tags for a post about home espresso."},
],
temperature=0.2,
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
उपयोग करने से पहले जांच लें कि आपको जिन कुंजियों की आवश्यकता है वे मौजूद हैं, और निकालने के कार्य के लिए तापमान को कम रखें। यदि पार्स विफल हो जाता है, तो समान इनपुट के साथ एक बार पुनः प्रयास करने से आमतौर पर काम बन जाता है, और विफल अनुरोधों के लिए भुगतान नहीं किया जाता है।
टूल कॉलिंग: एक पूर्ण राउंड ट्रिप
टूल कॉलिंग मॉडल को आपके कोड को एक फ़ंक्शन चलाने के लिए कहने देती है। आप फ़ंक्शन को tools में वर्णित करते हैं, मॉडल एक tool_calls प्रविष्टि के साथ उत्तर देता है, आप इसे चलाते हैं और परिणाम को एक role: "tool" संदेश के रूप में वापस भेजते हैं।
import json
def get_weather(city: str) -> dict:
return {"city": city, "temp_c": 18, "sky": "cloudy"}
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
messages = [{"role": "user", "content": "Is it warm in Lisbon right now?"}]
first = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(get_weather(**args)),
})
final = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools
)
print(final.choices[0].message.content)
else:
print(msg.content)
यहां फ़ंक्शन स्थिर डेटा लौटाता है, इसलिए इसे असली लुकअप से बदलें। टूल तर्क एक JSON स्ट्रिंग के रूप में आते हैं, इसलिए उन पर कार्य करने से पहले हमेशा उन्हें पार्स करें और मानों को सत्यापित करें। stream: true के साथ, tool_calls टुकड़ों में आते हैं जिन्हें पार्स करने से पहले आप एकत्र करते हैं। जब आपको किसी विशिष्ट टूल की आवश्यकता हो तो tool_choice का उपयोग करें।
उदाहरणों की लागत और वे गलतियां जो एक घंटा बर्बाद करती हैं
उदाहरण चलाने में बहुत कम लागत आती है, लेकिन एक बार अंकगणित देखने में मदद मिलती है। 1M इनपुट टोकन के लिए $0.15 और 1M आउटपुट टोकन के लिए $0.50 पर:
- संवाद लूप, एक 1,200-टोकन प्रॉम्प्ट और एक 300-टोकन उत्तर के साथ: इनपुट के लिए $0.00018 और आउटपुट के लिए $0.00015 है जो $0.00033 के बराबर है। एक हजार टर्न्स की लागत $0.33 है।
- टूल राउंड ट्रिप दो कॉल करता है। यदि पहली 400 टोकन इन और 60 आउट उपयोग करती है, और दूसरी 500 इन और 150 आउट, तो कुल 900 इन और 210 आउट होते हैं: $0.000135 जमा $0.000105 बराबर $0.00024।
- स्ट्रीमिंग की लागत समान टोकन गणना वाले एक सामान्य कॉल के समान ही है। यह तब बदलता है जब आप पाठ देखते हैं, न कि इसकी लागत।
$0.50 का मुफ़्त ट्रायल क्रेडिट उस आकार पर संवाद लूप के 1,500 से अधिक टर्न्स के लिए भुगतान कर सकता है ($0.50 / $0.00033), इसलिए आप टॉप-अप करने से पहले स्वतंत्र रूप से प्रयोग कर सकते हैं। विफल और अस्वीकृत अनुरोधों के लिए भुगतान नहीं किया जाता है, जिसका अर्थ है कि आपके पार्सिंग में एक बग जो आपको एक कॉल को पुनः चलाने पर मजबूर करता है, आपके लिए विफल प्रयासों के लिए लागत नहीं होता है।
- गलत बेस URL। इसे
/v1पर समाप्त होना चाहिए। यदि आप SDK के बेस URL में/chat/completionsजोड़ते हैं, तो 404 त्रुटि आएगी क्योंकि SDK स्वयं यह पथ जोड़ देता है। - अलग मॉडल नाम। अन्य प्लेटफ़ॉर्म से कॉपी किए गए नाम यहाँ मौजूद नहीं हैं। ID
uncensoredहै। - मेमोरी की उम्मीद। API पिछले अनुरोधों को याद नहीं रखती। हर बार इतिहास भेजें।
- बिना सुरक्षा के मॉडल JSON पार्स करना।
json.loadsको try ब्लॉक में रखें और खराब प्रतिक्रिया के लिए एक योजना बनाएं। - स्ट्रीम खुले छोड़ना। एक अधूरा स्ट्रीम एक कॉन्करेंसी स्लॉट को व्यस्त रखता है, और एक ट्रायल कुंजी में केवल दो स्लॉट होते हैं।
- API कुंजी को फ्रंट-एंड कोड में डालना। इसे सर्वर पर रखें।
यदि कुछ अभी भी गलत दिखता है, तो curl के साथ एक अनुरोध भेजें और तुलना करें कि आपका कोड क्या बनाता है। curl का प्रयोग SDK को हटा देता है और बॉडी में अंतर को स्पष्ट बनाता है।
उपयोग, बैलेंस और त्रुटियों को पढ़ना
Python SDK से हेडर देखने के लिए, कच्चे प्रतिक्रिया रैपर का उपयोग करें:
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("x-request-id"))
print("balance usd:", raw.headers.get("x-balance-usd"))
print("rpm limit:", raw.headers.get("x-ratelimit-limit-requests"))
completion = raw.parse()
print(completion.usage.total_tokens)
हर कॉल के साथ रिक्वेस्ट ID लॉग करें ताकि आप बाद में किसी एक रिक्वेस्ट की ओर इशारा कर सकें। क्रेडिट खत्म होने से पहले अलर्ट उठाने के लिए बैलेंस हेडर का उपयोग करें।
जब आप एक लिमिट पार करते हैं, तो API HTTP 429 लौटाता है, और त्रुटि कोड बताता है कि कौन सी:
| कोड या हेडर | क्या करें | क्या करें |
|---|---|---|
rate_limited | प्रति मिनट बहुत सारे अनुरोध (फुल कुंजी पर 300, ट्रायल पर 60) | बैक ऑफ़ करें और कॉल्स को फैलाएं |
concurrency | एक साथ बहुत सारे (फुल कुंजी पर 8, ट्रायल पर 2) | चल रहे रिक्वेस्ट के खत्म होने का इंतज़ार करें |
Retry-After: 5 | अस्थायी ओवरलोड | पांच सेकंड बाद पुनः प्रयास करें |
असफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है। अनुरोध बॉडी 8 MB तक हो सकती है। पूर्ण संदर्भ के लिए और मौजूदा क्लाइंट कोड को पुन: उपयोग करने के तरीके के लिए, दस्तावेज़ देखें। कुंजी प्राप्त करने के तरीके के लिए, GLM API कुंजी लेख देखें।
