Több lépésből álló munkafolyamatok automatizálása
Ezen az oldalon
Lecke frissítve: 2026. november 3. az OpenAI számítógép-használati integrációs irányelvei szerint: az ügynök már nem kezeli a bejelentkezést; a parancsok érvényesítése és a felhasználót kötelező ágak (véleményezés, új rendelések) emberi megerősítést igényelnek; az orchestrátor most már ellenőrzi a korábban figyelmen kívül hagyott
success_text_containskritériumot, jelzi a sikertelen lépéseket ahelyett, hogy kihagyná őket, és soha nem játszik újra olyan lépést, amely adatot hoz létre. Forrás: Megerősítés és beleegyezés.
Komplex feladatok orchestrálása
A valós munkafolyamatok ritkán állnak egyetlen műveletből. Egy CRM rendszer feltöltése magában foglalja az oldalak közötti navigálást, egy kapcsolattartó megtalálását, adatainak frissítését, majd egy lehetőség létrehozását – négy összeláncolt műveletet, amelyek mindegyike saját okokból meghiúsulhat. Ha ezt az egész blokkot egyetlen prompttal bízod egy ügynökre, az néha működik, de sosem fogod tudni, hol akadt el. Ez a lecke megtanít arra, hogyan strukturáld ezeket a több lépésből álló automatizálásokat úgy, hogy minden láncszem megfigyelhető és újrajátszható legyen.
Lépésalapú architektúra
Kezdd azzal, hogy a munkafolyamatot atomi lépésekre bontod, amelyek mindegyikének világos célja és sikerfeltétele van. Ez a kritérium választja el a teendőlistát az igazi munkafolyamattól: enélkül az orchestrátorod nem tudja eldönteni, hogy az ügynök tényleg sikeresen végzett-e, vagy egy hibaoldalon állt meg. Az alábbi példában a modul megnyitását az URL ellenőrzi, a keresést pedig a kapcsolattartó nevének képernyőn való megjelenése. A bejelentkezés itt nem szerepel: a kódod ezt előzőleg kezelte, anélkül, hogy a jelszót feltárná a modell előtt (8. lecke). Az utolsó lépésnél a "retry": False beállítás szerepel, mert ez adatot hoz létre: egy részleges hiba utáni újrajátszás duplikációt eredményezhet.
workflow = [
{
"name": "open_contacts",
"task": "Open the Contacts module in the CRM.",
"success_url_contains": "/contacts",
},
{
"name": "search_contact",
"task": "Search for contact 'Jean Dupont' in the search bar.",
"success_text_contains": "Jean Dupont",
},
{
"name": "update_record",
"task": "Open Jean Dupont's profile and update their phone number: 06 98 76 54 32.",
},
{
"name": "create_opportunity",
"task": "Create an opportunity: 'Cloud Migration Q2 2026', amount 50000 EUR, probability 60%.",
"retry": False, # non-replayable step: creates data
},
]
Az orchestrátor
Most végrehajtod ezt a listát. Az orchestrátor sorban végigmegy a lépéseken, és mindegyiket egy újrapróbálkozási ciklusba csomagolja: egy olyan lépés, amely kivételt dob vagy nem teljesíti a sikerfeltételt, legfeljebb max_retries alkalommal ismétlődik meg, hacsak nincs nem újrajátszhatóként megjelölve. Ez a részlet éles környezetben számít, mert sok vizuális ügynök hiba átmeneti – egy lassú oldal, egy hiányos megjelenítés a képernyőkép készítésekor. Egy véglegesen sikertelen lépés leállítja a munkafolyamatot, mivel a következő lépések ettől függenek. Végül az orchestrátor egy strukturált naplót ad vissza, amely minden lépésnél jelzi az állapotot és az elhasznált próbálkozások számát: ez az első diagnosztikai eszközöd.
def run_workflow(workflow: list, page, max_retries: int = 2):
"""Executes a multi-step workflow with retries."""
results = []
for step in workflow:
step_name = step["name"]
print(f"\n--- Step: {step_name} ---")
attempts = max_retries + 1 if step.get("retry", True) else 1
error = "success criterion not met"
for attempt in range(attempts):
try:
run_agent(step["task"], page=page)
# Optional checks: URL, then visible text
url_check = step.get("success_url_contains")
if url_check and url_check not in page.url:
print(" Expected URL not found")
continue
text_check = step.get("success_text_contains")
if text_check and text_check not in page.locator("body").inner_text():
print(" Expected text not found")
continue
print(f" Success (attempt {attempt + 1})")
results.append({"step": step_name, "status": "success", "attempts": attempt + 1})
break
except Exception as e:
print(f" Error: {e}")
error = str(e)
else:
# No attempt succeeded: subsequent steps depend on this one
results.append({"step": step_name, "status": "failed", "error": error})
break
return results
Adatok átadása a lépések között
Gyakran előfordul, hogy egy lépés olyan adatot állít elő, amelyre a következőnek szüksége van: a kosár oldalán leolvasott árat ellenőrizni kell a fizetési lépésnél; a 2. lépésben létrehozott ügyszám hivatkozásként szolgál az 5. lépésben. Egy megosztott kontextus megoldja ezt az igényt anélkül, hogy a kódod globális változók kusza hálójává válna. Az alábbi példa szándékosan megáll a fizetés előtt: az OpenAI a pénzügyi tranzakció megerősítését olyan műveletnek minősíti, amely a végrehajtás pillanatában felhasználói validálást igényel. Az alábbi osztály kulcs-érték párokat tárol, és exposes egy inject metódust, amely lecseréli a {kulcs} jelölőket egy prompt sablonban, lehetővé téve, hogy a feladataidat paraméterezett sablonokként írd meg.
class WorkflowContext:
"""Stores data shared between steps."""
def __init__(self):
self.data = {}
def set(self, key: str, value):
self.data[key] = value
def get(self, key: str, default=None):
return self.data.get(key, default)
def inject(self, template: str) -> str:
"""Replaces {key} variables in the template."""
task = template
for key, value in self.data.items():
task = task.replace("{" + key + "}", str(value))
return task
# Usage example
ctx = WorkflowContext()
# Step 1: agent reads a price
extracted_price = run_agent(
"Read the total price displayed and return only the number.",
page=page
)
ctx.set("price", extracted_price.strip())
# Step 2: agent verifies, without validating anything
verdict = run_agent(ctx.inject(
"The expected amount is {price} EUR. Compare it to the total on the payment page "
"and answer only OK or MISMATCH. Do not validate anything."
), page=page)
# Step 3: a transaction is confirmed at the moment of action, by a human
if verdict.strip() == "OK":
if input(f"Confirm order for {ctx.get('price')} EUR? [y/N] ").strip().lower() == "y":
run_agent("Click the order confirmation button.", page=page)
Feltételes munkafolyamatok
A lineáris sorozatok gyorsan elérik a határaikat, mert a következő lépés függhet az előző eredményétől. Az észben tartandó minta ez: először kérd meg az ügynököt, hogy olvassa be az állapotot úgy, hogy egy zárt halmazból származó értékre korlátozod a válaszát, majd ágazz el Pythonban. A rendelés követésénél a „feldolgozás alatt“ állapot a csomagkövetéshez vezet, a „kiszállítva“ a kézbesítési dátum lekérdezéséhez, a „törölve“ pedig az ok megismeréséhez. A formázási korlátozások a promptban elengedhetetlenek: nélkülük az ügynök egy mondatot ad vissza, amelyet az összehasonlításaid rendszerint elvétnek. Mindhárom ág csak olvasási művelet: vélemény közzététele vagy újrarendelés kötelezné a felhasználót, és igényelné a megerősítését.
def conditional_workflow(page):
"""Workflow with conditional branching."""
# Step 1: Read status
status = run_agent(
"Read the order status. "
"Return only: processing, delivered, or canceled.",
page=page
)
# Branch based on result
match status.strip().lower():
case "processing":
return run_agent("Click 'Track package' and note the displayed stage.", page=page)
case "delivered":
return run_agent("Note the displayed delivery date.", page=page)
case "canceled":
return run_agent("Note the displayed cancellation reason.", page=page)
case _:
raise ValueError(f"Unexpected status: {status!r}")
Párhuzamosítás
Amikor a feladatok függetlenek, nincs szükség soros feldolgozásra. Három termékadatlap adatainak kinyerése sokkal kevesebb időt vesz igénybe, ha három ügynök dolgozik egyszerre, mindegyik a saját fülén. A Playwright aszinkron verziója és az asyncio.gather ehhez elegendő: egy korutin URL-enként, egy new_page korutinenként, és a fülek szisztematikus bezárása a memóriában felhalmozódó lapok elkerülése érdekében. A run_agent_async a 4. leckéből származó ciklus, amelyet az AsyncOpenAI klienssel és a Playwright aszinkron API-jával írtak át: ugyanaz a logika, minden hívás előtt egy await kulcsszóval. Ne feledd, hogy a párhuzamosítás megszorozza az API-hívások átviteli sebességét is, növelve annak kockázatát, hogy eléred a sebességkorlátokat (11. lecke), és terheli a céloldalt is – három fül észrevétlen marad, ötven már sokkal kevésbé.
import asyncio
from playwright.async_api import async_playwright
async def parallel_extraction(urls: list[str]):
"""Extracts data from multiple pages in parallel."""
async with async_playwright() as pw:
browser = await pw.chromium.launch(headless=True)
async def extract_one(url: str):
page = await browser.new_page(
viewport={"width": 1280, "height": 720}
)
try:
await page.goto(url)
result = await run_agent_async(
"Extract the product title and price.", page=page
)
finally:
await page.close()
return {"url": url, "data": result}
results = await asyncio.gather(
*[extract_one(url) for url in urls]
)
return results
# Run
urls = [
"https://shop.example.com/product/1",
"https://shop.example.com/product/2",
"https://shop.example.com/product/3",
]
data = asyncio.run(parallel_extraction(urls))
Főbb megállapítások
- Bontsd a munkafolyamatokat atomi lépésekre explicit sikerfeltételekkel
- Játssz újra automatikusan olyan lépéseket, amelyek biztonságosan újrapróbálhatók, de soha azokat, amelyek adatot hoznak létre
- Használj megosztott kontextust az adatok lépések közötti átadásához
- A feltételes munkafolyamatok alkalmazkodnak az oldal tartalmához; a felhasználót kötelező ágak megerősítést igényelnek
- Párhuzamosítsd a független feladatokat az idő megtakarítása érdekében