Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Automatizē daudzpakāpju darbplūsmas

Nodarbība 9 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Sarežģītu uzdevumu orķestrēšana
  2. Uz soļiem balstīta arhitektūra
  3. Orķestrators
  4. Datu pārsūtīšana starp soļiem
  5. Nosacītas darbplūsmas
  6. Paralēlizpilde
  7. Galvenās atziņas

Nodarbība atjaunināta 2026. gada 3. novembrī saskaņā ar OpenAI datorlietojuma integrācijas vadlīnijām: aģents vairs neveic pieteikšanos; komandu validācija un zari, kas saista lietotāju (atsauksmes, jauni pasūtījumi), prasa cilvēka apstiprinājumu; orķestrators tagad pārbauda success_text_contains kritēriju, ko iepriekš ignorēja, atzīmē neizdevušos soļus, nevis izlaiž tos, un nekad neatkārto soli, kas rada datus. Avots: Apstiprinājums un piekrišana.

Sarežģītu uzdevumu orķestrēšana

Reālas darbplūsmas reti sastāv no vienas darbības. CRM aizpildīšana ietver pārvietošanos starp lapām, kontakta atrašanu, tā informācijas atjaunināšanu un pēc tam iespējas izveidi — četras ķēdē savienotas operācijas, no kurām katra var neizdoties savu iemeslu dēļ. Visa šī bloka uzticēšana aģentam vienā prasībā dažkārt strādā, taču tu nekad neuzzināsi, kur tieši tas izgāzās. Šī nodarbība iemācīs tev strukturēt šīs daudzpakāpju automatizācijas tā, lai katrs posms būtu novērojams un atkārtojams.

Uz soļiem balstīta arhitektūra

Sāc, sadalot darbplūsmu atomāros soļos, katram ar skaidru mērķi un veiksmes kritēriju. Tieši šis kritērijs atšķir uzdevumu sarakstu no patiesas darbplūsmas: bez tā tavs orķestrators nevar noteikt, vai aģents patiešām guva panākumus vai apstājās pie kļūdas lapas. Zemāk redzamajā piemērā moduļa atvēršana tiek verificēta pēc URL, bet meklēšana — pēc kontakta vārda klātbūtnes ekrānā. Pieteikšanās šeit nav iekļauta: tavs kods to apstrādāja iepriekš, neizpaužot paroli modelim (8. nodarbība). Pēdējam solim ir "retry": False, jo tas rada datus: tā atkārtošana pēc daļējas kļūmes varētu izveidot dublikātu.

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

Orķestrators

Tagad tev jāizpilda šis saraksts. Orķestrators secīgi iziet cauri soļiem, katru ietverot atkārtošanas ciklā: solis, kas izraisa izņēmumu vai neizpilda savu veiksmes kritēriju, tiek atkārtots līdz max_retries reizēm, ja vien tas nav atzīmēts kā neatkārtojams. Šī detaļa ir svarīga ražošanas vidē, jo daudzi vizuālo aģentu darbības traucējumi ir pārejoši — lēna lapa, nepilnīga attēlošana ekrānuzņēmuma brīdī. Solis, kas neizdodas galīgi, aptur darbplūsmu, jo turpmākie soļi ir atkarīgi no tā. Visbeidzot, orķestrators atgriež strukturētu žurnālu, norādot katram solim tā statusu un izmantoto mēģinājumu skaitu: tavs pirmais diagnostikas rīks.

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

Datu pārsūtīšana starp soļiem

Bieži vien viens solis ģenerē datus, kas nepieciešami nākamajam: cenai, kas nolasīta groza lapā, jābūt verificētai norēķinu solī; lietas numurs, kas izveidots 2. solī, kalpo kā atsauce 5. solī. Kopīgs konteksts atrisina šo vajadzību, nepārvēršot tavu kodu globālo mainīgo sajukumā. Zemāk redzamais piemērs apzināti apstājas pirms maksājuma: OpenAI klasificē finanšu darījuma apstiprināšanu kā darbību, kas izpildes brīdī prasa lietotāja validāciju. Tālāk esošā klase glabā atslēgu-vērtību pārus un eksponē metodi inject, kas aizstāj {key} marķierus prasības veidnē, ļaujot tev rakstīt uzdevumus kā parametrizētas veidnes.

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)

Nosacītas darbplūsmas

Lineāras secības ātri sasniedz savas robežas, jo nākamais solis var būt atkarīgs no iepriekšējā rezultāta. Atceries šo modeli: vispirms liec aģentam nolasīt stāvokli, ierobežojot to atbildēt ar vērtību no slēgtas kopas, un pēc tam veic zarošanu Python valodā. Pasūtījuma izsekošanai statuss „apstrādē” noved pie sūtījuma izsekošanas, „piegādāts” — pie piegādes datuma iegūšanas, „atcelts” — pie iemesla uzzināšanas. Formāta ierobežojumi prasībā ir būtiski: bez tiem aģents atgriež teikumu, kuru tavas salīdzināšanas regulāri palaidīs garām. Visi trīs zari paliek tikai lasāmi: atsauksmes publicēšana vai pasūtījuma atkārtošana saistītu lietotāju un prasītu tā apstiprinājumu.

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

Paralēlizpilde

Kad uzdevumi ir neatkarīgi, nav nepieciešams tos apstrādāt secīgi. Datu izgūšana no trim produktu lapām aizņem daudz mazāk laika, ja trīs aģenti strādā vienlaicīgi, katrs savā cilnē. Pietiek ar Playwright asinhrono versiju un asyncio.gather: viena korutina katram URL, viena new_page katrai korutīnai un sistemātiska lapu aizvēršana, lai izvairītos no cilņu uzkrāšanās atmiņā. run_agent_async ir 4. nodarbības cikls, pārrakstīts ar AsyncOpenAI klientu un Playwright asinhrono API: tā pati loģika, ar await pirms katra izsaukuma. Patur prātā, ka paralēlisms arī reizina tavu API izsaukumu caurlaidspēju, palielinot risku sasniegt ātruma ierobežojumus (11. nodarbība), un slodzi uz mērķa vietni — trīs cilnes paliek nepamanītas, piecdesmit — daudz mazāk.

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

Galvenās atziņas

  • Sadali darbplūsmas atomāros soļos ar skaidriem veiksmes kritērijiem
  • Automātiski atkārto soļus, kurus var droši atkārtot, nekad tos, kas rada datus
  • Izmanto kopīgu kontekstu, lai pārsūtītu datus starp soļiem
  • Nosacītas darbplūsmas pielāgojas lapas saturam; zari, kas saista lietotāju, prasa tā apstiprinājumu
  • Paralēlizpildi neatkarīgus uzdevumus, lai ietaupītu laiku