HI ▾
API कुंजी पाएँ

GLM API उदाहरण: Python, JSON मोड और स्ट्रीमिंग

ये सभी GLM API उदाहरण एक ही OpenAI-कम्पैटिबल एंडपॉइंट पर चलते हैं, बेस यूआरएल https://api.glmapikey.com/v1 और मॉडल uncensored के साथ। प्रत्येक स्निपेट छोटा और स्वयं-समावेशी है, ताकि आप इसे पेस्ट कर सकें, अपनी कुंजी जोड़ सकें और इसे चला सकें।

अपडेट किया गया

एक क्लाउड सर्वर को स्ट्रीमिंग चमकते हुए डेटा टोकन, API कोड उदाहरणों को दर्शाते हुए

मुख्य बिंदु

  • हर उदाहरण बेस URL https://api.glmapikey.com/v1, Bearer प्रमाणीकरण और मॉडल ID uncensored का उपयोग करता है।
  • स्ट्रीमिंग, JSON मोड और फ़ंक्शन कॉलिंग सभी समान चैट पूर्णता एंडपॉइंट पर समर्थित हैं।
  • प्रत्येक कॉल पर खर्च ट्रैक करने के लिए X-Balance-USD और उपयोग ब्लॉक पढ़ें।
  • 429 हैंडल करें कोड द्वारा: rate_limited, concurrency या Retry-After: 5 ओवरलोड।

कुछ भी चलाने से पहले

आपको एक कुंजी की आवश्यकता है और कुछ नहीं। 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 कुंजी लेख देखें।

प्रश्न और उत्तर

उदाहरण किस बेस URL का उपयोग करते हैं?

हर उदाहरण https://api.glmapikey.com/v1 का उपयोग करता है, मॉडल ID uncensored और एक Bearer टोकन के साथ। किसी भी OpenAI SDK को उन मानों को बदलने के बाद काम करना चाहिए।

क्या API स्ट्रीमिंग का समर्थन करता है?

हाँ। stream को true सेट करें और सर्वर-सेंट इवेंट्स पढ़ें। उपयोग स्ट्रीम के अंत में रिपोर्ट किया जाता है।

मुझे वैध JSON कैसे वापस मिलेगा?

response_format पास करें जिसका type json_object हो और प्रॉम्प्ट में वह संरचना वर्णित करें जिसे आप चाहते हैं। अपने कोड में परिणाम पार्स करें और उन कुंजियों की जांच करें जिनकी आपको आवश्यकता है।

क्या मैं फ़ंक्शन कॉलिंग का उपयोग कर सकता हूँ?

हाँ। tools और tool_choice पास करें, मॉडल द्वारा अनुरोधित फ़ंक्शन चलाएं, और परिणाम को role tool के साथ एक संदेश के रूप में लौटाएं।

मैं अपनी शेष क्रेडिट कहाँ देख सकता हूँ?

प्रत्येक प्रतिक्रिया में एक X-Balance-USD हेडर होता है जिसमें आपका शेष बैलेंस होता है, और उपयोग ब्लॉक टोकन गणना देता है।

आपकी कुंजी बस एक फ़ॉर्म दूर है

एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।

API कुंजी पाएँ