Automatizuokite daugiažingsnes darbo eigas
Šiame puslapyje
Pamoka atnaujinta 2026 m. lapkričio 3 d. pagal „OpenAI“ kompiuterio naudojimo integracijos gaires: agentas nebevaldo prisijungimo; komandų tikrinimui ir šakoms, įpareigojančioms naudotoją (apžvalgos, nauji užsakymai), reikia žmogaus patvirtinimo; orchestratorius dabar tikrina anksčiau ignoruotą
success_text_containskriterijų, žymi nepavykusius žingsnius vietoj jų praleidimo ir niekada nekartoją žingsnio, kuris kuria duomenis. Šaltinis: Patvirtinimas ir sutikimas.
Sudėtingų užduočių orchestravimas
Realiame pasaulyje darbo eigos retai susideda iš vieno veiksmo. CRM sistemos pildymas apima naršymą tarp puslapių, kontakto radimą, jo informacijos atnaujinimą ir galimybės sukūrimą – keturias grandininės operacijas, kurių kiekviena gali nepavykti dėl savo priežasčių. Viso šio bloko perdavimas agentui vienu raginimu kartais veikia, tačiau niekada nežinosite, kur tiksliai įvyko klaida. Šioje pamokoje išmoksi struktūruoti šias daugiažingsnes automatizacijas taip, kad kiekviena grandis būtų stebima ir pakartojama.
Žingsniais pagrįsta architektūra
Pradėk nuo darbo eigos suskaidymo į atominius žingsnius, kurių kiekvienas turi aiškų tikslą ir sėkmės kriterijų. Būtent šis kriterijus atskiria darbų sąrašą nuo tikros darbo eigos: be jo tavo orchestratorius negali nustatyti, ar agentas iš tikrųjų pasiekė tikslą, ar sustojo ties klaidos puslapiu. Toliau pateiktame pavyzdyje modulio atidarymas tikrinamas pagal URL, o paieška – pagal kontakto vardo buvimą ekrane. Prisijungimas čia neįtrauktas: tavo kodas tai atliko iš anksto, neatskleisdamas slaptažodžio modeliui (8 pamoka). Paskutinis žingsnis turi "retry": False, nes jis kuria duomenis: jo kartojimas po dalinio gedimo gali sukurti dublikatą.
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
},
]
Orchestratorius
Dabar reikia vykdyti šį sąrašą. Orchestratorius eina per žingsnius nuosekliai, kiekvieną apgaubdamas kartojimo ciklu: žingsnis, kuris išmeta išimtį arba neatitinka sėkmės kriterijaus, kartojamas iki max_retries kartų, nebent jis pažymėtas kaip nepakartojamas. Ši detalė svarbi gamyboje, nes daugelis vaizdinių agentų gedimų yra laikini – lėtas puslapis, neužbaigtas atvaizdavimas ekrano kopijos darymo metu. Žingsnis, kuris galutinai nepavyksta, sustabdo visą darbo eigą, nes vėlesni žingsniai nuo jo priklauso. Galiausiai orchestratorius grąžina struktūruotą žurnalą, nurodantį kiekvieno žingsnio būseną ir sunaudotų bandymų skaičių: tai tavo pirmasis diagnostikos įrankis.
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
Duomenų perdavimas tarp žingsnių
Dažnai vienas žingsnis sukuria duomenis, reikalingus kitam: kainą, nuskaitytą iš krepšelio puslapio, reikia patikrinti atsiskaitymo žingsnyje; 2 žingsnyje sukurtas bylos numeris tarnauja kaip nuoroda 5 žingsnyje. Bendras kontekstas išsprendžia šį poreikį nepaversdamas tavo kodo globalių kintamųjų painiava. Toliau pateiktame pavyzdyje sąmoningai sustojama prieš mokėjimą: „OpenAI“ finansinės operacijos patvirtinimą klasifikuoja kaip veiksmą, reikalaujantį naudotojo patvirtinimo vykdymo metu. Toliau esanti klasė saugo raktų ir reikšmių poras bei pateikia inject metodą, kuris pakeičia {key} žymeklius raginimo šablone, leisdamas rašyti užduotis kaip parametrizuotus šablonus.
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)
Sąlyginės darbo eigos
Tiesinės sekos greitai pasiekia savo ribas, nes kitas žingsnis gali priklausyti nuo ankstesnio rezultato. Įsimintinas modelis yra toks: pirmiausia paprašyk agento nuskaityti būseną, apribojant jį atsakyti reikšme iš uždaro aibės, tada šakokis „Python“ kalboje. Užsakymo sekimui būsena „vykdoma“ („processing“) veda prie siuntos sekimo, „pristatyta“ („delivered“) – prie pristatymo datos gavimo, „atšaukta“ („canceled“) – prie priežasties nustatymo. Formatavimo apribojimai raginime yra esminiai: be jų agentas grąžins sakinį, kurio tavo palyginimai reguliariai nepagaus. Visos trys šakos lieka tik skaitymui: apžvalgos rašymas arba užsakymo kartojimas įpareigotų naudotoją ir reikalautų jo patvirtinimo.
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}")
Lygiagretinimas
Kai užduotys yra nepriklausomos, jų nereikia vykdyti nuosekliai. Duomenų ištraukimas iš trijų produktų lapų užtrunka daug mažiau laiko, jei trys agentai dirba vienu metu, kiekvienas savo kortelėje. „Playwright“ asinchroninė versija ir asyncio.gather yra pakankami: viena korutina kiekvienam URL, vienas new_page kiekvienai korutinai ir sistemingas puslapio uždarymas, kad išvengtumėte kortelių kaupimosi atmintyje. run_agent_async yra 4 pamokos ciklas, perrašytas naudojant AsyncOpenAI klientą ir „Playwright“ asinchroninį API: ta pati logika, tik prieš kiekvieną kvietimą dedamas await. Atmink, kad lygiagretumas taip pat padidina tavo API kvietimų srautą, didindamas riziką pasiekti tavo greičio ribas (11 pamoka), ir tavo apkrovą tikslinamajai svetainei – trys kortelės lieka nepastebėtos, penkiasdešimt – daug mažiau.
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))
Svarbiausi punktai
- Suskirstyk darbo eigas į atominius žingsnius su aiškiais sėkmės kriterijais
- Automatiškai kartok žingsnius, kuriuos galima saugiai kartoti, bet niekada nekartok tų, kurie kuria duomenis
- Naudok bendrą kontekstą duomenims perduoti tarp žingsnių
- Sąlyginės darbo eigos prisitaiko prie puslapio turinio; šakos, įpareigojančios naudotoją, reikalauja jo patvirtinimo
- Lygiagrečink nepriklausomas užduotis, kad sutaupytum laiko