Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Automatizácia viacstupňových pracovných postupov

Lekcia 9 z 14 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Orchestrovanie komplexných úloh
  2. Architektúra založená na krokoch
  3. Orchestrátor
  4. Odovzdávanie dát medzi krokmi
  5. Podmienené pracovné postupy
  6. Paralelizácia
  7. Kľúčové poznatky

Lekcia aktualizovaná 3. novembra 2026 podľa pokynov OpenAI pre integráciu Computer Use: agent už nezvláda prihlásenie; validácia príkazov a vetvy, ktoré zaväzujú používateľa (recenzie, nové objednávky), si vyžadujú ľudské potvrdenie; orchestrátor teraz kontroluje kritérium success_text_contains, ktoré predtým ignoroval, označuje neúspešné kroky namiesto ich preskočenia a nikdy neopakuje krok, ktorý vytvára dáta. Zdroj: Potvrdenie a súhlas.

Orchestrovanie komplexných úloh

Reálne pracovné postupy sa zriedka skladajú z jednej akcie. Naplnenie CRM zahŕňa navigáciu medzi stránkami, vyhľadanie kontaktu, aktualizáciu jeho informácií a následné vytvorenie príležitosti – štyri prepojené operácie, z ktorých každá môže zlyhať z vlastných dôvodov. Odovzdanie celého tohto bloku agentovi v jednom príkaze niekedy funguje, ale nikdy nezistíš, kde presne došlo k chybe. Táto lekcia ťa naučí štruktúrovať tieto viacstupňové automatizácie tak, aby bol každý článok pozorovateľný a opakovateľný.

Architektúra založená na krokoch

Začni rozdelením pracovného postupu na atómové kroky, pričom každý má jasný cieľ a kritérium úspechu. Práve toto kritérium odlišuje zoznam úloh od skutočného pracovného postupu: bez neho tvoj orchestrátor nerozozná, či agent skutočne uspel, alebo zastavil na stránke s chybou. V nižšie uvedenom príklade je otvorenie modulu overené URL adresou a vyhľadávanie prítomnosťou mena kontaktu na obrazovke. Prihlásenie tu nie je zahrnuté: tvoj kód to vybavil vopred bez toho, aby odhalil heslo modelu (Lekcia 8). Posledný krok má "retry": False, pretože vytvára dáta: jeho opakovanie po čiastočnom zlyhaní by mohlo vytvoriť duplikát.

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
    },
]

Orchestrátor

Teraz musíš tento zoznam vykonať. Orchestrátor prechádza krokmi sekvenčne a každý z nich obalí do slučky s opakovaním: krok, ktorý vyvolá výnimku alebo nesplní svoje kritérium úspechu, sa opakuje až max_retries-krát, pokiaľ nie je označený ako neopakovateľný. Tento detail je v produkcii dôležitý, pretože mnohé zlyhania vizuálnych agentov sú prechodné – pomalá stránka, neúplné vykreslenie v čase snímky obrazovky. Krok, ktorý definitívne zlyhá, zastaví celý pracovný postup, keďže nasledujúce kroky na ňom závisia. Nakoniec orchestrátor vráti štruktúrovaný záznam, ktorý pre každý krok uvádza jeho stav a počet spotrebovaných pokusov: tvoj prvý diagnostický nástroj.

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

Odovzdávanie dát medzi krokmi

Často jeden krok vyprodukuje dáta potrebné pre ďalší: cena načítaná na stránke košíka sa musí overiť v kroku pokladne; číslo prípadu vytvorené v kroku 2 slúži ako referencia v kroku 5. Zdieľaný kontext rieši túto potrebu bez toho, aby sa tvoj kód zmenil na spletenec globálnych premenných. Nižšie uvedený príklad zámerne končí pred platbou: OpenAI klasifikuje potvrdenie finančnej transakcie ako akciu vyžadujúcu validáciu používateľom v momente vykonania. Trieda nižšie ukladá páry kľúč-hodnota a vystavuje metódu inject, ktorá nahrádza značky {kľúč} v šablóne príkazu, čo ti umožňuje písať úlohy ako parameterizované šablóny.

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)

Podmienené pracovné postupy

Lineárne sekvencie rýchlo narážajú na svoje limity, pretože ďalší krok môže závisieť od výsledku toho predchádzajúceho. Vzorec, ktorý si treba zapamätať, je tento: najprv požiadaj agenta, aby prečítal stav obmedzením jeho odpovede na hodnotu z uzavretej množiny, a potom sa vetvi v Pythone. Pri sledovaní objednávky stav „spracováva sa“ vedie k sledovaniu balíka, „doručené“ k získaniu dátumu doručenia a „zrušené“ k získaniu dôvodu. Obmedzenia formátu v príkaze sú nevyhnutné: bez nich agent vráti vetu, ktorú tvoje porovnania pravidelne minú. Všetky tri vetvy zostávajú len na čítanie: pridanie recenzie alebo opätovné objednanie by zaviazalo používateľa a vyžadovalo si jeho potvrdenie.

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}")

Paralelizácia

Keď sú úlohy nezávislé, nie je potrebné spracovávať ich sekvenčne. Extrakcia dát z troch produktových listov trvá oveľa menej času, ak pracujú traja agenti súčasne, každý vo svojej karte. Async verzia Playwright a asyncio.gather stačia: jedna korutína na URL adresu, jedna new_page na korutínu a systematické zatváranie stránok, aby sa v pamäti nehromadili karty. run_agent_async je slučka z Lekcie 4 prepísaná s klientom AsyncOpenAI a async API Playwright: rovnaká logika, s await pred každým volaním. Maj na pamäti, že paralelizácia tiež násobí priepustnosť tvojich volaní API, čím zvyšuje riziko dosiahnutia limitov rýchlosti (Lekcia 11), a zaťaženie cieľovej stránky – tri karty zostanú bez povšimnutia, päťdesiat oveľa menej.

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))

Kľúčové poznatky

  • Rozdeľ pracovné postupy na atómové kroky s explicitnými kritériami úspechu
  • Automaticky opakuj kroky, ktoré sa dajú bezpečne retryovať, nikdy nie tie, ktoré vytvárajú dáta
  • Použi zdieľaný kontext na odovzdávanie dát medzi krokmi
  • Podmienené pracovné postupy sa prispôsobujú obsahu stránky; vetvy, ktoré zaväzujú používateľa, si vyžadujú jeho potvrdenie
  • Paralelizuj nezávislé úlohy na úsporu času