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

Rīki asinhronai un paralēlai darbībai

Nodarbība 8 no 25 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Rīki asinhronai un paralēlai darbībai
  2. Asinhronie rīki
  3. Automātiskais paralēlisms
  4. Paralēlisma kontrole
  5. Paradums: Paralēlu rezultātu apkopošana
  6. Noildzes un noturība
  7. Veiktspēja: Paralēlisma ietekme
  8. Galvenās atziņas

Rīki asinhronai un paralēlai darbībai

Produkcijas vidē tavi rīki izsauc ārējās API, veic vaicājumus datubāzēm vai veic I/O operācijas. Šīs darbības prasa laiku, un tas summējas: aģents, kas secīgi veic piecus vienu sekundi ilgu izsaukumus, atbildi sniedz pēc piecām sekundēm. Tieši rīku padarīšana par asinhroniem un SDK natīvās paralēlisma spēju izmantošana atšķir demonstrācijas projektu no lietojama servisa.

Asinhronie rīki

Dekoratīvs @function_tool natīvi atbalsta async funkcijas. Nav nepieciešama nekāda konfigurācija: vienkārši deklarē async def, izmanto asinhronu HTTP klientu, un SDK pārējais nokārto pats.

import httpx
from agents import function_tool

@function_tool
async def search_company(name: str) -> str:
    """Meklē uzņēmuma informāciju, izmantojot Societe.com API."""
    async with httpx.AsyncClient() as client:
        response = await client.get(
            "https://api.societe.com/v1/search",
            params={"q": name},
            timeout=10,
        )
        if response.status_code == 200:
            data = response.json()
            return f"Uzņēmums: {data['name']}, SIREN: {data['siren']}, Apgrozījums: {data['revenue']}"
        return f"Nav rezultātu priekš '{name}'"

@function_tool
async def verify_solvency(siren: str) -> str:
    """Pārbauda uzņēmuma maksātspēju pēc tā SIREN numura."""
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://api.credit-scoring.com/v1/{siren}",
            timeout=10,
        )
        data = response.json()
        return f"Maksātspējas vērtējums: {data['score']}/100, risks: {data['risk_level']}"

Kad Runner izpilda asinhronu rīku, tas nebloķē notikumu cilpu (event loop). FastAPI serverī tas nozīmē, ka citi pieprasījumi tiek apstrādāti tālāk, kamēr tavs aģents gaida atbildi no Societe.com API.

Automātiskais paralēlisms

Divi neatkarīgi asinhroni rīki var darboties vienlaicīgi. To izlemj modelis, un tavas instrukcijas var to tieši veicināt.

from agents import Agent, Runner

agent = Agent(
    name="B2B Analītiķis",
    instructions="""Tu analizē uzņēmumus biznesa lēmumu pieņemšanai.
    Kad tiek lūgts analizēt uzņēmumu, iegūsti tā informāciju
    UN vienlaicīgi pārbaudi tā maksātspēju.""",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
)

# Modelis palaidīs abus rīkus paralēli
result = await Runner.run(
    agent,
    "Analizē uzņēmumu Acme Corp (SIREN 123456789)"
)

Tā kā SIREN numurs ir norādīts vaicājumā, maksātspējas pārbaude negaida uz uzņēmuma meklēšanas pabeigšanu: SDK izpilda abus izsaukumus vienlaicīgi. Kopējais laiks ir vienāds ar lēnākā rīka ilgumu, nevis abu summa.

Paralēlisma kontrole

Paralēlisms ne vienmēr ir vēlams. Ja tavi rīki raksta vienā ierakstā vai ja datu konsekvences nodrošināšanai ir svarīga secība, piespied secīgu izpildi.

from agents import Agent

agent = Agent(
    name="Piesardzīgs aģents",
    instructions="Izpildi rīkus vienu pēc otra, lai nodrošinātu datu konsekvenci.",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
    parallel_tool_calls=False,  # Piespiedu secīga izpilde
)

Parametrs parallel_tool_calls=False piespiež modeli izsaukt tikai vienu rīku vienlaicīgi. Tu apmaini latentumu pret paredzamību.

Paradums: Paralēlu rezultātu apkopošana

Visbiežāk sastopamais praktiskais gadījums ir datu vākšana no vairākiem avotiem par vienu un to pašu entītiju. Šeit pilsētas laika apstākļiem un kultūras pasākumu kalendāram nav nekāda sakara vienam ar otru, taču atbildei ir nepieciešami abi.

import json
from agents import Agent, Runner, function_tool

@function_tool
async def get_weather(city: str) -> str:
    """Iegūst aktuālos laika apstākļus pilsētā."""
    # Simulācija - produkcijā: laika apstākļu API izsaukums
    weather_data = {
        "Paris": {"temp": 22, "conditions": "sunny"},
        "Lyon": {"temp": 19, "conditions": "cloudy"},
        "Marseille": {"temp": 26, "conditions": "sunny"},
    }
    data = weather_data.get(city, {"temp": 0, "conditions": "unknown"})
    return json.dumps({"city": city, **data}, ensure_ascii=False)

@function_tool
async def get_events(city: str) -> str:
    """Iegūst gaidāmos pasākumus pilsētā."""
    events = {
        "Paris": ["Koncerts Stade de France", "Izstāde Luvrā"],
        "Lyon": ["Gaismas festivāls", "Gastronomijas gadatirgus"],
        "Marseille": ["Vidusjūras regate"],
    }
    return json.dumps({
        "city": city,
        "events": events.get(city, [])
    }, ensure_ascii=False)

agent = Agent(
    name="Ceļojumu aģents",
    instructions="""Tu esi ceļojumu aģents. Kad tiek lūgti
    ieteikumi konkrētai pilsētai, iegūsti laika apstākļus UN pasākumus
    vienlaicīgi, lai sniegtu pilnīgu konsultāciju.""",
    tools=[get_weather, get_events],
    model="gpt-5.6-terra",
)

# Modelis izsauks abus rīkus paralēli katrai pilsētai
result = await Runner.run(
    agent,
    "Es vēlos šajā nedēļas nogalē apmeklēt Parīzi. Ko tu ieteiktu?"
)
print(result.final_output)

Abi rīki atgriež JSON, kas atvieglo modelim datu atkārtotu apvienošanu. Pievērs uzmanību instrukciju formulējumam: frāze “UN … vienlaicīgi” izraisa paralēlu izsaukumu, nevis gausu ķēdi.

Noildzes un noturība

API, kas nekad neatbild, bloķē tavu aģentu tikpat droši kā sinhrons rīks. Katru lēno izsaukumu ierobežo ar noildi (timeout) un pārvērt kļūmes saprotamos ziņojumos.

import asyncio
from agents import function_tool

@function_tool
async def slow_api_call(query: str) -> str:
    """Izsauc API, kas var būt lēns."""
    try:
        async with asyncio.timeout(5):  # 5 sekunžu noilde
            # Tavs API izsaukums šeit
            await asyncio.sleep(0.1)  # Simulācija
            return f"Rezultāts priekš '{query}'"
    except asyncio.TimeoutError:
        return "API neatbildēja laikā. Lūdzu, mēģini vēlreiz."

Veiktspēja: Paralēlisma ietekme

Aplūkosim mērogu. Trīs rīki, kas katrs ilgst 500 ms, izpildīti secīgi, aizņem 1500 ms; tie paši trīs rīki, izpildīti paralēli, aizņem aptuveni 500 ms – tik ilgi, cik ilgst lēnākais no tiem. Aģentam, kas izmanto daudzus rīkus, šī atšķirība praksē ir acumirklī pamanāma.

Galvenās atziņas

  • Izmanto async rīkiem, kas veic tīkla vai I/O izsaukumus
  • SDK automātiski izpilda neatkarīgus rīkus paralēli
  • parallel_tool_calls=False piespiedu kārtā nodrošina secīgu izpildi, kad tas ir nepieciešams
  • Pievieno noildzes, izmantojot asyncio.timeout(), lai nodrošinātu noturību
  • Paralēlisms var samazināt latentumu tik reižu, cik daudz rīku tiek izmantoti