Hoe OpenAI API-foutcode 429 in Python op te lossen, zelfs met krediet

OpenAI API-quotumfouten begrijpen

Wanneer u met de API van OpenAI werkt, ontvangt u een foutmelding zoals Foutcode 429 kan frustrerend zijn, vooral voor degenen die nieuw zijn bij zowel Python als OpenAI. Deze fout geeft doorgaans aan dat u uw huidige API-gebruiksquotum heeft overschreden.

Als je je OpenAI-account hebt gecontroleerd en hebt bevestigd dat je nog credits beschikbaar hebt, vraag je je misschien af ​​waarom deze fout steeds verschijnt. Het komt vaak voor dat ontwikkelaars dit probleem tegenkomen wanneer ze voor het eerst hun API-aanroepen instellen.

Het begrijpen van de oorzaak van dit probleem is van cruciaal belang om ervoor te zorgen dat u de API effectief kunt gebruiken. In deze handleiding worden de waarschijnlijke redenen achter de fout uiteengezet en vindt u stappen om deze op te lossen.

Laten we eens kijken naar de mogelijke redenen waarom u deze fout tegenkomt, ook al heeft u credits in uw OpenAI-account, en hoe u deze kunt oplossen in uw Python-script.

Hoe de Python-scripts omgaan met OpenAI API-snelheidslimieten

De hierboven verstrekte scripts zijn ontworpen om een ​​veelvoorkomend probleem aan te pakken waarmee ontwikkelaars te maken krijgen bij het gebruik van de OpenAI-API: het tegenkomen van een foutmelding die aangeeft dat u uw grenzen heeft overschreden API-quotum ondanks dat je krediet hebt. Dit vraagstuk houdt verband met de tarieflimiet die OpenAI stelt aan het aantal verzoeken binnen een bepaalde periode. Het hoofdscript is geschreven om deze situatie op te lossen door gebruik te maken van foutafhandeling en mechanismen voor opnieuw proberen. Er wordt gebruik gemaakt van de RateLimitFout uitzondering om te detecteren wanneer er in een korte periode te veel verzoeken worden verzonden, waardoor de fout wordt geactiveerd. Bovendien gebruiken de scripts een strategie voor opnieuw proberen om de API-aanroep automatisch opnieuw uit te voeren nadat de snelheidslimiet is bereikt.

Om deze strategieën te implementeren, definieert het eerste script een functie genaamd maak_voltooiing, die een prompt en het toegestane aantal nieuwe pogingen accepteert. Deze functie probeert de voltooiings-API van OpenAI aan te roepen en genereert een antwoord op basis van het gegeven model en de gegeven prompt. Als er een snelheidslimietfout wordt gedetecteerd, drukt de functie een informatief bericht af en roept zichzelf recursief op om de bewerking opnieuw uit te voeren. Deze aanpak is effectief bij het voorkomen van abrupte beëindiging van scripts en het efficiënt beheren van API-snelheidslimieten.

In het tweede script wordt een vergelijkbare foutafhandelingsstrategie geïmplementeerd, maar deze bevat extra logica om van model te wisselen als de snelheidslimiet wordt overschreden. Dit is met name handig wanneer verschillende modellen verschillende snelheidslimieten kunnen hebben. Het script begint met het initialiseren van de OpenAI-client met behulp van een aangepaste functie genaamd initialiseer_client. Deze functie verifieert de geldigheid van de API-sleutel en zorgt ervoor dat het script met succes is geverifieerd voordat verder wordt gegaan met oproepen. Als de authenticatie mislukt, wordt er een duidelijk foutbericht aan de gebruiker geretourneerd, waardoor de verwarring rond verkeerde configuraties wordt verminderd.

Het tweede script introduceert ook een functie met de naam maak_chat, waarmee een API-aanroep wordt geprobeerd met behulp van een specifiek model. Als een RateLimitFout wordt verhoogd, drukt de functie een bericht af dat aangeeft dat er wordt overgeschakeld naar een fallback-model, zoals van "davinci-002" naar "davinci-003". Dit getuigt van flexibiliteit bij het beheren van tarieflimieten en het blijven leveren van resultaten. Bovendien gebruiken de scripts omgevingsvariabelen om de API-sleutel veilig te beheren met behulp van de dotenv pakket, waarbij de nadruk wordt gelegd op veilige coderingspraktijken. Omgevingsvariabelen verminderen het risico dat gevoelige gegevens in de codebase worden blootgesteld.

import os
from dotenv import load_dotenv
import openai
from openai.error import RateLimitError
# Load environment variables from a .env file
load_dotenv()
# Retrieve API key securely
api_key = os.getenv("OPENAI_API_KEY")
# Initialize OpenAI client
client = openai.OpenAI(api_key=api_key)
# Define a function to handle API calls with retry mechanism
def create_completion(prompt, retries=3):
    try:
        response = client.Completion.create(
            model="davinci-002",
            prompt=prompt,
            max_tokens=50
        )
        return response
    except RateLimitError as e:
        if retries > 0:
            print("Rate limit exceeded. Retrying...")
            return create_completion(prompt, retries - 1)
        else:
            print(f"Failed after multiple attempts: {str(e)}")
            return None
# Testing prompt
result = create_completion("Say this is a test")
if result:
    print(result)

import os
from dotenv import load_dotenv
import openai
from openai.error import RateLimitError, AuthenticationError
# Load environment variables
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
# Initialize OpenAI client with API key validation
def initialize_client(api_key):
    try:
        return openai.OpenAI(api_key=api_key)
    except AuthenticationError as auth_error:
        print("Invalid API key provided:", str(auth_error))
        return None
client = initialize_client(api_key)
# API call with fallback model if rate limit is reached
def create_chat(prompt, model="text-davinci-002"):
    try:
        response = client.Completion.create(
            model=model,
            prompt=prompt,
            max_tokens=60
        )
        return response
    except RateLimitError:
        print("Rate limit reached. Switching model...")
        return create_chat(prompt, model="text-davinci-003")
# Testing fallback mechanism
result = create_chat("Say this is another test")
if result:
    print(result)

OpenAI-snelheidslimietfouten in Python-scripts overwinnen

Bij het werken met de OpenAI API komen gebruikers vaak foutcode tegen 429, wat aangeeft dat het aantal toegestane API-verzoeken is overschreden. Dit kan verwarrend zijn, vooral voor beginners die hun tegoed hebben gecontroleerd en hebben bevestigd dat ze over voldoende saldo beschikken. In dergelijke gevallen gaat het probleem waarschijnlijk niet over het beschikbare krediet, maar over de tarieflimieten die door OpenAI zijn vastgesteld. Deze limieten kunnen het aantal API-aanroepen beperken dat u binnen een bepaalde periode kunt doen. Het effectief begrijpen en beheren van deze limieten is cruciaal voor het bouwen van een betrouwbare oplossing.

Eén manier om dit aan te pakken is door een mechanisme voor opnieuw proberen te introduceren, zoals weergegeven in de vorige scriptvoorbeelden. Een ander belangrijk aspect om te overwegen is echter het begrijpen van OpenAI quotabeleid in de diepte. OpenAI kan verschillende tarieflimieten afdwingen, afhankelijk van het model of het gebruikte accounttype. Free-tier-accounts kunnen bijvoorbeeld te maken krijgen met strengere limieten in vergelijking met betaalde niveaus, wat van invloed kan zijn op de manier waarop u uw API-aanroepen ontwerpt. Bovendien moeten gebruikers ervoor zorgen dat hun API-sleutelrechten correct zijn ingesteld, omdat een verkeerde configuratie ook quotafouten kan veroorzaken.

Naast het beheren van nieuwe pogingen en het kiezen van fallback-modellen, is het optimaliseren van de API-aanroepen essentieel. Dit omvat het minimaliseren van onnodige API-verzoeken en het focussen op kritieke verzoeken. Ontwikkelaars kunnen ook API-gebruiksstatistieken volgen via het OpenAI-dashboard om inzicht te krijgen in hun consumptiepatronen en hun scripts dienovereenkomstig aan te passen. Door deze strategieën te implementeren, kunt u de kans verkleinen dat u de tarieflimieten bereikt en een soepelere interactie met de API van OpenAI garanderen.