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

LLM API त्रुटि 429: कारण और समाधान

LLM API त्रुटि 429 का अर्थ है कि सर्वर अभी अनुरोध को अस्वीकार कर रहा है, हमेशा के लिए नहीं। इस API पर तीन अलग-अलग कारण हैं, और प्रत्येक के लिए थोड़ा अलग समाधान चाहिए।

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

आठ लेनों वाले गेट पर कतार में प्रतीक्षित प्रकाश के पैकेट, API रेट लिमिट का चित्रण

मुख्य बिंदु

तीन प्रकार की 429

HTTP 429 मानक "बहुत अधिक अनुरोध" स्थिति है। यहाँ यह तीन स्थितियों को कवर करता है, और JSON त्रुटि बॉडी बताती है कि आप किस स्थिति में हैं।

त्रुटि कोडइसका अर्थसामान्य समाधान
rate_limitedप्रति मिनट बहुत सारे अनुरोधअनुरोधों को धीमा करें, मिनट में अनुरोधों को फैलाएं
concurrencyएक ही समय में बहुत सारे अनुरोध चल रहे हैंसमानांतरता कम करें, स्लॉट खाली होने का प्रतीक्षा करें
ओवरलोड, Retry-After: 5 के साथसेवा पर अस्थायी लोड, यह आपकी गलती नहीं हैहेडर में दिए गए सेकंड की संख्या का इंतज़ार करें, फिर पुनः प्रयास करें

पहले कोड पढ़ें, क्योंकि एक कारण का समाधान दूसरे के लिए कुछ नहीं करेगा। यदि वास्तविक समस्या 20 वर्कर्स का एक साथ चलना है, तो प्रति मिनट आपके अनुरोधों को आधा करने से मदद नहीं मिलेगी।

अपनी सीमाओं को जानें

सीमाएँ कुंजी के प्रकार पर निर्भर करती हैं:

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

प्रत्येक प्रतिक्रिया में X-RateLimit-Limit-Requests और X-RateLimit-Limit-Concurrency होते हैं, ताकि आपका क्लाइंट कठोर कोडिंग के बजाय ऊपरी सीमा पढ़ सके। नए उपयोगकर्ताओं के लिए ट्रायल कुंजी अक्सर समस्या का कारण बनती है: एक स्क्रिप्ट जो एक बार में 1 अनुरोध पर ठीक चलती है, जब आप 4 के थ्रेड पूल को जोड़ते हैं तो वह विफल होने लगती है। ट्रायल का उपयोग परीक्षण के लिए किया जाता है, और $20 के किसी भी टॉप-अप के साथ पूर्ण कुंजी प्राप्त होती है (राशियां और बोनस के लिए मूल्य निर्धारण पृष्ठ देखें)।

ऊपर दी गई संख्याएँ प्रति कुंजी हैं। यदि एक कुंजी एक वेब एप, एक क्रॉन जॉब और एक सहकर्मी के नोटबुक द्वारा साझा की जाती है, तो वे सभी एक ही पूल से खींचते हैं, और 429 तब तक यादृच्छिक लगते हैं जब तक कि आप तीनों कार्यभारों को एक साथ न जोड़ दें।

स्ट्रीमिंग समानांतरता त्रुटियों को अधिक संभावित क्यों बनाती है

एक सामान्य अनुरोध एक सेकंड या दो सेकंड के लिए एक समकालिकता स्लॉट को पकड़े रखता है। एक स्ट्रीम किए गए अनुरोध (stream: true) अंतिम टोकन आने और स्ट्रीम बंद होने तक स्लॉट को पकड़े रखता है। एक लंबा उत्तर दसियों सेकंड तक स्लॉट को व्यस्त रख सकता है, इसलिए कई सक्रिय उपयोगकर्ताओं वाले चैट एप में 8 स्लॉट जल्दी गायब हो जाते हैं।

इसमें अधिकांश समस्याएं दो गलतियों के कारण होती हैं। पहली स्ट्रीम को बंद किए बिना छोड़ देना है: यदि क्लाइंट पढ़ना बंद कर देता है लेकिन कनेक्शन को खुला छोड़ देता है, तो स्लॉट तब तक आबद्ध रहता है जब तक कनेक्शन समाप्त न हो जाए। हमेशा प्रतिक्रिया को finally ब्लॉक में बंद करें, या SDK के कॉन्टेक्स्ट मैनेजर का उपयोग करें। दूसरी तब होती है जब आप स्ट्रीम को फिर से शुरू करते हैं और पहली अभी भी सक्रिय है, तो दूसरी खोलने से स्लॉट का उपयोग दोगुना हो जाता है, ठीक उसी समय जब स्लॉट कम हों।

यदि आपके एप को आपकी कुंजी की अनुमति से अधिक एक साथ लंबे स्ट्रीम की आवश्यकता है, तो नई चैट्स को अपनी ओर कतार में लगाएं और एक छोटा इंतज़ार स्थिति दिखाएं। यह उपयोगकर्ताओं को कच्ची त्रुटियाँ दिखाने से बेहतर है।

बैकऑफ़ के साथ पुनः प्रयास करने वाला Python कोड

यह पैटर्न सरल है: 429 को कैच करें, कोड पढ़ें, प्रतीक्षा करें, बढ़ते विलंब और कुछ यादृच्छिकता के साथ फिर से प्रयास करें, और कुछ प्रयासों के बाद छोड़ दें। यह संस्करण सेवा के base URL के खिलाफ आधिकारिक openai पैकेज का उपयोग करता है:

import random
import time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.onekeyllmapi.com/v1",
    api_key="YOUR_KEY",
    max_retries=0,  # we handle retries ourselves
)

def chat(messages, attempts=5):
    for i in range(attempts):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=messages,
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            headers = e.response.headers
            wait = float(headers.get("Retry-After", 0))
            if not wait:
                wait = min(30, 2 ** i)  # 1, 2, 4, 8, 16 seconds
            wait += random.uniform(0, 1)  # jitter
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

print(chat([{"role": "user", "content": "Reply with the word ok."}]))

जब हेडर मौजूद हो, तो उसे न्यूनतम प्रतीक्षा के रूप में उपयोग करें। जब यह अनुपस्थित हो, तो घातीय विलंब rate_limited के लिए काम करता है क्योंकि प्रति-मिनट विंडो आगे बढ़ती है। ज़िटर कई वर्कर को एक ही क्षण में फिर से प्रयास करने से रोकता है।

समानांतर कॉल को कैप करें ताकि आप दुर्लभ ही 429 देखें

पुनः प्रयास लक्षण का इलाज करते हैं। एक सेमाफोर इसे अधिकांशतः रोकता है क्योंकि यह आपकी गिनती से अधिक कभी नहीं भेजता। इसे सीमा से थोड़ा नीचे सेट करें ताकि एक पुनः प्रयास या एक भटकता अनुरोध अभी भी जगह रखे:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.onekeyllmapi.com/v1",
    api_key="YOUR_KEY",
)
sem = asyncio.Semaphore(6)  # full key allows 8; use 1 on a trial key

async def ask(prompt):
    async with sem:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Give one fact about the number {n}." for n in range(50)]
    results = await asyncio.gather(*(ask(p) for p in prompts))
    print(len(results))

asyncio.run(main())

प्रति मिनट की सीमा के लिए, प्रति मिनट 300 अनुरोध औसतन प्रति सेकंड 5 होते हैं। यदि आप हज़ारों छोटे कार्यों को बैच करते हैं, तो सेमाफोर के सामने एक छोटा स्लीप या टोकन बकेट जोड़ें। क्योंकि SDK डिफ़ॉल्ट रूप से स्वयं भी पुनः प्रयास करता है, max_retries को स्पष्ट रूप से सेट करें ताकि आपका अपना तर्क और SDK का पुनः प्रयास एकत्र न हों और प्रतीक्षा को गुणा न करें।

curl के साथ 429 को पुनः उत्पन्न करें और निरीक्षण करें

कोड बदलने से पहले, कच्ची प्रतिक्रिया देखें। हेडर प्रिंट करने के लिए curl में -i जोड़ें, और जानबूझकर त्रुटि उत्पन्न करने के लिए समानांतर में कुछ अनुरोध भेजें:

for i in 1 2 3 4; do
  curl -i -s https://api.onekeyllmapi.com/v1/chat/completions     -H "Authorization: Bearer $API_KEY"     -H "Content-Type: application/json"     -d '{"model":"uncensored","messages":[{"role":"user","content":"Count to 200 slowly."}]}' &
done
wait

ट्रायल कुंजी पर, जो एक समय में 2 अनुरोध की अनुमति देती है, तीसरे और चौथे कॉल 429 स्थिति और concurrency त्रुटि कोड के साथ वापस आएंगे। एक फुल कुंजी पर आपको एक समय में 8 से अधिक की आवश्यकता होगी। प्रत्येक प्रतिक्रिया में तीन चीजें देखें: स्थिति पंक्ति, Retry-After हेडर यदि कोई हो, और JSON बॉडी में error.code फ़ील्ड। यह छोटा प्रयोग अनुमान लगाने की एक घंटे की मेहनत से अधिक बताता है, और यदि कुछ गलत दिखे तो सहायता को दिखाने के लिए एक पुनरुत्पादन योग्य मामला देता है।

इसके लिए डिज़ाइन करें, इसके आस-पास नहीं

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

एक छोटा डीबगिंग चेकलिस्ट

  1. प्रत्येक 429 के लिए पूर्ण त्रुटि बॉडी और X-Request-Id हेडर को लॉग करें। कोड फ़ील्ड rate_limited को concurrency से अलग करती है।
  2. जांचें कि क्या आपकी कुंजी एक ट्रायल कुंजी है। यदि हाँ, तो 2 समकालीन अनुरोध और प्रति मिनट 60 की उम्मीद करें।
  3. हर उस प्रोग्राम की गिनती करें जो कुंजी का उपयोग करता है, केवल उस प्रोग्राम की नहीं जो विफल हुआ।
  4. बंद न हुए स्ट्रीम और तुरंत बिना विलंब के पुनः प्रयास करने वाले लूप की तलाश करें। एक तत्काल पुनः प्रयास लूप एक 429 को सौ में बदल देता है।
  5. X-Balance-USD या GET /v1/balance के साथ शेष राशि की पुष्टि करें। खाली शेष राशि 429 से अलग समस्या है, लेकिन जांचने में कुछ सेकंड लगते हैं।

असफल अनुरोधों के लिए चार्ज नहीं किया जाता, इसलिए पुनः प्रयास करने से अस्वीकृत प्रयासों के लिए टोकन खर्च नहीं होते। स्टेटस कोड और हेडर की पूरी सूची के लिए, दस्तावेज़ीकरण देखें। यदि आपको ट्रायल से अधिक सीमाओं वाली कुंजी चाहिए, तो API कुंजी प्राप्त करें और टॉप-अप करें।

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

क्या 429 मेरी गलती है या प्रदाता की?

दोनों ही संभव हैं। rate_limited और concurrency कोड का अर्थ है कि आपकी कुंजी अपनी सीमा से आगे निकल गई है। Retry-After हेडर के साथ एक 429 अस्थायी ओवरलोड से भी आ सकता है, और निर्दिष्ट समय तक प्रतीक्षा करना फिर पुनः प्रयास करना सही प्रतिक्रिया है।

पुनः प्रयास करने से पहले मुझे कितना समय प्रतीक्षा करनी चाहिए?

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

अस्वीकृत अनुरोधों के लिए पैसे खर्च होते हैं?

नहीं। विफल या अस्वीकृत अनुरोधों पर कोई शुल्क नहीं लगाया जाता।

क्या मैं अपनी सीमाएँ बढ़ा सकता हूँ?

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

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

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