Multi-trins agent med ræsonnementssløjfe
På denne side
Multi-trins agent med ræsonnementssløjfe
De mest kraftfulde agenter stopper ikke efter et enkelt værktøjskald. De kæder flere ræsonnementstrin sammen, justerer deres strategi baseret på resultaterne og itererer, indtil de når deres mål. I denne lektion lærer du at bygge disse multi-trins agenter. Eksemplerne bruger GPT-5.6-familien: Hvor den tidligere generation krævede skift af modeller for at aktivere ræsonnement, styrer du nu denne adfærd via effort-indstillingen på din valgte model.
Plan-udfør-mønsteret
En multi-trins agent starter med at skabe en plan og udfører derefter hvert trin. Denne adskillelse er bevidst: Planlæggeren har ingen værktøjer og producerer en typet struktur, mens eksekutøren modtager denne plan som et køreplan og blot følger den. En vag anmodning som „forbered kvartalsrapporten for nøglekunder” bliver til en konkret sekvens af handlinger – spørg CRM’en, generér rapporten, send e-mailen – før nogen handling forsøges.
from agents import Agent, Runner, function_tool
from pydantic import BaseModel
import json
class PlanAction(BaseModel):
steps: list[str]
objective: str
planner_agent = Agent(
name="Planner",
instructions="""Du modtager en kompleks opgave. Opdel den i simple, ordnede trin.
Hvert trin skal være en konkret, handlingsbar post.""",
model="gpt-5.6-sol", # Avanceret ræsonnement til planlægning
output_type=PlanAction,
)
@function_tool
def search_crm(query: str) -> str:
"""Søger i CRM'en efter kundeoplysninger."""
return json.dumps({"customers": [
{"name": "Acme Corp", "revenue": 500000, "contract": "Enterprise"},
{"name": "TechStart", "revenue": 50000, "contract": "Starter"},
]})
@function_tool
def generate_report(title: str, content: str) -> str:
"""Genererer en formateret rapport."""
return f"Rapport '{title}' genereret succesfuldt ({len(content)} tegn)"
@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
"""Sender en e-mail."""
return f"E-mail sendt til {recipient}: {subject}"
executor_agent = Agent(
name="Executor",
instructions="""Du udfører opgaver trin for trin.
Brug tilgængelige værktøjer til at fuldføre hvert trin.
Hvis et trin fejler, så prøv en alternativ tilgang.""",
tools=[search_crm, generate_report, send_email],
model="gpt-5.6-terra",
)
async def process_complex_task(task: str):
# Trin 1: Planlæg
plan = await Runner.run(planner_agent, task)
print(f"Plan: {plan.final_output.steps}")
# Trin 2: Udfør med planen som kontekst
execution_instructions = f"""Udfør følgende trin i rækkefølge:
{chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
Mål: {plan.final_output.objective}"""
result = await Runner.run(executor_agent, execution_instructions)
return result.final_output
Selv-korrigerende agent
Planlægning er ikke nok: I den virkelige verden fejler værktøjer. Den anden form for sløjfe lader agenten opdage sine egne fejl og rette dem. Alt afhænger af en detalje, der ofte overses – værktøjet kaster ikke en undtagelse; det returnerer en læsbar fejlmeddelelse. Agenten læser den, indser, at den har glemt FROM-klausulen, omskriver sin forespørgsel og prøver igen, inden for grænsen på tre forsøg sat af dens instrukser.
from agents import Agent, Runner, function_tool
@function_tool
def execute_sql_query(sql: str) -> str:
"""Udfører en SQL-forespørgsel på databasen."""
# Simulation: nogle forespørgsler fejler
if "DROP" in sql.upper():
return "FEJL: Destruktive forespørgsler er forbudt."
if "SELECT" in sql.upper() and "FROM" not in sql.upper():
return "FEJL: Ugyldig SQL-syntaks - mangler FROM."
return json.dumps({
"columns": ["name", "monthly_revenue", "region"],
"rows": [
["Acme Corp", 45000, "Île-de-France"],
["TechStart", 12000, "Rhône-Alpes"],
],
"result_count": 2
})
analyst_agent = Agent(
name="Data Analyst",
instructions="""Du analyserer data ved at udføre SQL-forespørgsler.
Hvis en forespørgsel fejler:
1. Analyser fejlmeddelelsen
2. Ret forespørgslen
3. Prøv igen
Maksimum 3 forsøg pr. forespørgsel.
Brug aldrig DROP, DELETE eller TRUNCATE.""",
tools=[execute_sql_query],
model="gpt-5.6-terra",
max_turns=10, # Nok omdrejninger til korrektioner
)
result = Runner.run_sync(
analyst_agent,
"Hvad er den samlede omsætning pr. region?"
)
Bemærk, at forbuddet mod destruktive forespørgsler optræder to steder: i instrukserne og i værktøjskoden. Instrukserne guider modellen, men det er kun server-side-tjekket i værktøjet, der garanterer, at en DROP TABLE aldrig sniger sig igennem.
Mønster: Kæde af specialiserede agenter
Til komplekse arbejdsgange skal du kæde flere specialiserede agenter sammen i stedet for at belaste en enkelt agent med ethvert ansvar. Hvert led har en klar rolle: Indsamleren samler råmaterialet, analytikeren – udstyret med en ræsonnementsmodel – identificerer tendenser, og skribenten formatterer outputtet. Fordelen er både pædagogisk og operationel: Når den endelige rapport skuffer, ved du straks, hvilken af de tre agenter du skal rette.
from agents import Agent, Runner
collection_agent = Agent(
name="Data Collector",
instructions="Indsaml alle data nødvendige for analysen.",
tools=[search_crm, execute_sql_query],
model="gpt-5.6-terra",
)
analysis_agent = Agent(
name="Analyst",
instructions="Analyser de indsamlede data og identificer tendenser.",
model="gpt-5.6-sol", # Avanceret ræsonnement til analyse
)
writing_agent = Agent(
name="Writer",
instructions="""Skriv en klar, struktureret rapport på engelsk
baseret på den leverede analyse. Format: introduktion, nøglepunkter, anbefalinger.""",
model="gpt-5.6-terra",
)
async def analysis_pipeline(question: str):
# Trin 1: Indsaml data
data = await Runner.run(collection_agent, question)
# Trin 2: Analyser
analysis = await Runner.run(
analysis_agent,
f"Analyser disse data: {data.final_output}"
)
# Trin 3: Skriv rapporten
report = await Runner.run(
writing_agent,
f"Skriv en rapport baseret på denne analyse: {analysis.final_output}"
)
return report.final_output
Styring af ræsonnementsdybde
Alle disse sløjfer deler én egenskab: De stopper måske aldrig. Parameteren max_turns er din primære sikkerhedsforanstaltning, og du finjusterer den baseret på opgavens ambition. Tre omdrejninger er nok til en agent, der forventes at svare ved første forsøg; femogtyve er nødvendige til en udforskning, der spørger flere kilder, før den konkluderer.
# Konservativ agent: få omdrejninger
simple_agent = Agent(
name="Simple Agent",
instructions="Svar på én omdrejning hvis muligt.",
model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Simpelt spørgsmål", max_turns=3)
# Kompleks agent: mange omdrejninger
research_agent = Agent(
name="Deep Researcher",
instructions="Udforsk alle vinkler før konklusion.",
tools=[search_crm, execute_sql_query],
model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Fuld Q1-analyse", max_turns=25)
Sæt denne værdi ved at observere dine spor i stedet for at gætte: Hvis dine faktiske eksekveringer afsluttes på seks omdrejninger, beskytter en grænse på femogtyve mod ingenting.
Vigtige pointer
- Plan-udfør-mønsteret adskiller planlægning (ræsonnementsmodel) fra udførelse
- En selv-korrigerende agent analyserer sine fejl og justerer sin strategi
- Kæder af specialiserede agenter muliggør komplekse, vedligeholdelige arbejdsgange
max_turnsstyrer ræsonnementsdybden og beskytter mod uendelige sløjfer- Reserver avancerede ræsonnementsevner til planlægning og analyse