AI-agenter · Lektion

Omförsök med exponentiell backoff

Använd tenacity för att göra om anrop vid tillfälliga fel, med exponentiellt ökande fördröjningar och jitter.

Lektion 2 av 415 steg

Omförsök med exponentiell backoff är en gratis lektion i AI-agenter på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för AI-agenter, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI-agenter innehåller totalt 4 lektioner.

Varför omförsök?

Externa anrop (LLM:er, sök-API:er och vektordatabaser) kan tillfälligt fallera. Ett enkelt omförsök återhämtar sig från de flesta tillfälliga felen utan att användaren behöver störas.

Vad du INTE ska göra

Försök inte igen direkt i en tät loop — du kommer att överbelasta tjänsten och rate limitern kommer att blockera dig:

# BAD
for _ in range(10):
    try:
        return call_api()
    except Exception:
        pass

Exponentiell backoff

Vänta längre efter varje fel. Exponenten 2 är konventionen:

import time

def call_with_backoff(fn, attempts=5):
    for i in range(attempts):
        try:
            return fn()
        except TransientError:
            if i == attempts - 1:
                raise
            time.sleep(2 ** i)   # 1, 2, 4, 8, 16 seconds

Lägg till jitter

Utan jitter sammanfaller omförsöken från många klienter — vilket skapar trafik i form av en "thundering herd". Lägg till en slumpmässig förskjutning:

import random
sleep = (2 ** i) + random.uniform(0, 1)
time.sleep(sleep)

Använd Tenacity

Biblioteket tenacity implementerar detta åt dig:

from tenacity import retry, wait_exponential_jitter, stop_after_attempt, retry_if_exception_type
import requests

@retry(
    wait=wait_exponential_jitter(initial=1, max=30),
    stop=stop_after_attempt(5),
    retry=retry_if_exception_type((requests.Timeout, requests.ConnectionError))
)
def search(query):
    return requests.get('https://api.tavily.com/search', timeout=10).json()

Försök bara igen vid tillfälliga fel

Försök aldrig igen vid:

4xx-fel (felaktig begäran — ett nytt försök hjälper inte)
Autentiseringsfel
Valideringsfel

Försök igen vid:

Timeouts
5xx-serverfel
Rate limits (med längre väntetider)

Rate-limit-medvetna omförsök

Respektera huvudet Retry-After:

if response.status_code == 429:
    wait = int(response.headers.get('Retry-After', 5))
    time.sleep(wait)
    continue

Begränsa den totala tiden för omförsök

Begränsa hur lång tid omförsöken totalt får ta — vanligtvis 30–60 sekunder för ett användarriktat anrop:

from tenacity import stop_after_delay

@retry(
    wait=wait_exponential_jitter(initial=1, max=10),
    stop=stop_after_delay(60)
)
def call_api():
    ...

Idempotensheaders

För icke-idempotenta API:er (Stripe med flera) inkluderar du en idempotensnyckel vid varje omförsök, så att dubbletter slås samman:

headers = {'Idempotency-Key': f'agent-call-{run_id}-{tool_id}'}

Försök även igen med LLM-anropet

SDK:erna för OpenAI och Anthropic försöker automatiskt igen 1–2 gånger. Du kan konfigurera:

client = OpenAI(max_retries=5, timeout=30.0)

Asynkrona omförsök

För asynkron kod:

from tenacity import AsyncRetrying

async for attempt in AsyncRetrying(wait=wait_exponential_jitter(), stop=stop_after_attempt(5)):
    with attempt:
        result = await call_api()

Logga omförsök

Varje omförsök bör logga: försöksnummer, sovtid och felorsak. Annars är det omöjligt att felsöka "varför är det så långsamt?".

Omförsök kontra timeouts

Ange en kort timeout för varje försök (t.ex. 10 s) och en total gräns med stop_after_delay (t.ex. 60 s). Utan båda kan en anslutning som har fastnat hänga för evigt.

Varför jitter?

Varför lägga till slumpmässig jitter i omförsöksfördröjningar?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Exponentiell backoff + jitter + begränsad totaltid + omförsök endast vid tillfälliga fel. Använd tenacity för att slippa standardkoden.

Gratis att börja

Lär dig AI-agenter med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 60
Lektioner: 239

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Omförsök med exponentiell backoff” gratis?

Ja – hela texten till ”Omförsök med exponentiell backoff” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i AI-agenter, kan Ni uppgradera till CoddyKit PRO. Kursen i AI-agenter innehåller totalt 4 lektioner.

Vad lär jag mig i ”Omförsök med exponentiell backoff”?

Använd tenacity för att göra om anrop vid tillfälliga fel, med exponentiellt ökande fördröjningar och jitter. Ni övar på AI-agenter med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig AI-agenter?

Du behöver inga förkunskaper. Utbildningen i AI-agenter på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Omförsök med exponentiell backoff”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här AI-agenter-lektionen?

Ja. Varje AI-agenter-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till AI-agenter