Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Nástroje asynchronní a paralelní

Lekce 8 z 25 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Nástroje asynchronní a paralelní
  2. Asynchronní nástroje
  3. Automatický paralelismus
  4. Řízení paralelismu
  5. Vzor: Agregace paralelních výsledků
  6. Časové limity a odolnost
  7. Výkon: Dopad paralelismu
  8. Klíčové poznatky

Nástroje asynchronní a paralelní

V produkčním prostředí tvoje nástroje volají externí API, dotazují se databází nebo provádějí operace vstup/výstup (I/O). Tyto operace trvají určitý čas a tento čas se sčítá: agent, který řetězí pět volání po jedné sekundě, odpoví až za pět sekund. Právě použití asynchronních nástrojů a využití nativního paralelismu SDK odděluje pouhé demo od použitelné služby.

Asynchronní nástroje

Dekorátor @function_tool nativně podporuje funkce async. Není potřeba žádná konfigurace: stačí deklarovat async def, použít asynchronního HTTP klienta a SDK se postará o zbytek.

import httpx
from agents import function_tool

@function_tool
async def search_company(name: str) -> str:
    """Vyhledá informace o společnosti prostřednictvím API 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"Společnost: {data['name']}, SIREN: {data['siren']}, Tržby: {data['revenue']}"
        return f"Žádné výsledky pro '{name}'"

@function_tool
async def verify_solvency(siren: str) -> str:
    """Ověří bonitu společnosti podle jejího čísla 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"Skóre bonity: {data['score']}/100, riziko: {data['risk_level']}"

Když Runner spustí asynchronní nástroj, neblokuje smyčku událostí (event loop). V serveru FastAPI to znamená, že jiné požadavky se stále zpracovávají, zatímco tvůj agent čeká na odpověď z API Societe.com.

Automatický paralelismus

Dva nezávislé asynchronní nástroje mohou běžet současně. O tomto rozhoduje model a tvé instrukce ho mohou k tomu explicitně povzbudit.

from agents import Agent, Runner

agent = Agent(
    name="B2B Analytik",
    instructions="""Analyzuješ společnosti pro obchodní rozhodnutí.
    Když jsi požádán o analýzu společnosti, získej její informace
    A zároveň ověř její bonitu.""",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
)

# Model spustí oba nástroje paralelně
result = await Runner.run(
    agent,
    "Analyzuj společnost Acme Corp (SIREN 123456789)"
)

Protože je číslo SIREN uvedeno přímo v dotazu, kontrola bonity nečeká na vyhledání společnosti: SDK provede oba volání současně. Celkový čas se rovná délce trvání nejpomalejšího nástroje, nikoli součtu obou.

Řízení paralelismu

Paralelismus není vždy žádoucí. Pokud tvoje nástroje zapisují do stejného záznamu nebo pokud je pro konzistenci dat důležitý pořadí, vynuť sekvenční provádění.

from agents import Agent

agent = Agent(
    name="Opatrný agent",
    instructions="Spouštěj nástroje jeden po druhém, aby byla zajištěna konzistence dat.",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
    parallel_tool_calls=False,  # Vynutí sekvenční provádění
)

Parametr parallel_tool_calls=False donutí model volat vždy pouze jeden nástroj najednou. Měníš latenci za předvídatelnost.

Vzor: Agregace paralelních výsledků

Nejběžnějším praktickým případem je shromažďování dat z více zdrojů pro stejnou entitu. Zde například počasí ve městě a kulturní program spolu nijak nesouvisí, ale odpověď potřebuje obojí.

import json
from agents import Agent, Runner, function_tool

@function_tool
async def get_weather(city: str) -> str:
    """Získá aktuální počasí pro dané město."""
    # Simulace – v produkci: volání weather API
    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:
    """Získá nadcházející akce ve městě."""
    events = {
        "Paris": ["Koncert na Stade de France", "Výstava v Louvru"],
        "Lyon": ["Světelný festival", "Gastronomický veletrh"],
        "Marseille": ["Středomořská regata"],
    }
    return json.dumps({
        "city": city,
        "events": events.get(city, [])
    }, ensure_ascii=False)

agent = Agent(
    name="Cestovní agent",
    instructions="""Jsi cestovní agent. Když jsi požádán
    o doporučení pro dané město, získej počasí A události
    současně, abys mohl poskytnout kompletní radu.""",
    tools=[get_weather, get_events],
    model="gpt-5.6-terra",
)

# Model zavolá oba nástroje paralelně pro každé město
result = await Runner.run(
    agent,
    "Chci tento víkend navštívit Paříž. Co doporučuješ?"
)
print(result.final_output)

Oba nástroje vracejí JSON, což modelu usnadňuje opětovné zkombinování dat. Všimni si formulace instrukce: fráze „A … současně“ spustí paralelní volání místo líného řetězení.

Časové limity a odolnost

API, které nikdy neodpoví, zablokuje tvého agenta stejně jistě jako synchronní nástroj. Každé pomalé volání omez časovým limitem a přeměň selhání na srozumitelné zprávy.

import asyncio
from agents import function_tool

@function_tool
async def slow_api_call(query: str) -> str:
    """Volá API, které může být pomalé."""
    try:
        async with asyncio.timeout(5):  # Časový limit 5 sekund
            # Zde tvé volání API
            await asyncio.sleep(0.1)  # Simulace
            return f"Výsledek pro '{query}'"
    except asyncio.TimeoutError:
        return "API neodpovědělo včas. Zkus to prosím znovu."

Výkon: Dopad paralelismu

Uveďme si to do perspektivy. Tři nástroje běžící 500 ms provedené sekvenčně stojí 1500 ms; stejné tři nástroje paralelně stojí asi 500 ms – tedy dobu trvání toho nejpomalejšího. U agenta využívajícího mnoho nástrojů je tento rozdíl v praxi okamžitě znát.

Klíčové poznatky

  • Používej async pro nástroje, které provádějí síťová volání nebo operace I/O
  • SDK automaticky spouští nezávislé nástroje paralelně
  • parallel_tool_calls=False vynutí sekvenční provádění, je-li to potřeba
  • Pro odolnost přidávej časové limity pomocí asyncio.timeout()
  • Paralelismus může snížit latenci úměrně počtu nástrojů