Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Outils asynchrones et parallèles

8. lecke 25 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Outils asynchrones et parallèles
  2. Outils asynchrones
  3. Parallélisme automatique
  4. Contrôle du parallélisme
  5. Modèle : Agrégation de résultats parallèles
  6. Délais d’attente et résilience
  7. Performance : Impact du parallélisme
  8. Főbb megállapítások

Outils asynchrones et parallèles

En production, tes outils appellent des API externes, interrogent des bases de données ou effectuent des opérations d’E/S. Ces opérations prennent du temps, et ce temps s’accumule : un agent qui enchaîne cinq appels d’une seconde met cinq secondes à répondre. Rendre les outils asynchrones et exploiter le parallélisme natif du SDK est ce qui sépare une démo d’un service utilisable.

Outils asynchrones

Le décorateur @function_tool prend nativement en charge les fonctions async. Aucune configuration n’est requise : déclare async def, utilise un client HTTP asynchrone, et le SDK gère le reste.

import httpx
from agents import function_tool

@function_tool
async def search_company(name: str) -> str:
    """Recherche des informations sur une entreprise via l'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"Entreprise : {data['name']}, SIREN : {data['siren']}, Chiffre d'affaires : {data['revenue']}"
        return f"Aucun résultat pour '{name}'"

@function_tool
async def verify_solvency(siren: str) -> str:
    """Vérifie la solvabilité d'une entreprise par son numéro 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"Score de solvabilité : {data['score']}/100, risque : {data['risk_level']}"

Lorsque le Runner exécute un outil asynchrone, il ne bloque pas la boucle d’événements. Dans un serveur FastAPI, cela signifie que les autres requêtes continuent d’être traitées pendant que ton agent attend la réponse de l’API Societe.com.

Parallélisme automatique

Deux outils asynchrones indépendants peuvent s’exécuter simultanément. Le modèle décide de cela, et tes instructions peuvent explicitement l’encourager.

from agents import Agent, Runner

agent = Agent(
    name="Analyste B2B",
    instructions="""Tu analyses les entreprises pour des décisions commerciales.
    Lorsqu'on te demande d'analyser une entreprise, récupère ses informations
    ET vérifie sa solvabilité en même temps.""",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
)

# Le modèle lancera les deux outils en parallèle
result = await Runner.run(
    agent,
    "Analyse l'entreprise Acme Corp (SIREN 123456789)"
)

Puisque le SIREN est fourni dans la requête, la vérification de solvabilité n’attend pas la recherche de l’entreprise : le SDK exécute les deux appels simultanément. Le temps total équivaut à la durée de l’outil le plus lent, et non à la somme des deux.

Contrôle du parallélisme

Le parallélisme n’est pas toujours souhaitable. Si tes outils écrivent dans le même enregistrement ou si l’ordre est crucial pour la cohérence des données, force l’exécution séquentielle.

from agents import Agent

agent = Agent(
    name="Agent prudent",
    instructions="Exécute les outils un par un pour assurer la cohérence des données.",
    tools=[search_company, verify_solvency],
    model="gpt-5.6-terra",
    parallel_tool_calls=False,  # Force l'exécution séquentielle
)

Le paramètre parallel_tool_calls=False force le modèle à n’appeler qu’un seul outil à la fois. Tu échanges la latence contre la prévisibilité.

Modèle : Agrégation de résultats parallèles

Le cas pratique le plus courant consiste à rassembler des données provenant de plusieurs sources pour une même entité. Ici, la météo d’une ville et son agenda culturel n’ont rien à voir l’un avec l’autre, mais la réponse a besoin des deux.

import json
from agents import Agent, Runner, function_tool

@function_tool
async def get_weather(city: str) -> str:
    """Obtient la météo actuelle d'une ville."""
    # Simulation - en production : appel API météo
    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:
    """Obtient les événements à venir dans une ville."""
    events = {
        "Paris": ["Concert au Stade de France", "Exposition au Louvre"],
        "Lyon": ["Fête des Lumières", "Foire de la Gastronomie"],
        "Marseille": ["Régate méditerranéenne"],
    }
    return json.dumps({
        "city": city,
        "events": events.get(city, [])
    }, ensure_ascii=False)

agent = Agent(
    name="Agent de voyage",
    instructions="""Tu es un agent de voyage. Lorsqu'on te demande
    des recommandations pour une ville, récupère la météo ET les événements
    simultanément pour fournir un conseil complet.""",
    tools=[get_weather, get_events],
    model="gpt-5.6-terra",
)

# Le modèle appellera les deux outils en parallèle pour chaque ville
result = await Runner.run(
    agent,
    "Je veux visiter Paris ce week-end. Que me recommandes-tu ?"
)
print(result.final_output)

Les deux outils renvoient du JSON, ce qui facilite la recombinaison des données par le modèle. Note la formulation de l’instruction : le « ET … simultanément » déclenche l’appel parallèle plutôt qu’une chaîne paresseuse.

Délais d’attente et résilience

Une API qui ne répond jamais bloque ton agent tout aussi sûrement qu’un outil synchrone. Encadre chaque appel lent par un délai d’attente et transforme les échecs en messages intelligibles.

import asyncio
from agents import function_tool

@function_tool
async def slow_api_call(query: str) -> str:
    """Appelle une API qui peut être lente."""
    try:
        async with asyncio.timeout(5):  # Délai d'attente de 5 secondes
            # Ton appel API ici
            await asyncio.sleep(0.1)  # Simulation
            return f"Résultat pour '{query}'"
    except asyncio.TimeoutError:
        return "L'API n'a pas répondu à temps. Veuillez réessayer."

Performance : Impact du parallélisme

Mettons les choses en perspective. Trois outils de 500 ms exécutés séquentiellement coûtent 1500 ms ; ces mêmes trois outils en parallèle coûtent environ 500 ms — la durée du plus lent. Pour un agent utilisant de nombreux outils, la différence est immédiatement perceptible en pratique.

Főbb megállapítások

  • Utilise async pour les outils qui effectuent des appels réseau ou des E/S
  • Le SDK exécute automatiquement les outils indépendants en parallèle
  • parallel_tool_calls=False force l’exécution séquentielle lorsque nécessaire
  • Ajoute des délais d’attente avec asyncio.timeout() pour la résilience
  • Le parallélisme peut diviser la latence par le nombre d’outils