Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Több lépésből álló munkafolyamatok automatizálása

9. lecke 14 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Komplex feladatok orchestrálása
  2. Lépésalapú architektúra
  3. Az orchestrátor
  4. Adatok átadása a lépések között
  5. Feltételes munkafolyamatok
  6. Párhuzamosítás
  7. Főbb megállapítások

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_contains krité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