Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Asynchrone en parallelle tools

Les 8 van 25 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Asynchrone en parallelle tools
  2. Asynchrone tools
  3. Automatisch parallelisme
  4. Parallelisme sturen
  5. Patroon: Parallelle resultaten aggregeren
  6. Time-outs en veerkracht
  7. Prestaties: Impact van parallelisme
  8. Belangrijkste punten

Asynchrone en parallelle tools

In productieomgevingen roepen uw tools externe API’s aan, bevragen databases of voeren I/O-bewerkingen uit. Deze bewerkingen kosten tijd, en die tijd telt op: een agent die vijf oproepen van één seconde achter elkaar uitvoert, doet er vijf seconden over om te reageren. Het asynchroon maken van tools en het benutten van de native parallelisme-mogelijkheden van de SDK is wat het verschil maakt tussen een demo en een bruikbare service.

Asynchrone tools

De decorator @function_tool ondersteunt native async-functies. Er is geen configuratie vereist: declareer async def, gebruik een asynchrone HTTP-client en de SDK regelt de rest.

import httpx
from agents import function_tool

@function_tool
async def search_company(name: str) -> str:
    """Zoekt bedrijfsinformatie via de 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"Bedrijf: {data['name']}, SIREN: {data['siren']}, Omzet: {data['revenue']}"
        return f"Geen resultaten voor '{name}'"

@function_tool
async def verify_solvency(siren: str) -> str:
    """Verifieert de solvabiliteit van een bedrijf op basis van het SIREN-nummer."""
    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"Solvabiliteitsscore: {data['score']}/100, risico: {data['risk_level']}"

Wanneer de Runner een asynchrone tool uitvoert, blokkeert deze de event loop niet. In een FastAPI-server betekent dit dat andere verzoeken gewoon doorgaan met verwerken terwijl uw agent wacht op het antwoord van de Societe.com API.

Automatisch parallelisme

Twee onafhankelijke asynchrone tools kunnen gelijktijdig draaien. Het model beslist hierover, en uw instructies kunnen dit expliciet aanmoedigen.

from agents import Agent, Runner

agent = Agent(
    name="B2B Analist",
    instructions="""U analyseert bedrijven voor zakelijke beslissingen.
    Wanneer u wordt gevraagd een bedrijf te analyseren, haalt u de informatie op
    EN verifieert u tegelijkertijd de solvabiliteit.""",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
)

# Het model start beide tools parallel
result = await Runner.run(
    agent,
    "Analyseer het bedrijf Acme Corp (SIREN 123456789)"
)

Omdat het SIREN-nummer al in de query staat, hoeft de solvabiliteitscontrole niet te wachten op de zoekopdracht van het bedrijf: de SDK voert beide oproepen gelijktijdig uit. De totale tijd is gelijk aan de duur van de langzaamste tool, niet de som van beide.

Parallelisme sturen

Parallelisme is niet altijd wenselijk. Als uw tools naar dezelfde record schrijven of als de volgorde belangrijk is voor de data-integriteit, forceer dan sequentiële uitvoering.

from agents import Agent

agent = Agent(
    name="Voorzichtige Agent",
    instructions="Voer tools één voor één uit om data-integriteit te waarborgen.",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
    parallel_tool_calls=False,  # Forceert sequentiële uitvoering
)

De parameter parallel_tool_calls=False dwingt het model om slechts één tool per keer aan te roepen. U wisselt hierbij latentie in voor voorspelbaarheid.

Patroon: Parallelle resultaten aggregeren

De meest voorkomende praktische casus betreft het verzamelen van data uit meerdere bronnen voor dezelfde entiteit. Hier hebben het weer en het culturele aanbod van een stad niets met elkaar te maken, maar het antwoord vereist beide.

import json
from agents import Agent, Runner, function_tool

@function_tool
async def get_weather(city: str) -> str:
    """Haalt het huidige weer voor een stad op."""
    # Simulatie - in productie: weer-API-oproep
    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:
    """Haalt aankomende evenementen in een stad op."""
    events = {
        "Paris": ["Concert in Stade de France", "Tentoonstelling in het Louvre"],
        "Lyon": ["Lichtjesfestival", "Gastronomiebeurs"],
        "Marseille": ["Mediterrane Regatta"],
    }
    return json.dumps({
        "city": city,
        "events": events.get(city, [])
    }, ensure_ascii=False)

agent = Agent(
    name="Reisagent",
    instructions="""U bent een reisagent. Wanneer u wordt gevraagd
    om aanbevelingen voor een stad, haalt u het weer EN de evenementen
    gelijktijdig op om compleet advies te geven.""",
    tools=[get_weather, get_events],
    model="gpt-5.6-terra",
)

# Het model roept beide tools parallel aan voor elke stad
result = await Runner.run(
    agent,
    "Ik wil dit weekend naar Parijs. Wat raadt u aan?"
)
print(result.final_output)

Beide tools retourneren JSON, waardoor het voor het model makkelijker is om de data opnieuw te combineren. Let op de formulering van de instructie: de zin “EN … gelijktijdig” triggert de parallelle oproep in plaats van een luie keten.

Time-outs en veerkracht

Een API die nooit reageert, blokkeert uw agent net zo zeker als een synchrone tool. Voorzie elke trage oproep van een time-out en zet fouten om in begrijpelijke berichten.

import asyncio
from agents import function_tool

@function_tool
async def slow_api_call(query: str) -> str:
    """Roep een API aan die traag kan zijn."""
    try:
        async with asyncio.timeout(5):  # Time-out van 5 seconden
            # Uw API-oproep hier
            await asyncio.sleep(0.1)  # Simulatie
            return f"Resultaat voor '{query}'"
    except asyncio.TimeoutError:
        return "De API reageerde niet op tijd. Probeer het opnieuw."

Prestaties: Impact van parallelisme

Laten we de schaal in perspectief plaatsen. Drie tools van 500 ms die sequentieel worden uitgevoerd, kosten 1500 ms; dezelfde drie tools parallel kosten ongeveer 500 ms—de duur van de langzaamste. Voor een agent die veel tools gebruikt, is het verschil in de praktijk direct merkbaar.

Belangrijkste punten

  • Gebruik async voor tools die netwerk- of I/O-oproepen doen
  • De SDK voert onafhankelijke tools automatisch parallel uit
  • parallel_tool_calls=False forceert sequentiële uitvoering wanneer nodig
  • Voeg time-outs toe met asyncio.timeout() voor veerkracht
  • Parallelisme kan de latentie delen door het aantal tools