Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Asünkroonsed ja paralleelsed tööriistad

Õppetund 8 / 25 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Asünkroonsed ja paralleelsed tööriistad
  2. Asünkroonsed tööriistad
  3. Automaatne paralleelsus
  4. Paralleelsuse juhtimine
  5. Muster: Paralleelsete tulemuste agregeerimine
  6. Aegumised ja vastupidavus
  7. Jõudlus: Paralleelsuse mõju
  8. Peamised punktid

Asünkroonsed ja paralleelsed tööriistad

Tootmiskeskkonnas kutsuvad sinu tööriistad väliseid API-sid, päringuid andmebaasidest või teevad sisend/väljund (I/O) toiminguid. Need toimingud võtavad aega ja see aeg liitub: agent, mis aheldab viis ühesekundilist kõnet, vajab vastamiseks viis sekundit. Tööriistade asünkroonseks muutmine ja SDK loomuliku paralleelsuse ärakasutamine on see, mis eristab demo-versiooni kasutatavast teenusest.

Asünkroonsed tööriistad

Dekoraator @function_tool toetab loomupäraselt async funktsioone. Konfiguratsiooni pole vaja: deklareeri async def, kasuta asünkroonset HTTP-klienti ja SDK hoolitseb ülejäänu eest.

import httpx
from agents import function_tool

@function_tool
async def search_company(name: str) -> str:
    """Otsib ettevõtte teavet Societe.com API kaudu."""
    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"Ettevõte: {data['name']}, SIREN: {data['siren']}, Käive: {data['revenue']}"
        return f"Tulemusi '{name}' jaoks ei leitud"

@function_tool
async def verify_solvency(siren: str) -> str:
    """Kontrollib ettevõtte maksevõimet selle SIREN-numbri põhjal."""
    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"Maksevõime skoor: {data['score']}/100, risk: {data['risk_level']}"

Kui Runner käivitab asünkroonse tööriista, ei blokeeri see sündmuste tsüklit. FastAPI serveris tähendab see, et teised päringud töötlevad edasi, samal ajal kui sinu agent ootab Societe.com API vastust.

Automaatne paralleelsus

Kaks sõltumatut asünkroonset tööriista saavad käivituda samaaegselt. Mudel otsustab selle ja sinu juhised saavad seda sõnaselgelt soodustada.

from agents import Agent, Runner

agent = Agent(
    name="B2B Analüütik",
    instructions="""Sa analüüsid ettevõtteid äriotsuste tegemiseks.
    Kui palutakse ettevõtet analüüsida, too välja selle teave
    JA kontrolli selle maksevõimet samaaegselt.""",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
)

# Mudel käivitab mõlemad tööriistad paralleelselt
result = await Runner.run(
    agent,
    "Analüüsi ettevõtet Acme Corp (SIREN 123456789)"
)

Kuna SIREN on päringus juba olemas, ei oota maksevõime kontroll ettevõtte otsingu lõppu: SDK käivitab mõlemad kõned samaaegselt. Kogu aeg võrdub aeglaseima tööriista kestusega, mitte mõlema summaga.

Paralleelsuse juhtimine

Paralleelsus pole alati soovitav. Kui sinu tööriistad kirjutavad samale kirjele või kui andmete järjepidevuse huvides on oluline järjekord, sunni järjestikust täitmist.

from agents import Agent

agent = Agent(
    name="Ettevaatlik agent",
    instructions="Käivita tööriistad ükshaaval, et tagada andmete järjepidevus.",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
    parallel_tool_calls=False,  # Sunnib järjestikust täitmist
)

Parameeter parallel_tool_calls=False sunnib mudelit kutsuma korraga ainult ühte tööriista. Sa vahetad latentsuse ennustatavuse vastu.

Muster: Paralleelsete tulemuste agregeerimine

Kõige levinum praktiline juhtum hõlmab andmete kogumist mitmest allikast sama üksuse kohta. Siin pole linna ilm ja kultuuriprogramm omavahel seotud, kuid vastus vajab mõlemat.

import json
from agents import Agent, Runner, function_tool

@function_tool
async def get_weather(city: str) -> str:
    """Toob linna praeguse ilma."""
    # Simulatsioon – tootmises: ilma API kõne
    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:
    """Toob linna eelseisvad üritused."""
    events = {
        "Paris": ["Kontsert Stade de France'il", "Näitus Louvre'is"],
        "Lyon": ["Valguste festival", "Gastronoomiamess"],
        "Marseille": ["Vahemere regatt"],
    }
    return json.dumps({
        "city": city,
        "events": events.get(city, [])
    }, ensure_ascii=False)

agent = Agent(
    name="Reisiagent",
    instructions="""Sa oled reisiagent. Kui palutakse
    linna kohta soovitusi, too välja ilm JA üritused
    samaaegselt, et pakkuda terviklikku nõu.""",
    tools=[get_weather, get_events],
    model="gpt-5.6-terra",
)

# Mudel kutsub mõlemad tööriistad iga linna jaoks paralleelselt
result = await Runner.run(
    agent,
    "Soovin sel nädalavahetusel Pariisi külastada. Mida soovitad?"
)
print(result.final_output)

Mõlemad tööriistad tagastavad JSON-i, mis muudab mudelile andmete uuesti kombineerimise lihtsamaks. Pane tähele juhiste sõnastust: „JA … samaaegselt“ käivitab paralleelse kõne, mitte laiska ahelat.

Aegumised ja vastupidavus

API, mis kunagi ei vasta, blokeerib sinu agenti sama kindlalt kui sünkroonne tööriist. Piira iga aeglast kõnet aegumisega ja muuda tõrked arusaadavateks sõnumiteks.

import asyncio
from agents import function_tool

@function_tool
async def slow_api_call(query: str) -> str:
    """Kutsub API-d, mis võib olla aeglane."""
    try:
        async with asyncio.timeout(5):  # 5-sekundiline aegumine
            # Sinu API kõne siia
            await asyncio.sleep(0.1)  # Simulatsioon
            return f"Tulemus päringule '{query}'"
    except asyncio.TimeoutError:
        return "API ei vastanud õigeaegselt. Palun proovi uuesti."

Jõudlus: Paralleelsuse mõju

Vaata skaalat perspektiivi. Kolm 500 ms kestvat tööriista, mis käivitatakse järjest, maksavad 1500 ms; samad kolm tööriista paralleelselt maksavad umbes 500 ms – aeglaseima kestuse. Agendi jaoks, mis kasutab palju tööriistu, on erinevus praktikas koheselt märgatav.

Peamised punktid

  • Kasuta async tööriistade puhul, mis teevad võrgu- või I/O-kõnesid
  • SDK käivitab sõltumatud tööriistad automaatselt paralleelselt
  • parallel_tool_calls=False sunnib vajadusel järjestikust täitmist
  • Lisa vastupidavuse huvides aegumised kasutades asyncio.timeout()
  • Paralleelsus võib vähendada latentsust tööriistade arvu võrra