Több lépéses ügynök következtetési ciklussal
Ezen az oldalon
Több lépéses ügynök következtetési ciklussal
A leghatékonyabb ügynökök nem állnak meg egyetlen eszközhívás után. Több következtetési lépést láncolnak össze, az eredmények alapján kiigazítják stratégiájukat, és addig iterálnak, amíg el nem érik a céljukat. Ebben a leckében megtanulod, hogyan építsd fel ezeket a több lépéses ügynököket. A példák a GPT-5.6 családot használják: míg az előző generációnál a következtetés engedélyezéséhez modellt kellett váltani, addig most a kiválasztott modellen belüli effort beállítással irányíthatod ezt a viselkedést.
A tervezés-végrehajtás mintázat
Egy több lépéses ügynök úgy kezd, hogy létrehoz egy tervet, majd végrehajtja az egyes lépéseket. Ez a szétválasztás szándékos: a tervezőnek nincsenek eszközei, és egy típusos struktúrát állít elő, míg a végrehajtó ezt a tervet kapja meg útitervként, és egyszerűen követi azt. Egy olyan homályos kérés, mint „készítsd elő a negyedéves értékelést a kulcsfontosságú ügyfelek számára“, konkrét cselekvések sorozatává válik – lekérdezés a CRM-ben, jelentés generálása, e-mail elküldése – még mielőtt bármilyen műveletet végrehajtanának.
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="""Komplex feladatot kapsz. Bontsd egyszerű, rendezett lépésekre.
Minden lépésnek konkrét, végrehajtható elemnek kell lennie.""",
model="gpt-5.6-sol", # Haladó következtetés a tervezéshez
output_type=PlanAction,
)
@function_tool
def search_crm(query: str) -> str:
"""Ügyfélinformációkat keres a CRM-ben."""
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:
"""Formázott jelentést generál."""
return f"Report '{title}' generated successfully ({len(content)} characters)"
@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
"""E-mailt küld."""
return f"Email sent to {recipient}: {subject}"
executor_agent = Agent(
name="Executor",
instructions="""Lépésről lépésre hajtod végre a feladatokat.
Használd a rendelkezésre álló eszközöket minden lépés teljesítéséhez.
Ha egy lépés sikertelen, próbálj meg egy alternatív megközelítést.""",
tools=[search_crm, generate_report, send_email],
model="gpt-5.6-terra",
)
async def process_complex_task(task: str):
# 1. lépés: Tervezés
plan = await Runner.run(planner_agent, task)
print(f"Plan: {plan.final_output.steps}")
# 2. lépés: Végrehajtás a terv kontextusában
execution_instructions = f"""Hajtsd végre a következő lépéseket sorrendben:
{chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
Célkitűzés: {plan.final_output.objective}"""
result = await Runner.run(executor_agent, execution_instructions)
return result.final_output
Önkorrigáló ügynök
A tervezés önmagában nem elég: a valóságban az eszközök meghibásodhatnak. A ciklusok második formája lehetővé teszi az ügynök számára, hogy felismerje saját hibáit és kijavítsa azokat. Minden egy gyakran figyelmen kívül hagyott részleten múlik: az eszköz nem dob kivételt, hanem egy olvasható hibaüzenetet ad vissza. Az ügynök elolvassa, rájön, hogy elfelejtette a FROM záradékot, átírja a lekérdezést, és újra megpróbálja – az utasításaiban meghatározott három próbálkozás keretein belül.
from agents import Agent, Runner, function_tool
@function_tool
def execute_sql_query(sql: str) -> str:
"""SQL lekérdezést hajt végre az adatbázison."""
# Szimuláció: egyes lekérdezések sikertelenek
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="""Adatokat elemzel SQL lekérdezések végrehajtásával.
Ha egy lekérdezés sikertelen:
1. Elemezd a hibaüzenetet
2. Javítsd ki a lekérdezést
3. Próbáld újra
Lekérdezésenként maximum 3 próbálkozás.
Soha ne használj DROP, DELETE vagy TRUNCATE parancsokat.""",
tools=[execute_sql_query],
model="gpt-5.6-terra",
max_turns=10, # Elég forduló a javításokhoz
)
result = Runner.run_sync(
analyst_agent,
"What is the total revenue by region?"
)
Vedd észre, hogy a romboló lekérdezésekre vonatkozó tiltás két helyen is szerepel: az utasításokban és az eszköz kódjában. Az utasítás vezeti a modellt, de csak a szerveroldali ellenőrzés az eszközben garantálja, hogy egy DROP TABLE soha ne csússzon át a rendszeren.
Mintázat: specializált ügynökök lánca
Komplex munkafolyamatok esetén láncolj össze több specializált ügynököt ahelyett, hogy egyetlen ügynökre hárítanád az összes felelősséget. Minden láncszemnek világos szerepe van: a gyűjtő összegyűjti a nyersanyagot, az elemző – aki egy következtető modellel van felszerelve – azonosítja a trendeket, az író pedig formázza a kimenetet. Az előny egyszerre oktatási és működési jellegű: ha a végső jelentés csalódást kelt, azonnal tudod, melyik három ügynök közül kell javítanod.
from agents import Agent, Runner
collection_agent = Agent(
name="Data Collector",
instructions="Gyűjtsd össze az elemzéshez szükséges összes adatot.",
tools=[search_crm, execute_sql_query],
model="gpt-5.6-terra",
)
analysis_agent = Agent(
name="Analyst",
instructions="Elemezd a gyűjtött adatokat és azonosítsd a trendeket.",
model="gpt-5.6-sol", # Haladó következtetés az elemzéshez
)
writing_agent = Agent(
name="Writer",
instructions="""Írj egy világos, strukturált jelentést angol nyelven
a megadott elemzés alapján. Formátum: bevezetés, kulcspontok, ajánlások.""",
model="gpt-5.6-terra",
)
async def analysis_pipeline(question: str):
# 1. lépés: Adatgyűjtés
data = await Runner.run(collection_agent, question)
# 2. lépés: Elemzés
analysis = await Runner.run(
analysis_agent,
f"Analyze this data: {data.final_output}"
)
# 3. lépés: Jelentés írása
report = await Runner.run(
writing_agent,
f"Write a report based on this analysis: {analysis.final_output}"
)
return report.final_output
A következtetés mélységének szabályozása
Ezeknek a ciklusoknak van egy közös tulajdonságuk: előfordulhat, hogy sosem állnak le. A max_turns paraméter az elsődleges biztonsági hálód, amelyet a feladat ambíciószintje alapján hangolsz. Három forduló elegendő egy olyan ügynöknek, amelytől elvárják, hogy első próbálkozásra válaszoljon; huszonötre van szükség egy olyan felderítéshez, amely több forrást is lekérdez, mielőtt következtetést vonna le.
# Konzervatív ügynök: kevés forduló
simple_agent = Agent(
name="Simple Agent",
instructions="Ha lehetséges, egyetlen fordulóban válaszolj.",
model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Simple question", max_turns=3)
# Komplex ügynök: sok forduló
research_agent = Agent(
name="Deep Researcher",
instructions="Mielőtt következtetést vonnál le, tárd fel az összes szempontot.",
tools=[search_crm, execute_sql_query],
model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Complete Q1 analysis", max_turns=25)
Ezt az értéket ne tippeléssel, hanem a nyomkövetési adatok (traces) megfigyelésével állítsd be: ha a tényleges végrehajtások hat forduló alatt befejeződnek, akkor a huszonötös korlát semmit sem véd ki.
Főbb megállapítások
- A tervezés-végrehajtás mintázat elválasztja a tervezést (következtető modell) a végrehajtástól
- Egy önkorrigáló ügynök elemzi a hibáit és kiigazítja a stratégiáját
- A specializált ügynökök lánca lehetővé teszi a komplex, karbantartható munkafolyamatokat
- A
max_turnsszabályozza a következtetés mélységét és megvéd a végtelen ciklusoktól - A haladó következtetési képességeket tartsd fenn a tervezéshez és az elemzéshez