तीन प्रकार की 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 स्लॉट लेने से रोकता है।
एक छोटा डीबगिंग चेकलिस्ट
- प्रत्येक 429 के लिए पूर्ण त्रुटि बॉडी और
X-Request-Idहेडर को लॉग करें। कोड फ़ील्डrate_limitedकोconcurrencyसे अलग करती है। - जांचें कि क्या आपकी कुंजी एक ट्रायल कुंजी है। यदि हाँ, तो 2 समकालीन अनुरोध और प्रति मिनट 60 की उम्मीद करें।
- हर उस प्रोग्राम की गिनती करें जो कुंजी का उपयोग करता है, केवल उस प्रोग्राम की नहीं जो विफल हुआ।
- बंद न हुए स्ट्रीम और तुरंत बिना विलंब के पुनः प्रयास करने वाले लूप की तलाश करें। एक तत्काल पुनः प्रयास लूप एक 429 को सौ में बदल देता है।
X-Balance-USDयाGET /v1/balanceके साथ शेष राशि की पुष्टि करें। खाली शेष राशि 429 से अलग समस्या है, लेकिन जांचने में कुछ सेकंड लगते हैं।
असफल अनुरोधों के लिए चार्ज नहीं किया जाता, इसलिए पुनः प्रयास करने से अस्वीकृत प्रयासों के लिए टोकन खर्च नहीं होते। स्टेटस कोड और हेडर की पूरी सूची के लिए, दस्तावेज़ीकरण देखें। यदि आपको ट्रायल से अधिक सीमाओं वाली कुंजी चाहिए, तो API कुंजी प्राप्त करें और टॉप-अप करें।
