Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Avtomatizacija večstopenjskih delovnih tokov

Lekcija 9 od 14 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Orkestracija kompleksnih nalog
  2. Arhitektura, temelječa na korakih
  3. Orkestrator
  4. Prenos podatkov med koraki
  5. Pogojni delovni tokovi
  6. Vzporedno izvajanje
  7. Ključne ugotovitve

Lekcija posodobljena 3. novembra 2026 v skladu s smernicami OpenAI za integracijo uporabe računalnika (Computer Use): agent ne upravlja več prijave; preverjanje ukazov in veje, ki zavezujejo uporabnika (ocene, nova naročila), zahtevajo človeško potrditev; orkestrator zdaj preveri merilo success_text_contains, ki ga je prej ignoriral, označi neuspešne korake namesto da bi jih preskočil, in nikoli ne ponovi koraka, ki ustvarja podatke. Vir: Potrditev in soglasje.

Orkestracija kompleksnih nalog

Delovni tokovi v realnem svetu redko sestojijo iz enega samega dejanja. Polnjenje CRM sistema vključuje navigacijo med stranmi, iskanje stika, posodobitev njegovih podatkov in nato ustvarjanje priložnosti – štiri zaporedne operacije, od katerih lahko vsaka odpove iz svojih razlogov. Če celoten blok prepustite agentu v enem samem pozivu, to včasih deluje, vendar nikoli ne boste vedeli, kje je šlo narobe. Ta lekcija vas nauči strukturirati te večstopenjske avtomatizacije tako, da je vsaka povezava opazna in ponovljiva.

Arhitektura, temelječa na korakih

Začnite z razčlenitvijo delovnega toka na atomske korake, vsak z jasnim ciljem in merilom uspeha. To merilo je tisto, kar loči seznam opravil od pravega delovnega toka: brez njega vaš orkestrator ne more vedeti, ali je agent dejansko uspel ali se ustavil na strani z napako. V spodnjem primeru je odpiranje modula preverjeno z URL-jem, iskanje pa s prisotnostjo imena stika na zaslonu. Prijava tukaj ni vključena: vaša koda je to opravila vnaprej, ne da bi geslo razkrila modelu (Lekcija 8). Končni korak ima "retry": False, ker ustvarja podatke: ponovni zagon po delni napaki bi lahko ustvaril duplikat.

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

Orkestrator

Zdaj morate ta seznam izvesti. Orkestrator prehaja skozi korake zaporedno in vsakega ovije v zanko za ponovne poskuse: korak, ki sproži izjemo ali ne izpolni merila uspeha, se ponovi do max_retries-krat, razen če je označen kot neponovljiv. Ta podrobnost je v proizvodnem okolju ključna, saj so številne napake vizualnih agentov prehodne – počasna stran, nepopoln izris ob času posnetka zaslona. Korak, ki dokončno odpove, ustavi delovni tok, saj so od njega odvisni naslednji koraki. Nazadnje orkestrator vrne strukturiran dnevnik, ki za vsak korak navaja njegov status in število porabljenih poskusov: vaše prvo diagnostično orodje.

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

Prenos podatkov med koraki

Pogosto en korak proizvede podatke, potrebne za naslednjega: ceno, prebrano na strani košarice, je treba preveriti ob plačilu; številka primera, ustvarjena v 2. koraku, služi kot referenca v 5. koraku. Skupni kontekst reši to potrebo, ne da bi se vaša koda spremenila v zamotan klub globalnih spremenljivk. Spodnji primer se namerno ustavi pred plačilom: OpenAI uvršča potrditev finančne transakcije med dejanja, ki zahtevajo uporabnikovo validacijo v trenutku izvedbe. Spodnji razred shranjuje pare ključ-vrednost in izpostavlja metodo inject, ki nadomesti označevalce {ključ} v predlogi poziva, kar vam omogoča pisanje nalog kot parametriziranih predlog.

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)

Pogojni delovni tokovi

Linearne sekvence hitro naletijo na svoje meje, saj je naslednji korak lahko odvisen od prejšnjega rezultata. Vzorec, ki si ga morate zapomniti, je ta: najprej prosite agenta, da prebere stanje tako, da ga omejite na odgovor z vrednostjo iz zaprtega nabora, nato pa se razvejite v Pythonu. Pri sledenju naročil status „v obdelavi” vodi do sledenja paketu, „dostavljeno” do pridobitve datuma dostave, „preklicano” pa do pridobitve razloga. Omejitve oblike v pozivu so bistvene: brez njih agent vrne stavek, ki ga vaša primerjava redko zajame. Vse tri veje ostajajo samo za branje: objava ocene ali ponovno naročilo bi zavezalo uporabnika in zahtevalo njegovo potrditev.

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

Vzporedno izvajanje

Ko so naloge neodvisne, jih ni treba obdelovati zaporedno. Pridobivanje podatkov iz treh listov izdelkov traja veliko manj časa, če trije agenti delujejo hkrati, vsak v svojem zavihku. Playwrightova asinhrona različica in asyncio.gather sta dovolj: ena korutina na URL, en new_page na korutino in sistematično zapiranje strani, da se izognete kopičenju zavihkov v pomnilniku. run_agent_async je zanka iz Lekcije 4, napisana znova s klientom AsyncOpenAI in asinhronim API-jem Playwrighta: ista logika, z await pred vsakim klicem. Imejte v mislih, da vzporednost tudi pomnoži vašo prepustnost klicev API-ja, kar povečuje tveganje za dosego omejitev hitrosti (Lekcija 11), in obremenitev ciljnega mesta – trije zavihki ostanejo neopaženi, petdeset pa veliko manj.

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

Ključne ugotovitve

  • Razčlenite delovne tokove na atomske korake z eksplicitnimi merili uspeha
  • Samodejno ponovite korake, ki jih je mogoče varno ponoviti, nikoli pa tistih, ki ustvarjajo podatke
  • Uporabite skupni kontekst za prenos podatkov med koraki
  • Pogojni delovni tokovi se prilagajajo vsebini strani; veje, ki zavezujejo uporabnika, zahtevajo njegovo potrditev
  • Vzporedno izvajajte neodvisne naloge za prihranek časa