Aģents ar vairākiem soļiem un spriešanas ciklu
Šajā lapā
Aģents ar vairākiem soļiem un spriešanas ciklu
Visjaudīgākie aģenti neapstājas pēc viena rīka izsaukuma. Tie savieno vairākus spriešanas soļus, pielāgo savu stratēģiju, balstoties uz rezultātiem, un iterē, līdz sasniedz mērķi. Šajā nodarbībā tu iemācīsies veidot šādus aģentus ar vairākiem soļiem. Piemēros tiek izmantota GPT-5.6 saime: tur, kur iepriekšējai paaudzei bija jāpārslēdz modeļi, lai aktivizētu spriešanu, tagad tu kontrolē šo uzvedību, izmantojot effort iestatījumu izvēlētajā modelī.
Plāno-izpildi modelis
Aģents ar vairākiem soļiem vispirms izveido plānu, pēc tam izpilda katru soli. Šī atdalīšana ir apzināta: plānotājam nav pieejami rīki, un tas ģenerē tipētu struktūru, savukārt izpildītājs saņem šo plānu kā ceļvedi un vienkārši tam seko. Neskaidrs pieprasījums, piemēram, „sagatavo ceturkšņa pārskatu galvenajiem klientiem”, pārvēršas konkrētā darbību secībā — veic vaicājumu CRM sistēmā, ģenerē pārskatu, nosūta e-pastu — pirms tiek mēģināta jebkura darbība.
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="""You receive a complex task. Break it down into simple, ordered steps.
Each step must be a concrete, actionable item.""",
model="gpt-5.6-sol", # Advanced reasoning for planning
output_type=PlanAction,
)
@function_tool
def search_crm(query: str) -> str:
"""Searches the CRM for customer information."""
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:
"""Generates a formatted report."""
return f"Report '{title}' generated successfully ({len(content)} characters)"
@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
"""Sends an email."""
return f"Email sent to {recipient}: {subject}"
executor_agent = Agent(
name="Executor",
instructions="""You execute tasks step by step.
Use available tools to complete each step.
If a step fails, try an alternative approach.""",
tools=[search_crm, generate_report, send_email],
model="gpt-5.6-terra",
)
async def process_complex_task(task: str):
# Step 1: Plan
plan = await Runner.run(planner_agent, task)
print(f"Plan: {plan.final_output.steps}")
# Step 2: Execute with the plan as context
execution_instructions = f"""Execute the following steps in order:
{chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
Objective: {plan.final_output.objective}"""
result = await Runner.run(executor_agent, execution_instructions)
return result.final_output
Paškoriģējošs aģents
Ar plānošanu vien nepietiek: reālajā pasaulē rīki kļūst. Otrs cikla veids ļauj aģentam noteikt savas kļūdas un tās labot. Viss ir atkarīgs no detaļas, ko bieži palaiž garām — rīks neizraisa izņēmumu; tas atgriež lasāmu kļūdas ziņojumu. Aģents to nolasī, saprot, ka aizmirsis FROM klauzulu, pārraksta savu vaicājumu un mēģina vēlreiz, ievērojot instrukcijās noteikto trīs mēģinājumu limitu.
from agents import Agent, Runner, function_tool
@function_tool
def execute_sql_query(sql: str) -> str:
"""Executes an SQL query on the database."""
# Simulation: some queries fail
if "DROP" in sql.upper():
return "ERROR: Destructive queries are forbidden."
if "SELECT" in sql.upper() and "FROM" not in sql.upper():
return "ERROR: Invalid SQL syntax - missing 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="""You analyze data by executing SQL queries.
If a query fails:
1. Analyze the error message
2. Correct the query
3. Retry
Maximum 3 attempts per query.
Never use DROP, DELETE, or TRUNCATE.""",
tools=[execute_sql_query],
model="gpt-5.6-terra",
max_turns=10, # Enough turns for corrections
)
result = Runner.run_sync(
analyst_agent,
"What is the total revenue by region?"
)
Ņem vērā, ka aizliegums veikt destruktīvus vaicājumus parādās divās vietās: instrukcijās un rīka kodā. Instrukcija vada modeli, taču tikai servera puses pārbaude rīkā garantē, ka DROP TABLE nekad neizslīdēs cauri.
Modelis: specializētu aģentu ķēde
Sarežģītām darbplūsmām savieno vairākus specializētus aģentus, nevis uzliec visu atbildību vienam aģentam. Katram posmam ir skaidra loma: vācējs sagatavo izejmateriālu, analītiķis — aprīkots ar spriešanas modeli — identificē tendences, un rakstnieks noformē izvadi. Ieguvums ir gan izglītojošs, gan operacionāls: ja gala pārskats ir vājš, tu uzreiz zini, kurš no trim aģentiem ir jālabo.
from agents import Agent, Runner
collection_agent = Agent(
name="Data Collector",
instructions="Collect all data necessary for the analysis.",
tools=[search_crm, execute_sql_query],
model="gpt-5.6-terra",
)
analysis_agent = Agent(
name="Analyst",
instructions="Analyze the collected data and identify trends.",
model="gpt-5.6-sol", # Advanced reasoning for analysis
)
writing_agent = Agent(
name="Writer",
instructions="""Write a clear, structured report in English
based on the provided analysis. Format: introduction, key points, recommendations.""",
model="gpt-5.6-terra",
)
async def analysis_pipeline(question: str):
# Step 1: Collect data
data = await Runner.run(collection_agent, question)
# Step 2: Analyze
analysis = await Runner.run(
analysis_agent,
f"Analyze this data: {data.final_output}"
)
# Step 3: Write the report
report = await Runner.run(
writing_agent,
f"Write a report based on this analysis: {analysis.final_output}"
)
return report.final_output
Spriešanas dziļuma kontrole
Visiem šiem cikliem ir kopīga iezīme: tie varētu nekad neapstāties. Parametrs max_turns ir tava galvenā drošība, un tu to pielāgo atbilstoši uzdevuma ambīcijām. Trīs gājieni pietiek aģentam, no kura sagaida atbildi jau pirmajā mēģinājumā; divdesmit pieci ir nepieciešami izpētei, kas vaicā vairākiem avotiem, pirms tiek izdarīts secinājums.
# Conservative agent: few turns
simple_agent = Agent(
name="Simple Agent",
instructions="Answer in a single turn if possible.",
model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Simple question", max_turns=3)
# Complex agent: many turns
research_agent = Agent(
name="Deep Researcher",
instructions="Explore all angles before concluding.",
tools=[search_crm, execute_sql_query],
model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Complete Q1 analysis", max_turns=25)
Iestati šo vērtību, novērojot savus izsekošanas datus (traces), nevis minot: ja tavi faktiskie izpildījumi beidzas sešos gājienos, limits divdesmit pieci neko nepasargā.
Galvenās atziņas
- Plāno-izpildi modelis atdala plānošanu (spriešanas modelis) no izpildes
- Paškoriģējošs aģents analizē savas kļūdas un pielāgo stratēģiju
- Specializētu aģentu ķēdes ļauj veidot sarežģītas un uzturamas darbplūsmas
max_turnskontrolē spriešanas dziļumu un pasargā no bezgalīgiem cikliem- Rezervē uzlabotas spriešanas spējas plānošanai un analīzei