Automatiseeri mitmeastmelisi töövooge
Sellel lehel
Õppetund uuendatud 3. novembril 2026 vastavalt OpenAI arvutikasutuse integreerimise juhistele: agent enam ei tegele sisselogimisega; käskude valideerimine ja harud, mis kohustavad kasutajat (ülevaated, uued tellimused), nõuavad inimlikku kinnitust; orkestraator kontrollib nüüd
success_text_containskriteeriumi, mida ta varem eiras, märgistab ebaõnnestunud sammud nende vahelejätmise asemel ja ei korda kunagi sammu, mis loob andmeid. Allikas: Kinnitamine ja nõusolek.
Komplekssete ülesannete orkestreerimine
Tegelikkuses koosnevad töövoog harva vaid ühest tegevusest. CRM-i täitmine hõlmab lehtede vahel liikumist, kontakti leidmist, tema andmete uuendamist ja seejärel võimaluse loomist – neli aheldatud toimingut, millest igaüks võib oma põhjustel ebaõnnestuda. Kogu selle ploki usaldamine agendile ühe vihjena toimib mõnikord, kuid sa ei saa kunagi teada, kus täpselt viga juhtus. See õppetund õpetab sind struktureerima mitmeastmelisi automatiseerimisi nii, et iga lüli oleks jälgitav ja korratav.
Sammupõhine arhitektuur
Alusta töövoogu atomseteks sammudeks jagamisest, millest igal on selge eesmärk ja õnnestumise kriteerium. Just see kriteerium eristab tegemiste nimekirja tõelisest töövoost: ilma selleta ei suuda sinu orkestraator öelda, kas agent tegelikult õnnestus või peatus vealehel. Allpool toodud näites kontrollitakse mooduli avamist URL-i põhjal ja otsingut kontakti nime ekraanil olemasolu põhjal. Sisselogimist siin ei ole: sinu kood tegi seda eelnevalt, paljastamata salasõna mudelile (Õppetund 8). Viimasel sammul on "retry": False, kuna see loob andmeid: selle kordamine pärast osalist ebaõnnestumist võib tekitada duplikaadi.
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
},
]
Orkestraator
Nüüd tuleb see nimekiri täita. Orkestraator läbib sammud järjestikku, pakkides igaühe kordamistsüklisse: samm, mis tõstab erindi või ei vasta õnnestumise kriteeriumile, korratakse kuni max_retries korda, välja arvatud juhul, kui see on märgistatud mittekorratavaks. See detail on tootmises oluline, kuna paljud visuaalse agendi tõrked on mööduvad – aeglane leht või puudulik renderdamine ekraanitõmmise tegemise hetkel. Lõplikult ebaõnnestunud samm peatab töövoogu, kuna sellele tuginevad järgnevad sammud. Lõpuks tagastab orkestraator struktureeritud logi, mis näitab iga sammu kohta selle olekut ja tarbitud katsete arvu: sinu esimene diagnostikavahend.
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
Andmete edastamine sammude vahel
Sageli toodab üks samm andmeid, mida on vaja järgmises: ostukorvi lehel loetud hind tuleb kassasammus üle kontrollida; 2. sammus loodud juhtumi number toimib viitena 5. sammus. Jagatud kontekst lahendab selle vajaduse, muutmata sinu koodi globaalsete muutujate sasipundriks. Allpool toodud näide peatub tahtlikult enne makset: OpenAI liigitab finantstehingu kinnitamise tegevuseks, mis nõuab kasutaja valideerimist täitmise hetkel. Allpool olev klass salvestab võtme-väärtuse paare ja pakub meetodit inject, mis asendab vihje mallis {key} markerid, võimaldades sul kirjutada ülesandeid parameetriseeritud mallidena.
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)
Tingimuslikud töövoog
Lineaarsed jadad jõuavad kiiresti oma piirideni, kuna järgmine samm võib sõltuda eelmise tulemusest. Meeldejääv muster on see: palu agendil kõigepealt olek lugeda, piirates teda vastama suletud hulgast pärit väärtusega, ja seejärel teota harud Pythonis. Tellimuse jälgimisel viib olek „töötlemisel“ pakendi jälgimiseni, „kohale toimetatud“ tarnekuupäeva hankimiseni ja „tühistatud“ põhjuse väljaselgitamiseni. Vormingupiirangud vihjes on hädavajalikud: ilma nendeta tagastab agent lause, mida sinu võrdlused regulaarselt ei taba. Kõik kolm haru jäävad ainult lugemisrežiimi: ülevaate postitamine või tellimuse kordamine kohustaks kasutajat ja nõuaks tema kinnitust.
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}")
Paralleliseerimine
Kui ülesanded on sõltumatud, pole vaja neid järjestikku töödelda. Andmete ekstraheerimine kolmest tootelehest võtab palju vähem aega, kui kolm agenti töötavad samaaegselt, igaüks oma vahekaardis. Playwrighti asünkroonne versioon ja asyncio.gather on piisavad: üks korutiin URL-i kohta, üks new_page korutiini kohta ja süstemaatiline lehe sulgemine, et vältida vahekaartide kuhjumist mällu. run_agent_async on 4. õppetunni tsükkel, mis on ümber kirjutatud AsyncOpenAI kliendi ja Playwrighti asünkroonse API-ga: sama loogika, kus iga kõne ees on await. Pea meeles, et parallelism korrutab ka sinu API-kõnede läbilaskevõimet, suurendades riski jõuda oma kiirusepiiranguteni (Õppetund 11), ning koormust sihtsaidile – kolm vahekaarti jäävad märkamatuks, viiskümmend palju vähem.
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))
Peamised punktid
- Jaota töövoog atomseteks sammudeks koos selgete õnnestumise kriteeriumidega
- Korda automaatselt samme, mida saab ohutult uuesti proovida, mitte kunagi neid, mis loovad andmeid
- Kasuta jagatud konteksti andmete edastamiseks sammude vahel
- Tingimuslikud töövoog kohanevad lehe sisuga; harud, mis kohustavad kasutajat, nõuavad tema kinnitust
- Paralleliseeri sõltumatuid ülesandeid aja säästmiseks