Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Orodja za asinhrono in vzporedno izvajanje

Lekcija 8 od 25 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Orodja za asinhrono in vzporedno izvajanje
  2. Asinhrona orodja
  3. Samodejno vzporedno izvajanje
  4. Nadzor vzporednosti
  5. Vzorec: Združevanje vzporednih rezultatov
  6. Časovne omejitve in odpornost
  7. Uspešnost: Vpliv vzporednosti
  8. Ključne ugotovitve

Orodja za asinhrono in vzporedno izvajanje

V produkcijskem okolju tvoja orodja kličejo zunanje API-je, poizvedujejo po bazah podatkov ali izvajajo operacije vhoda/izhoda (I/O). Te operacije trajajo, čas pa se sešteva: agent, ki zaporedno izvede pet klicev po eno sekundo, potrebuje pet sekund za odgovor. Prav asinhronost orodij in izkoriščanje samodejnega vzporednega izvajanja v SDK-ju ločita demonstracijski projekt od uporabne storitve.

Asinhrona orodja

Dekorator @function_tool samodejno podpira funkcije async. Ni potrebna nobena dodatna konfiguracija: deklariraj async def, uporabi asinhronega HTTP odjemalca in SDK bo poskrbel za ostalo.

import httpx
from agents import function_tool

@function_tool
async def search_company(name: str) -> str:
    """Poišče informacije o podjetju prek API-ja Societe.com."""
    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"Podjetje: {data['name']}, SIREN: {data['siren']}, Prihodek: {data['revenue']}"
        return f"Ni rezultatov za '{name}'"

@function_tool
async def verify_solvency(siren: str) -> str:
    """Preveri bonitetno sposobnost podjetja na podlagi številke SIREN."""
    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"Bonitetna ocena: {data['score']}/100, tveganje: {data['risk_level']}"

Ko Runner izvede asinhrono orodje, ne blokira zanke dogodkov (event loop). To v strežniku FastAPI pomeni, da se drugi zahtevki obdelujejo naprej, medtem ko tvoj agent čaka na odgovor API-ja Societe.com.

Samodejno vzporedno izvajanje

Dve neodvisni asinhroni orodji se lahko izvedeta hkrati. O tem odloča model, tvoja navodila pa ga lahko k temu izrecno spodbudijo.

from agents import Agent, Runner

agent = Agent(
    name="B2B Analitik",
    instructions="""Analiziraš podjetja za poslovne odločitve.
    Ko te prosijo za analizo podjetja, pridobi njegove informacije
    IN hkrati preveri njegovo bonitetno sposobnost.""",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
)

# Model bo zagnal obe orodji vzporedno
result = await Runner.run(
    agent,
    "Analiziraj podjetje Acme Corp (SIREN 123456789)"
)

Ker je številka SIREN podana že v poizvedbi, preverjanje bonitete ne čaka na iskanje podjetja: SDK izvede oba klica hkrati. Skupni čas je enak trajanju najpočasnejšega orodja, ne vsoti obeh.

Nadzor vzporednosti

Vzporedno izvajanje ni vedno zaželeno. Če tvoja orodja pišejo v isti zapis ali če je za skladnost podatkov pomemben vrstni red, vsili zaporedno izvajanje.

from agents import Agent

agent = Agent(
    name="Previdni agent",
    instructions="Izvedi orodja eno za drugim, da zagotoviš skladnost podatkov.",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
    parallel_tool_calls=False,  # Vsili zaporedno izvajanje
)

Parameter parallel_tool_calls=False prisili model, da kliče le eno orodje naenkrat. Zamenjaš latenco za predvidljivost.

Vzorec: Združevanje vzporednih rezultatov

Najpogostejši praktični primer je zbiranje podatkov iz več virov za isto entiteto. Tukaj vreme in kulturni dogodki v mestu nimata nič skupnega, vendar odgovor potrebuje oboje.

import json
from agents import Agent, Runner, function_tool

@function_tool
async def get_weather(city: str) -> str:
    """Pridobi trenutno vreme za mesto."""
    # Simulacija - v produkciji: klic API-ja za vreme
    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:
    """Pridobi prihajajoče dogodke v mestu."""
    events = {
        "Paris": ["Koncert na Stade de France", "Razstava v Louvru"],
        "Lyon": ["Festival luči", "Sejem gastronomije"],
        "Marseille": ["Sredozemska regata"],
    }
    return json.dumps({
        "city": city,
        "events": events.get(city, [])
    }, ensure_ascii=False)

agent = Agent(
    name="Potovalni agent",
    instructions="""Si potovalni agent. Ko te prosijo
    za priporočila za mesto, hkrati pridobi vreme IN dogodke,
    da zagotoviš popoln nasvet.""",
    tools=[get_weather, get_events],
    model="gpt-5.6-terra",
)

# Model bo za vsako mesto poklical obe orodji vzporedno
result = await Runner.run(
    agent,
    "Ta vikend želim obiskati Pariz. Kaj priporočaš?"
)
print(result.final_output)

Obe orodji vrneta JSON, kar modelu olajša ponovno združevanje podatkov. Bodi pozoren na formulacijo navodil: fraza “IN … hkrati” sproži vzporedni klic namesto lenega zaporedja.

Časovne omejitve in odpornost

API, ki nikoli ne odgovori, blokira tvojega agenta prav tako zanesljivo kot sinhrono orodje. Vsak počasen klic omeji s časovno omejitvijo (timeout) in napake pretvori v razumljiva sporočila.

import asyncio
from agents import function_tool

@function_tool
async def slow_api_call(query: str) -> str:
    """Kliče API, ki je lahko počasen."""
    try:
        async with asyncio.timeout(5):  # Časovna omejitev 5 sekund
            # Tvoj klic API-ja tukaj
            await asyncio.sleep(0.1)  # Simulacija
            return f"Rezultat za '{query}'"
    except asyncio.TimeoutError:
        return "API ni odgovoril pravočasno. Poskusi znova."

Uspešnost: Vpliv vzporednosti

Poglejmo si razmerja v praksi. Tri orodja, ki trajajo po 500 ms in se izvedejo zaporedno, stanejo 1500 ms; ista tri orodja, izvedena vzporedno, stanejo približno 500 ms – toliko, kolikor traja najpočasnejše. Pri agentu, ki uporablja veliko orodij, je ta razlika v praksi takoj opazna.

Ključne ugotovitve

  • Za orodja, ki opravljajo omrežne ali I/O klice, uporabi async.
  • SDK samodejno izvaja neodvisna orodja vzporedno.
  • parallel_tool_calls=False po potrebi vsili zaporedno izvajanje.
  • Za odpornost dodaj časovne omejitve z asyncio.timeout().
  • Vzporednost lahko zmanjša latenco za faktor števila orodij.