AI-agenter · leksjon

Oppdage og håndtere verktøyfeil

Når et verktøy returnerer HTTP 500, sender du feilen til modellen, slik at den kan prøve en annen fremgangsmåte i stedet for å krasje.

Leksjon 4 av 415 trinn

Oppdage og håndtere verktøyfeil er en gratis leksjon i AI-agenter på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI-agenter, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI-agenter inneholder totalt 4 leksjoner.

Verktøy feiler – planlegg for det

Alle verktøy i praksis feiler av og til:

Tidsavbrudd i nettverket
Frekvensbegrensninger
Ugyldige argumenter fra modellen
Nedetid hos eksterne tjenester
Ugyldig autentisering

Agenter i produksjon må kunne håndtere dette på en god måte.

Returner alltid, kast aldri

Fang opp alle verktøyfeil i agentløkken, og returner dem som innhold. Ikke la et unntak avslutte løkken:

def safe_dispatch(tool_call):
    try:
        args = json.loads(tool_call.function.arguments)
        return TOOLS[tool_call.function.name](**args)
    except json.JSONDecodeError:
        return {'error': 'Arguments are not valid JSON.'}
    except KeyError:
        return {'error': f'Unknown tool: {tool_call.function.name}'}
    except Exception as e:
        return {'error': f'{type(e).__name__}: {e}'}

Strukturert feilformat

Bruk en konsekvent struktur, slik at modellen gjenkjenner feil:

error = {'ok': False, 'error_type': 'TimeoutError', 'error_message': 'Tavily timed out after 10s', 'retryable': True}
print(error)

Skill mellom feil som kan prøves på nytt og permanente feil

Noen feil bør føre til et nytt forsøk (tidsavbrudd), mens andre ikke bør det (404). Fortell modellen:

if isinstance(e, requests.Timeout):
    return {'ok': False, 'retryable': True, 'error': str(e)}
if isinstance(e, ValueError):
    return {'ok': False, 'retryable': False, 'error': str(e)}

Prøv forbigående feil på nytt automatisk

For nettverkskall kan det gjøres nye forsøk med eksponentiell ventetid:

from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type

@retry(
    wait=wait_exponential(multiplier=1, max=10),
    stop=stop_after_attempt(3),
    retry=retry_if_exception_type((requests.Timeout, requests.ConnectionError))
)
def web_search(query):
    return requests.get('https://api.tavily.com/search', ...).json()

Argumentvalidering

Valider argumentene med en Pydantic-modell før verktøyet kalles:

from pydantic import BaseModel, ValidationError

class SearchArgs(BaseModel):
    query: str
    k: int = 5

try:
    args = SearchArgs.model_validate_json(tool_call.function.arguments)
except ValidationError as e:
    return {'error': f'Bad arguments: {e}'}

Vis modellen feilen

Legg feilen til som et verktøyresultat, og kall modellen på nytt. Modellen korrigerer ofte seg selv:

messages.append({
    'role': 'tool',
    'tool_call_id': tc.id,
    'content': json.dumps({'error': 'Argument k must be an integer'})
})
# Next model call: 'Sorry, let me retry with k=5...'

Unngå uendelige feilsløyfer

Noen modeller prøver samme ødelagte kall på nytt når de får se en feil. Sett en grense for løkken, og oppdag gjentakelser:

recent_calls = []
for tc in msg.tool_calls:
    key = (tc.function.name, tc.function.arguments)
    if recent_calls.count(key) >= 3:
        return 'Agent stuck in retry loop, aborting.'
    recent_calls.append(key)

Verktøyspesifikk gjenoppretting

For verktøy som er kjent for å være ustabile, bygg logikk for nye forsøk INNE I verktøyet, ikke i løkken:

def search_with_fallback(query):
    try:
        return tavily_search(query)
    except Exception:
        return bing_search(query)   # secondary provider

Tidsavbrudd for hvert kall

Alle eksterne kall trenger et tidsavbrudd. Ellers kan én treg tjeneste fryse hele agenten:

import requests
response = requests.get(url, timeout=10)  # 10s

# For LLM calls:
from openai import OpenAI
client = OpenAI(timeout=30.0)

Kretsbrytere

Når et verktøy feiler gjentatte ganger, «åpner» du kretsen og hopper over verktøyet en stund:

import time

class CircuitOpen(Exception):
    pass

def circuit(failure_threshold=5, recovery_timeout=60):
    def decorator(func):
        state = {'failures': 0, 'open_until': 0}
        def wrapper(*args, **kwargs):
            if time.time() < state['open_until']:
                raise CircuitOpen('circuit is open')
            try:
                result = func(*args, **kwargs)
                state['failures'] = 0
                return result
            except Exception:
                state['failures'] += 1
                if state['failures'] >= failure_threshold:
                    state['open_until'] = time.time() + recovery_timeout
                raise
        return wrapper
    return decorator

@circuit(failure_threshold=3, recovery_timeout=1)
def fragile_tool(x):
    if x < 0:
        raise ValueError('bad input')
    return x * 2

for x in [1, -1, -1, -1, -1]:
    try:
        print('ok', fragile_tool(x))
    except CircuitOpen as e:
        print('blocked:', e)
    except ValueError as e:
        print('failed:', e)

Loggføring av feil med kontekst

Loggfør nok informasjon til å kunne feilsøke i etterkant: verktøynavn, argumenter, feiltype, stakksporing, forespørsels-ID, bruker-ID og sporings-ID. Send dette til observability-verktøyet.

Kontrollert degradering

Når et kritisk verktøy er nede, må agenten fortelle brukeren det ærlig i stedet for å late som om den har lykkes:

if all_search_tools_failed:
    return 'I was unable to search the web right now. Please try again in a few minutes.'

Mønster for verktøyfeil

Hva er den sikreste måten å håndtere verktøyunntak inne i agentløkken på?

Besvar den i den interaktive leksjonen

Oppsummering

Verktøy feiler. Fang opp, klassifiser og gjør feilene til strukturert innhold, slik at agenten kan hente seg inn. Legg til tidsavbrudd, nye forsøk og kretsbrytere for pålitelighet i produksjon.

Gratis å komme i gang

Lær deg AI-agenter med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 60
Leksjoner: 239

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Oppdage og håndtere verktøyfeil» gratis?

Ja – hele teksten i «Oppdage og håndtere verktøyfeil» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI-agenter-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI-agenter inneholder totalt 4 leksjoner.

Hva lærer jeg i «Oppdage og håndtere verktøyfeil»?

Når et verktøy returnerer HTTP 500, sender du feilen til modellen, slik at den kan prøve en annen fremgangsmåte i stedet for å krasje. Du øver på AI-agenter med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med AI-agenter?

Ingen tidligere erfaring er nødvendig. AI-agenter på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Oppdage og håndtere verktøyfeil»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne AI-agenter-leksjonen?

Ja. Alle AI-agenter-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

ReAct: mønsteret resonnering + handling
Implementere ReAct fra grunnen av
Vanlige verktøysett (nett, kalkulator, RAG)
Oppdage og håndtere verktøyfeil

← Tilbake til AI-agenter