Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Automatisoi monivaiheisia työnkulkuja

Oppitunti 9 / 14 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Monimutkaisten tehtävien orkestrointi
  2. Vaihepohjainen arkkitehtuuri
  3. Orkestroija
  4. Datan välittäminen vaiheiden välillä
  5. Ehdolliset työnkulut
  6. Rinnakkais suoritus
  7. Keskeiset asiat

Oppitunti päivitetty 3. marraskuuta 2026 OpenAI:n tietokoneen käyttöä koskevien integrointiohjeiden mukaisesti: agentti ei enää käsittele kirjautumista; komentojen validointi ja käyttäjän sitovat haarat (arvostelut, uudet tilaukset) vaativat ihmisen vahvistuksen; orkestroija tarkistaa nyt aiemmin huomiotta jättämänsä success_text_contains-ehdon, merkitsee epäonnistuneet vaiheet ohittamisen sijaan virheellisiksi eikä toista koskaan vaihetta, joka luo dataa. Lähde: Confirmation and consent.

Monimutkaisten tehtävien orkestrointi

Todelliset työnkulut harvoin koostuvat yhdestä ainoasta toiminnosta. CRM-järjestelmän täyttäminen sisältää sivujen välillä navigoinnin, yhteystiedon etsimisen, tietojen päivittämisen ja mahdollisuuden luomisen – neljä ketjutettua operaatiota, joista jokainen voi epäonnistua omista syistään. Koko kokonaisuuden antaminen agentille yhdessä kehotteessa toimii joskus, mutta et koskaan tiedä, missä kohtaa se epäonnistui. Tämä oppitunti opettaa sinua rakentamaan nämä monivaiheiset automaatiot niin, että jokainen lenkki on havainnoitavissa ja toistettavissa.

Vaihepohjainen arkkitehtuuri

Aloita jakamalla työnkulku atomisiin vaiheisiin, joilla jokaisella on selkeä tavoite ja onnistumiskriteeri. Tämä kriteeri erottaa tehtävälistan aidosta työnkulusta: ilman sitä orkestroijasi ei pysty päättelemään, onko agentti todella onnistunut vai pysähtynyt virhesivulle. Alla olevassa esimerkissä moduulin avaaminen varmistetaan URL-osoitteella ja haku yhteystiedon nimen näkyvyydellä ruudulla. Kirjautumista ei ole sisällytetty tähän: koodisi hoiti sen etukäteen paljastamatta salasanaa mallille (oppitunti 8). Viimeisellä vaiheella on "retry": False, koska se luo dataa: sen toistaminen osittaisen epäonnistumisen jälkeen voisi luoda kaksoiskappaleen.

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

Orkestroija

Nyt sinun tulee suorittaa tämä lista. Orkestroija käy vaiheet läpi sekventiaalisesti käärien jokaisen uudelleenyrityssilmukkaan: vaihe, joka nostaa poikkeuksen tai epäonnistuu onnistumiskriteerissään, yritetään uudelleen enintään max_retries kertaa, ellei sitä ole merkitty ei-toistettavaksi. Tämä yksityiskohta on tärkeä tuotantoympäristössä, koska monet visuaalisen agentin epäonnistumiset ovat ohimeneviä – hidas sivu tai keskeneräinen renderöinti kuvankaappauksen hetkellä. Lopullisesti epäonnistuva vaihe pysäyttää työnkulun, sillä myöhemmät vaiheet riippuvat siitä. Lopuksi orkestroija palauttaa jäsennellyn lokin, joka kertoo jokaisen vaiheen osalta sen tilan ja kulutettujen yritysten määrän: ensimmäinen vianmääritystyökalusi.

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

Datan välittäminen vaiheiden välillä

Usein yksi vaihe tuottaa dataa, jota seuraava tarvitsee: ostoskorisivulta luettu hinta on vahvistettava kassavaiheessa; vaiheessa 2 luotu tapausnumero toimii viitteenä vaiheessa 5. Jaettu konteksti ratkaisee tämän tarpeen muuttamatta koodiasi globaalien muuttujien sotkuksi. Alla oleva esimerkki pysähtyy tarkoituksellisesti ennen maksua: OpenAI luokittelee taloudellisen transaktion vahvistamisen toiminnoksi, joka vaatii käyttäjän validointia suorituksen hetkellä. Alla oleva luokka tallentaa avain-arvo-pareja ja tarjoaa inject-metodin, joka korvaa {key}-merkit kehotemallissa, jolloin voit kirjoittaa tehtäväsi parametrisoituina malleina.

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)

Ehdolliset työnkulut

Lineaariset sekvenssit törmäävät nopeasti rajoihinsa, koska seuraava vaihe voi riippua edellisestä tuloksesta. Muistettava malli on tämä: pyydä ensin agenttia lukemaan tila rajoittamalla se vastaamaan arvoa suljetusta joukosta, ja tee sitten haaroitus Pythonissa. Tilauksen seurannassa “käsitellään”-tila johtaa paketin seurantaan, “toimitettu” toimituspäivän hakemiseen ja “peruutettu” syyn hakemiseen. Muotoilurajoitukset kehotteessa ovat olennaisia: ilman niitä agentti palauttaa lauseen, jonka vertailusi eivät säännöllisesti tavoita. Kaikki kolme haaraa pysyvät vain luku -tilassa: arvostelun lähettäminen tai uudelleentilaaminen sitoisivat käyttäjän ja vaatisivat hänen vahvistuksensa.

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

Rinnakkais suoritus

Kun tehtävät ovat toisistaan riippumattomia, niitä ei tarvitse käsitellä sekventiaalisesti. Datan extracting kolmesta tuotesivusta vie huomattavasti vähemmän aikaa, jos kolme agenttia työskentelee samanaikaisesti, kukin omassa välilehdessään. Playwrightin async-versio ja asyncio.gather riittävät: yksi korutiini URL-osoitetta kohden, yksi new_page korutiinia kohden ja järjestelmällinen sivun sulkeminen välilehtien kertymisen estämiseksi muistissa. run_agent_async on oppitunnin 4 silmukka uudelleenkirjoitettuna AsyncOpenAI-asiakkaan ja Playwrightin async-API:n kanssa: sama logiikka, mutta await jokaisen kutsun edessä. Pidä mielessä, että rinnakkaisuus myös moninkertaistaa API-kutsujesi läpimenon, kasvattaen riskiä osua nopeusrajoituksiisi (oppitunti 11), ja kuormitustasi kohdesivustolla – kolme välilehteä jää huomaamatta, viisikymmentä huomataan paljon helpommin.

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

Keskeiset asiat

  • Jaa työnkulut atomisiin vaiheisiin, joilla on eksplisiittiset onnistumiskriteerit
  • Toista automaattisesti vaiheet, jotka voidaan yrittää turvallisesti uudelleen, mutta ei koskaan dataa luovia vaiheita
  • Käytä jaettua kontekstia datan välittämiseen vaiheiden välillä
  • Ehdolliset työnkulut mukautuvat sivun sisältöön; käyttäjän sitovat haarat vaativat hänen vahvistuksensa
  • Rinnakkaista riippumattomia tehtäviä säästääksesi aikaa