सबसे पहले इंटीग्रेशन पैटर्न चुनें
अधिकांश GLM API इंटीग्रेशन कार्य चार पैटर्न में से किसी एक में आता है, और यह चयन बाकी सब कुछ प्रभावित करता है: गुप्त कुंजी कहाँ रहती है, आप बर्स्ट्स को कैसे संभालते हैं और उपयोगकर्ता के लिए विफलता कैसी दिखती है।
| पैटर्न | इसके लिए अच्छा | मुख्य जोखिम |
|---|---|---|
| बैकएंड प्रॉक्सी | वेब ऐप्स और मोबाइल ऐप्स जिनके अपने उपयोगकर्ता हैं | वह एंडपॉइंट जिसे कोई भी खाली कर सकता है |
| क्यू वर्कर | बॉट्स, बैच जॉब्स, बल्क टेक्स्ट प्रोसेसिंग | जब अनुरोध सीमाओं से तेज़ हों तो बैकलॉग |
| चैट बॉट | Discord, Telegram या Matrix के किरदार और साथी | लंबा चैट इतिहास लागत बढ़ा देता है |
| ऑटोमेशन टूल | उन टूल्स में वर्कफ़्लो जो HTTP या OpenAI नोड प्रदान करते हैं | जब कोई चरण त्रुटि देता है तो साइलेंट विफलता |
चारों के अंत में एक ही कॉल होती है: POST /v1/chat/completions https://api.glmapikey.com/v1 पर, Bearer कुंजी और मॉडल uncensored के साथ। API OpenAI-संगत है, इसलिए आप किसी भी OpenAI SDK का उपयोग कर सकते हैं, या यदि आपकी स्टैक में SDK नहीं है तो raw HTTP। यह एक ओपन-वेट मॉडल है जो एक स्वतंत्र प्रदाता द्वारा चलाया जाता है, किसी भी विक्रेता की आधिकारिक API नहीं और न ही एक राउटर, इसलिए एक मॉडल के व्यवहार के लिए बनाएं। केवल टेक्स्ट: यदि आपके उत्पाद को छवियों या एम्बेडिंग्स की भी आवश्यकता है, तो उन भागों के लिए एक दूसरे प्रदाता की योजना बनाएं।
दस्तावेज़ पृष्ठ एंडपॉइंट्स और हेडर सूचीबद्ध करता है, और GLM कुंजी लेख बताता है कि कुंजी कैसे प्राप्त करें।
बैकएंड प्रॉक्सी: कुंजी को क्लाइंट से दूर रखें
ब्राउज़र या ऐप बंडल में जो भी चलता है उसे देखा जा सकता है। यदि कुंजी वहाँ भेजी जाती है, तो कोई भी इसे कॉपी कर सकता है और आपका क्रेडिट खर्च कर सकता है। समाधान एक पतला सर्वर रूट है जो कुंजी को रखता है, अपने नियम लागू करता है और अनुरोध को आगे बढ़ाता है।
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import AsyncOpenAI
from pydantic import BaseModel
app = FastAPI()
client = AsyncOpenAI(
base_url="https://api.glmapikey.com/v1",
api_key="YOUR_KEY",
)
class Ask(BaseModel):
prompt: str
@app.post("/ask")
async def ask(body: Ask):
async def gen():
stream = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": body.prompt[:4000]}],
max_tokens=600,
stream=True,
)
async for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
yield chunk.choices[0].delta.content
return StreamingResponse(gen(), media_type="text/plain")
रूट प्रॉम्प्ट को ट्रंक करता है और जवाब को कैप करता है, जो कि न्यूनतम है। लॉन्च से पहले वास्तविक नियंत्रण जोड़ें: उपयोगकर्ता प्रमाणीकरण, प्रति-उपयोगकर्ता दैनिक टोकन बजट, और प्रति IP या खाते अनुरोध दर पर सीमा। API हर कॉल पर उपयोग लौटाता है, इसलिए आप अपने डेटाबेस में प्रति उपयोगकर्ता टोकन गिन सकते हैं और उन अनुरोधों को अस्वीकार कर सकते हैं जो उनकी हिस्सेदारी से अधिक हैं।
प्रॉक्सी के माध्यम से स्ट्रीमिंग को एक जाँच की आवश्यकता है: पुष्टि करें कि आपका रिवर्स प्रॉक्सी प्रतिक्रियाओं को बफर नहीं करता है, या टेक्स्ट शब्द-दर-शब्द आने के बजाय अंत में एक ब्लॉक में आएगा।
क्यू वर्कर: समानांतरता सीमा का सम्मान करें
सीमाएँ प्रति कुंजी होती हैं। एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोध की अनुमति देती है। एक ट्रायल कुंजी 2 और 60 की अनुमति देती है। कार्यों के निरंतर स्ट्रीम के लिए, समानांतरता आमतौर पर वह होती है जो पहले बांधती है, क्योंकि प्रत्येक अनुरोध एक स्लॉट को तब तक घेरता रहता है जब तक कि यह पूरा न हो जाए, और एक स्ट्रीम वाला तब तक जब तक स्ट्रीम समाप्त न हो जाए।
सीमा के बराबर आकार वाला वर्कर पूल ही स्पष्ट उत्तर है। जॉब्स आपकी कतार में प्रतीक्षा करते हैं, 429 के साथ विफल होने के बजाय:
import asyncio
from openai import AsyncOpenAI, RateLimitError
client = AsyncOpenAI(
base_url="https://api.glmapikey.com/v1",
api_key="YOUR_KEY",
max_retries=0,
)
WORKERS = 8 # use 2 on a trial key
async def run_job(prompt: str) -> str:
for attempt in range(5):
try:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
max_tokens=500,
)
return r.choices[0].message.content
except RateLimitError as e:
delay = float(e.response.headers.get("retry-after", 2 * (attempt + 1)))
await asyncio.sleep(delay)
raise RuntimeError("gave up after repeated 429 responses")
async def worker(queue: asyncio.Queue, results: list):
while True:
prompt = await queue.get()
try:
results.append(await run_job(prompt))
finally:
queue.task_done()
async def main(prompts):
queue, results = asyncio.Queue(), []
for p in prompts:
queue.put_nowait(p)
tasks = [asyncio.create_task(worker(queue, results)) for _ in range(WORKERS)]
await queue.join()
for t in tasks:
t.cancel()
return results
429 बॉडी में त्रुटि कोड बताता है कि आपको क्यों रोका गया: rate_limited प्रति मिनट अनुरोधों के लिए, concurrency एक साथ बहुत अधिक अनुरोधों के लिए, और एक साधारण 429 Retry-After: 5 संक्षिप्त ओवरलोड के लिए। हेडर का सम्मान करना देरी अनुमान लगाने से सरल है। विफल और अस्वीकृत अनुरोधों के लिए शुल्क नहीं लिया जाता, इसलिए पुनः प्रयासों में कोई लागत नहीं आती।
बॉट्स और पात्र
चैट बॉट वह सामान्य स्थान है जहाँ अप्रत्याशित खर्च सामने आते हैं, क्योंकि एक बॉट जो इतिहास रखता है, हर संदेश पर उसे फिर से भेजता है। यह तय करें कि इतिहास के कितने संदेश रखने हैं, और इतिहास को स्वयं संग्रहीत करें, क्योंकि API कॉल के बीच कोई अवस्था नहीं रखता है।
एक बजट उदाहरण बिंदु को स्पष्ट करता है। मान लीजिए एक बॉट के 500 सक्रिय उपयोगकर्ता हैं जो प्रतिदिन 20 संदेश भेजते हैं। हर संदेश में 1,500 इनपुट टोकन (व्यक्तित्व, एक छोटा इतिहास और नई लाइन) होते हैं और 250 टोकन लौटाता है:
- प्रति संदेश: 1,500 / 1,000,000 x $0.15 = $0.000225 इन, प्लस 250 / 1,000,000 x $0.50 = $0.000125 आउट, तो $0.00035
- प्रतिदिन: 500 x 20 = 10,000 संदेश, तो $3.50
- 30 दिनों के लिए: $105
यदि आप इतिहास को बढ़ने देते हैं जब तक कि यह 12,000-टोकन कॉन्टेक्स्ट विंडो को न भर दे, तो प्रति संदेश इनपुट आठ गुना बढ़कर 12,000 टोकन हो जाता है, या केवल इनपुट के लिए $0.0018, और मासिक आंकड़ा उसी अनुपात में बढ़ता है। पुरानी घटनाओं का एक छोटा सारांश वाला रोलिंग विंडो कम कीमत पर व्यक्तित्व को स्थिर रखता है।
साथी और रोलप्ले बॉट्स के लिए, उत्पाद नियमों को अपनी परत में रखें। मॉडल को कानूनी वयस्क उपयोग के लिए सामग्री अस्वीकार किए बिना जवाब देने के लिए ट्यून किया गया है, और एक कठोर सीमा नाबालिगों से संबंधित यौन सामग्री है, जिसे सेवा अस्वीकार करती है। यदि आपका बॉट एक सार्वजनिक सर्वर पर रहता है, तो उम्र जाँच और चैनल नियम जोड़ें जो उस प्लेटफ़ॉर्म से मेल खाते हैं जिस पर आप इसे चलाते हैं।
ऑटोमेशन टूल्स और नो-कोड वर्कफ़्लो
OpenAI-शैली के नोड वाले वर्कफ़्लो टूल्स इस API को तीन फ़ील्ड बदलकर उपयोग कर सकते हैं: URL को https://api.glmapikey.com/v1, कुंजी और मॉडल नाम को uncensored। ऐसे टूल्स जिनके पास केवल एक सामान्य HTTP अनुरोध नोड है, वे कच्चे अनुरोध भेज सकते हैं:
curl https://api.glmapikey.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "uncensored", "messages": [{"role": "user", "content": "Classify this ticket: printer offline"}], "response_format": {"type": "json_object"}}'
उन वर्कफ़्लो स्टेप्स के लिए जो एक स्टेप को दूसरे में भेजते हैं, JSON मोड का उपयोग करना मूल्यवान है, ताकि अगला नोड पार्से करने योग्य पाठ प्राप्त करे। API कॉल करने वाले किसी भी स्टेप के लिए एक त्रुटि शाखा जोड़ें, क्योंकि 429 और 5xx प्रतिक्रियाएँ कभी-कभी होती हैं और वर्कफ़्लो के बीच में एक चुपचाप फेल होना बाद में खोजना मुश्किल होता है। उस नोड पर एक छोटी देरी के साथ रीट्राइज़ सेट करें, और सुनिश्चित करें कि समानांतर शाखाएँ आपकी कुंजी की अनुमति वाले समानांतर अनुरोधों की संख्या से अधिक न हों।
जब कुछ फेल होता है तो आपके उपयोगकर्ता क्या देखते हैं
हर इंटीग्रेशन के लिए असफल मार्ग की योजना होनी चाहिए, और उपयोगकर्ता-मुखी भाग रीट्राइज़ कोड जितना ही महत्वपूर्ण है। व्यावहारिक रूप से तीन स्थितियाँ सामने आती हैं।
पहली एक छोटा ओवरलोड है: Retry-After: 5 के साथ 429। शांति से रीट्राइज़ करें, और इस बीच एक टाइपिंग इंडिकेटर दिखाएँ, ताकि उपयोगकर्ता को त्रुटि के बजाय थोड़ा धीमा जवाब दिखाई दे। दूसरी स्थिति अपनी पूल सीमा पर पहुँचना है। यदि सभी आठ स्लॉट व्यस्त हैं, तो संदेश को कतार में डालें और उपयोगकर्ता को बताएँ कि यह प्रतीक्षा कर रहा है, जो एक खाली स्क्रीन से बेहतर है। तीसरी स्थिति क्रेडिट खत्म होना है, जिसे कोई रीट्राइज़ ठीक नहीं कर सकता। बैलेंस हेडर की निगरानी करें, एक थ्रेशोल्ड पर स्वयं को अलर्ट करें, और एक फॉलबैक संदेश तैयार रखें जब वह बिना सूचना के खत्म हो जाए।
अंतिम उपयोगकर्ताओं को कच्चे API त्रुटियाँ न दिखाएँ। उन्हें रिक्वेस्ट आईडी के साथ लॉग करें, और एक साधारण वाक्य दिखाएँ जो बताता है कि क्या हुआ और आगे क्या करना है। उपयोगकर्ता द्वारा पढ़े जाने वाले किसी भी चीज़ में कुंजी, बेस URL या स्टैक ट्रेस शामिल न करें।
पैसे, निगरानी और लॉन्च जाँच
बिलिंग प्रीपेड है। आप $20 से $500 तक किसी भी पूर्ण राशि का टॉप-अप कर सकते हैं, $50 से +5%, $100 से +10% और $200 से +15%। क्रेडिट कभी एक्सपायर नहीं होता, और कोई सब्सक्रिप्शन नहीं है। क्रिप्टो (TRC20 पर USDT, Base पर USDC) से भुगतान करें। नए उपयोगकर्ता API कुंजी पृष्ठ पर एक क्लिक के साथ $0.50 का मुफ़्त ट्रायल क्रेडिट दावा कर सकते हैं, जो 7 दिनों के लिए मान्य है, ताकि आप इसे फंड करने से पहले एक इंटीग्रेशन का परीक्षण कर सकें। दरों के लिए मूल्य निर्धारण पृष्ठ देखें।
उत्पादन में क्या निगरानी करनी है:
- बैलेंस। प्रतिक्रियाओं से
X-Balance-USDपढ़ें और जब यह आपकी चुनी हुई सीमा से कम हो जाए तो अलर्ट करें। - अनुरोध ID। प्रत्येक कार्य के साथ
X-Request-Idसंग्रहीत करें ताकि एक विफलता को ट्रैक किया जा सके। - टोकन उपयोग। प्रत्येक उपयोगकर्ता और सुविधा के लिए
usageजोड़ें ताकि यह देखा जा सके कि पैसा कहाँ जा रहा है। - 429 रेट। बढ़ती गिनती का अर्थ है कि आपका पूल कुंजी की सीमाओं से बड़ा है।
एक छोटी लॉन्च जाँच सूची: उत्पादन होस्ट से एक वास्तविक अनुरोध चलाएं, स्टैजिंग में एक मजबूर 429 का परीक्षण करें, पुष्टि करें कि उपयोगकर्ता आपके प्रमाणीकरण के बिना API तक नहीं पहुँच सकता, और लिखें कि जब API अनुपलब्ध हो तो आपकी सेवा क्या दिखाती है। प्रॉम्प्ट प्रशिक्षण के लिए उपयोग नहीं किए जाते हैं, जिसे आप अपने उपयोगकर्ताओं को दे सकते हैं, लेकिन अपनी गोपनीयता नीति में यह कहें कि उनका टेक्स्ट जवाब जनरेट करने के लिए एक थर्ड-पार्टी प्रदाता को भेजा जाता है।
