AI-agenter · leksjon

Teknikker for trinnvis feilsøking

Legge til stoppunkter og mellomliggende utskrifter og bruke debuggeren i agentkode.

Leksjon 4 av 413 trinn

Teknikker for trinnvis feilsøking 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.

Feilsøking av agenter er annerledes enn feilsøking av funksjoner

En funksjon har en tydelig inndata og utdata. En agent har en løkke med LLM-kall, verktøykjøringer og endringer i historikken — og alt dette kan gå galt på subtile måter.

Trinnvis feilsøking lar Dem sette kjøringen på pause ved hvert trinn, undersøke agentens tilstand og forstå nøyaktig hva som gikk galt.

Pythons innebygde feilsøker: pdb

Pythons feilsøker pdb lar Dem sette kjøringen på pause, undersøke variabler og gå gjennom koden linje for linje. Sett inn import pdb; pdb.set_trace() hvor som helst i agentløkken for å åpne en interaktiv feilsøkingsøkt.

import pdb

def run_agent_loop(query: str):
    history = []
    for step in range(1, 21):
        action = decide_action(query, history)

        # Drop into debugger at step 3 to inspect state
        if step == 3:
            import pdb; pdb.set_trace()
            # At this point you can:
            # (Pdb) print(action)       -- inspect current action
            # (Pdb) print(history)      -- inspect full history
            # (Pdb) n                   -- next line
            # (Pdb) c                   -- continue execution
            # (Pdb) q                   -- quit

        result = execute_tool(action['tool'], action['args'])
        history.append({'tool': action['tool'], 'result': result})

Python 3.7+: Funksjonen breakpoint()

Python 3.7+ inneholder den innebygde funksjonen breakpoint() — ryddigere enn import pdb; pdb.set_trace(). Den respekterer også miljøvariabelen PYTHONBREAKPOINT, som lar Dem bytte til en annen feilsøker.

def run_agent_loop(query: str):
    history = []
    for step in range(1, 21):
        action = decide_action(query, history)

        breakpoint()  # cleaner than pdb.set_trace()

        result = execute_tool(action['tool'], action['args'])
        history.append({'tool': action['tool'], 'result': result})

# Disable all breakpoints without changing code:
# PYTHONBREAKPOINT=0 python agent.py

# Use ipdb (better UI) instead:
# PYTHONBREAKPOINT=ipdb.set_trace python agent.py
# pip install ipdb

Referanse for pdb-kommandoer

De viktigste pdb-kommandoene for feilsøking av agentløkker:

n — neste linje (hopp over)
s — gå inn i funksjonskallet
c — fortsett til neste stoppunkt
p expr — skriv ut verdien til uttrykket
pp expr — skriv ut med formatering (for dicts/lists)
l — vis kildekode rundt gjeldende linje
q — avslutt feilsøkingen

# Typical pdb debugging session for an agent loop:
# (Pdb) p step           -- print current step number: 3
# (Pdb) pp action        -- pretty-print the action dict
# {'type': 'tool', 'tool': 'search_web', 'args': {'query': 'Python docs'}}
# (Pdb) pp history       -- see full conversation so far
# (Pdb) p len(history)   -- count messages: 6
# (Pdb) n                -- execute next line
# (Pdb) p result         -- see tool result
# (Pdb) c                -- continue to next breakpoint
print('pdb lets you inspect agent state at any point in the loop')

Betingede stoppunkter

Stopp bare når en bestemt betingelse er oppfylt — for eksempel bare når et bestemt verktøy er valgt, eller når trinntallet er høyt. Dette unngår at kjøringen stopper ved hver iterasjon i en lang løkke.

def run_agent_loop(query: str):
    history = []
    for step in range(1, 21):
        action = decide_action(query, history)

        # Break only if the agent picks the wrong tool
        if action.get('tool') == 'calculate' and 'weather' in query.lower():
            breakpoint()  # This is suspicious — weather shouldn't use calculator

        # Break only if we're near the step limit
        if step >= 18:
            breakpoint()  # Why hasn't the agent concluded yet?

        result = execute_tool(action['tool'], action['args'])
        history.append({'tool': action['tool'], 'result': result})

VS Code-feilsøking for agentkode

VS Code Python-feilsøkingsverktøy gir en visuell opplevelse for trinnvis kjøring, med paneler for inspeksjon av variabler, kallstakker og overvåkingsuttrykk. Konfigurer en launch.json-fil for å kjøre agenten i feilsøkingsmodus.

# .vscode/launch.json
# {
#   'version': '0.2.0',
#   'configurations': [
#     {
#       'name': 'Debug Agent',
#       'type': 'python',
#       'request': 'launch',
#       'program': 'agent_cli.py',
#       'args': ['--query', 'What is the weather in Paris?'],
#       'env': {
#         'OPENAI_API_KEY': 'your-key',
#         'LOG_LEVEL': 'DEBUG'
#       },
#       'console': 'integratedTerminal'
#     }
#   ]
# }

# Set breakpoints by clicking the left margin in VS Code
# Press F5 to start debugging, F10 to step over, F11 to step into
print('VS Code debugger provides visual debugging with no code changes needed')

Legge til et --debug-flagg i CLI-et

Legg til flagget --debug i agentens CLI. Når flagget er angitt, aktiverer det detaljert logging, skriver ut hvert trinn og kan eventuelt starte pdb ved feil. Dermed kan De feilsøke uten å endre kildekoden.

import argparse
import logging

parser = argparse.ArgumentParser()
parser.add_argument('--query', required=True)
parser.add_argument('--debug', action='store_true', help='Enable step-by-step debugging output')
parser.add_argument('--pdb-on-error', action='store_true', help='Drop into pdb on any exception')
args = parser.parse_args()

if args.debug:
    logging.basicConfig(level=logging.DEBUG)
    print('[DEBUG MODE] Step-by-step output enabled')

try:
    result = run_agent(args.query, verbose=args.debug)
    print(result['answer'])
except Exception as e:
    if args.pdb_on_error:
        import pdb; pdb.post_mortem()  # debug the crash
    else:
        raise

Trinnvis kjøring med detaljert modus

En detaljert modus skriver ut omfattende informasjon om hvert trinn til stdout, slik at De kan følge agentens kjøring uten en feilsøker. Legg til et verbose=True-flagg i agentløkken.

import json

def run_agent(query: str, verbose: bool = False) -> dict:
    history = []

    for step in range(1, 21):
        action = decide_action(query, history)

        if verbose:
            print(f'\n--- Step {step} ---')
            print(f'Action type: {action["type"]}')
            if action['type'] == 'tool':
                print(f'Tool: {action["tool"]}')
                print(f'Args: {json.dumps(action["args"], indent=2)}')

        if action['type'] == 'final_answer':
            if verbose:
                print(f'\nFinal answer: {action["answer"]}')
            return {'status': 'ok', 'answer': action['answer']}

        result = execute_tool(action['tool'], action['args'])
        if verbose:
            print(f'Result: {str(result)[:200]}')
        history.append({'tool': action['tool'], 'result': result})

    return {'status': 'max_steps', 'answer': None}

Etteranalytisk feilsøking med pdb.post_mortem()

Når en agent krasjer med et unntak, åpner pdb.post_mortem() feilsøkeren på det nøyaktige feilstedet, med kallstakken bevart. Dette er svært nyttig for å forstå krasj uten å måtte gjenskape dem.

import pdb
import sys
import traceback

def run_agent_with_postmortem(query: str, debug: bool = False) -> dict:
    try:
        return run_agent(query)
    except Exception as e:
        if debug:
            print(f'\nAgent crashed: {e}')
            traceback.print_exc()
            print('\nDropping into post-mortem debugger...')
            pdb.post_mortem()  # opens debugger at the crash site
            return {'status': 'crashed', 'error': str(e)}
        else:
            raise

# Usage:
# python agent.py --query 'test' --pdb-on-error

Inspisere meldingshistorikken i feilsøkeren

Det mest nyttige å inspisere under feilsøking av en agent er samtalehistorikken. Bruk pdbs pp-kommando til å skrive den ut med formatering, eller gå gjennom den for å forstå hva agenten har sett så langt.

# Inside a pdb session, common inspection commands:

# Print the full history:
# (Pdb) pp history

# Print only user and assistant messages:
# (Pdb) pp [m for m in history if m['role'] in ('user', 'assistant')]

# Count messages:
# (Pdb) p len(history)

# Find tool calls in history:
# (Pdb) pp [m for m in history if m.get('role') == 'tool']

# Print the last message:
# (Pdb) pp history[-1]

# Print total token estimate (rough):
# (Pdb) p sum(len(str(m)) for m in history)
print('History inspection is the key to understanding agent state')

Trinnvis simulering uten LLM-kall

For rask iterasjon bør De lage en simuleringsmodus der De manuelt angir hvilken handling agenten skal utføre i hvert trinn. Dermed kan De teste verktøykjøring og historikkhåndtering uten å foreta LLM API-kall.

def run_agent_simulation(query: str, scripted_actions: list) -> dict:
    'Simulate agent steps without LLM calls, using pre-defined actions'
    history = []

    for step, action in enumerate(scripted_actions, 1):
        print(f'Step {step}: {action}')

        if action['type'] == 'final_answer':
            return {'status': 'ok', 'answer': action['answer'], 'steps': step}

        result = execute_tool(action['tool'], action['args'])
        print(f'  Result: {str(result)[:100]}')
        history.append({'tool': action['tool'], 'result': result})

    return {'status': 'script_exhausted', 'history': history}

# Test tool execution logic without any LLM:
# result = run_agent_simulation('test', [
#     {'type': 'tool', 'tool': 'search_web', 'args': {'query': 'Python'}},
#     {'type': 'final_answer', 'answer': 'Python is a programming language.'}
# ])

Kunnskapstest: Trinnvis feilsøking

Test forståelsen av feilsøkingsteknikker for agentkode.

Besvar den i den interaktive leksjonen

Oppsummering: Teknikker for trinnvis feilsøking

De har nå et komplett feilsøkingsverktøysett for agentløkker:

Bruk breakpoint() (Python 3.7+) eller import pdb; pdb.set_trace() for interaktiv feilsøking
Bruk betingede stoppunkter for å stoppe bare når noe mistenkelig skjer
Konfigurer VS Code launch.json for feilsøking med et grafisk grensesnitt
Legg til CLI-flaggene --debug og --pdb-on-error for feilsøking ved behov
Bruk pdb.post_mortem() for å inspisere krasj etter at de har oppstått
Bygg en simuleringsmodus for å teste verktøylogikk uten LLM-kall
Bruk detaljert modus for å følge kjøringen uten pauser

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 «Teknikker for trinnvis feilsøking» gratis?

Ja – hele teksten i «Teknikker for trinnvis feilsøking» 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 «Teknikker for trinnvis feilsøking»?

Legge til stoppunkter og mellomliggende utskrifter og bruke debuggeren i agentkode. 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 «Teknikker for trinnvis feilsøking»?

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

← Tilbake til AI-agenter