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

बॉट्स और बैकएंड के लिए GLM API इंटीग्रेशन गाइड

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

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

गेटवे क्यूब ऐप, चैट और ऑटोमेशन ब्लॉक से आइटम प्राप्त कर रहा है, जो API इंटीग्रेशन का प्रतिनिधित्व करता है

मुख्य बिंदु

  • कुंजी एक ऐसे सर्वर पर रखें जिस पर आपका नियंत्रण हो और ऐप्स को आपका बैकएंड कॉल करने दें, ब्राउज़र से कभी सीधे API न कॉल करें।
  • चल रहे अनुरोधों को कुंजी की सीमा तक सीमित करें: पूर्ण कुंजी के लिए 8, ट्रायल कुंजी के लिए 2।
  • टोकन से बजट की योजना बनाएं: प्रति 1M $0.15 और $0.50 पर, एक सामान्य बॉट संदेश का खर्च एक सेंट का अंश होता है।
  • कोई भी टूल जिसमें ओपनएआई-कम्पैटिबल विकल्प और कस्टम बेस URL फील्ड हो, https://api.glmapikey.com/v1 का उपयोग कर सकता है।

सबसे पहले इंटीग्रेशन पैटर्न चुनें

अधिकांश 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 अनुपलब्ध हो तो आपकी सेवा क्या दिखाती है। प्रॉम्प्ट प्रशिक्षण के लिए उपयोग नहीं किए जाते हैं, जिसे आप अपने उपयोगकर्ताओं को दे सकते हैं, लेकिन अपनी गोपनीयता नीति में यह कहें कि उनका टेक्स्ट जवाब जनरेट करने के लिए एक थर्ड-पार्टी प्रदाता को भेजा जाता है।

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

क्या मुझे API को ब्राउज़र से कॉल करना चाहिए?

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

एक साथ कितने अनुरोध चलाए जा सकते हैं?

एक पूर्ण कुंजी 8 समानांतर अनुरोधों और प्रति मिनट 300 की अनुमति देती है। एक ट्रायल कुंजी 2 समानांतर और प्रति मिनट 60 की अनुमति देती है।

429 पर मेरे कोड को क्या करना चाहिए?

त्रुटि कोड पढ़ें, फिर प्रतीक्षा करें। जब मौजूद हो तो Retry-After मान का उपयोग करें, जो अस्थायी ओवरलोड पर 5 सेकंड होता है, और पुनः प्रयास करें। विफल अनुरोधों के लिए शुल्क नहीं लगाया जाता है।

क्या कॉल के बीच स्थिति बनाए रखी जाती है?

नहीं। आपको हर बार पूरी बातचीत भेजनी होती है, प्रॉम्प्ट और जवाब सहित 100,000 टोकन तक, और आपको हर कॉल पर इनपुट टोकन के लिए भुगतान करना होता है।

क्या मैं इसे नो-कोड टूल्स से उपयोग कर सकता हूँ?

हाँ, यदि टूल आपको अपने OpenAI नोड पर बेस URL सेट करने या https://api.glmapikey.com/v1/chat/completions पर एक बेयरर कुंजी के साथ एक कस्टम HTTP अनुरोध भेजने की अनुमति देता है।

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

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

API कुंजी पाएँ