Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Asynkrone og parallelle værktøjer

Lektion 8 af 25 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Asynkrone og parallelle værktøjer
  2. Asynkrone værktøjer
  3. Automatisk parallelisme
  4. Styring af parallelisme
  5. Mønster: Samling af parallelle resultater
  6. Timeout og robusthed
  7. Ydeevne: Påvirkningen af parallelisme
  8. Vigtige pointer

Asynkrone og parallelle værktøjer

I produktion kalder dine værktøjer eksterne API’er, spørger databaser eller udfører I/O-operationer. Disse operationer tager tid, og tiden løber hurtigt sammen: En agent, der kæder fem kald på ét sekund sammen, bruger fem sekunder på at svare. Det, der adskiller en demo fra en brugbar tjeneste, er at gøre værktøjer asynkrone og udnytte SDK’ets indbyggede parallelisme.

Asynkrone værktøjer

Dekoratøren @function_tool understøtter nativt async-funktioner. Ingen konfiguration er nødvendig: Erklær async def, brug en asynkron HTTP-klient, så klarer SDK’et resten.

import httpx
from agents import function_tool

@function_tool
async def search_company(name: str) -> str:
    """Søger efter virksomhedsoplysninger via Societe.com API'et."""
    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"Virksomhed: {data['name']}, SIREN: {data['siren']}, Omsætning: {data['revenue']}"
        return f"Ingen resultater for '{name}'"

@function_tool
async def verify_solvency(siren: str) -> str:
    """Verificerer en virksomheds solvens ud fra dens 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"Solvensscore: {data['score']}/100, risiko: {data['risk_level']}"

Når Runneren eksekverer et asynkront værktøj, blokerer den ikke event loop’en. På en FastAPI-server betyder det, at andre forespørgsler fortsætter med at blive behandlet, mens din agent venter på svaret fra Societe.com API’et.

Automatisk parallelisme

To uafhængige asynkrone værktøjer kan køre samtidigt. Modellen træffer denne beslutning, og dine instrukser kan eksplicit opmuntre til det.

from agents import Agent, Runner

agent = Agent(
    name="B2B-analytiker",
    instructions="""Du analyserer virksomheder til brug for forretningsbeslutninger.
    Når du bliver bedt om at analysere en virksomhed, skal du hente dens oplysninger
    OG verificere dens solvens på samme tid.""",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
)

# Modellen vil lancere begge værktøjer parallelt
result = await Runner.run(
    agent,
    "Analyser virksomheden Acme Corp (SIREN 123456789)"
)

Da SIREN-nummeret er angivet i forespørgslen, behøver solvenskontrollen ikke vente på søgningen efter virksomheden: SDK’et udfører begge kald samtidigt. Den samlede tid svarer til varigheden af det langsomste værktøj, ikke summen af begge.

Styring af parallelisme

Parallelisme er ikke altid ønskværdig. Hvis dine værktøjer skriver til den samme post, eller hvis rækkefølgen er afgørende for datakonsistens, skal du gennemtvinge sekventiel eksekvering.

from agents import Agent

agent = Agent(
    name="Forsigtig agent",
    instructions="Eksekver værktøjer ét ad gangen for at sikre datakonsistens.",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
    parallel_tool_calls=False,  # Gennemtvinger sekventiel eksekvering
)

Parameteren parallel_tool_calls=False tvinger modellen til kun at kalde ét værktøj ad gangen. Du bytter latens ud for forudsigelighed.

Mønster: Samling af parallelle resultater

Det mest almindelige praktiske tilfælde indebærer indsamling af data fra flere kilder for den samme entitet. Her har en bys vejr og kulturelle begivenheder intet med hinanden at gøre, men svaret har brug for begge dele.

import json
from agents import Agent, Runner, function_tool

@function_tool
async def get_weather(city: str) -> str:
    """Henter aktuelt vejr for en by."""
    # Simulation - i produktion: kald til vejr-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:
    """Henter kommende begivenheder i en by."""
    events = {
        "Paris": ["Koncert på Stade de France", "Udstilling på Louvre"],
        "Lyon": ["Lysfestival", "Gastronomimessen"],
        "Marseille": ["Middelhavsregattaen"],
    }
    return json.dumps({
        "city": city,
        "events": events.get(city, [])
    }, ensure_ascii=False)

agent = Agent(
    name="Rejseagent",
    instructions="""Du er rejseagent. Når du bliver bedt om
    anbefalinger til en by, skal du hente vejr OG begivenheder
    samtidigt for at give fuldstændig rådgivning.""",
    tools=[get_weather, get_events],
    model="gpt-5.6-terra",
)

# Modellen vil kalde begge værktøjer parallelt for hver by
result = await Runner.run(
    agent,
    "Jeg vil besøge Paris i weekenden. Hvad anbefaler du?"
)
print(result.final_output)

Begge værktøjer returnerer JSON, hvilket gør det lettere for modellen at kombinere dataene igen. Bemærk formuleringen i instrukserne: „OG … samtidigt” udløser det parallelle kald i stedet for en doven kæde.

Timeout og robusthed

Et API, der aldrig svarer, blokerer din agent lige så sikkert som et synkront værktøj. Sæt en timeout på ethvert langsomt kald, og omdan fejl til forståelige beskeder.

import asyncio
from agents import function_tool

@function_tool
async def slow_api_call(query: str) -> str:
    """Kalder et API, der kan være langsomt."""
    try:
        async with asyncio.timeout(5):  # 5 sekunders timeout
            # Dit API-kald her
            await asyncio.sleep(0.1)  # Simulation
            return f"Resultat for '{query}'"
    except asyncio.TimeoutError:
        return "API'et svarede ikke inden for tiden. Prøv igen."

Ydeevne: Påvirkningen af parallelisme

Lad os sætte skalaen i perspektiv. Tre værktøjer på 500 ms, der eksekveres sekventielt, koster 1500 ms; de samme tre værktøjer parallelt koster ca. 500 ms – varigheden af det langsomste. For en agent, der bruger mange værktøjer, er forskellen straks mærkbar i praksis.

Vigtige pointer

  • Brug async til værktøjer, der foretager netværks- eller I/O-kald
  • SDK’et eksekverer automatisk uafhængige værktøjer parallelt
  • parallel_tool_calls=False gennemtvinger sekventiel eksekvering, når det er nødvendigt
  • Tilføj timeouts med asyncio.timeout() for at opnå robusthed
  • Parallelisme kan reducere latensen med antallet af værktøjer