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

Appels parallèles et séquentiels

3. lecke 20 közül Fejlesztő
Ezen az oldalon
  1. Appels parallèles et séquentiels
  2. Appels parallèles
  3. Désactiver les appels parallèles
  4. Appels séquentiels avec une boucle
  5. Exemple concret : Pipeline de traitement
  6. Modèle hybride : Parallèle puis séquentiel
  7. Főbb megállapítások

Appels parallèles et séquentiels

Le modèle peut émettre plusieurs appels de fonctions dans une seule réponse, le faisant automatiquement dès qu’il identifie des besoins indépendants. Ce n’est pas qu’une optimisation cosmétique : trois appels de deux secondes exécutés ensemble prennent deux secondes au total, mais chaînés séquentiellement, ils en prennent six.

Le vrai sujet de cette leçon n’est pas de savoir comment paralléliser — le modèle s’en charge — mais comment reconnaître les cas où il ne faut pas le faire. Deux appels sont indépendants lorsque l’ordre d’exécution n’affecte pas le résultat. Dès qu’une opération lit ce qu’une autre écrit, ou qu’un paramètre doit provenir d’un appel précédent, le parallélisme devient un bug difficile à reproduire.

Appels parallèles

Rien n’a besoin d’être activé : c’est le comportement par défaut. Une requête concernant trois villes produit trois éléments function_call dans la même réponse ; tu les exécutes. Note que le modèle raisonne sur le sens des fonctions basé sur tes descriptions — les descriptions pilotent la décision, comme pour presque tout dans ce cours.

from openai import OpenAI
import json
import asyncio

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "get_meteo",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "get_taux_change",
        "description": "Get exchange rate between two currencies",
        "parameters": {
            "type": "object",
            "properties": {
                "source": {"type": "string"},
                "cible": {"type": "string"}
            },
            "required": ["source", "cible"],
            "additionalProperties": False
        },
        "strict": True
    }
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather in Paris and Berlin, "
          "and what is the EUR/USD exchange rate?",
    tools=tools
)

# Le modèle émet 3 appels en parallèle
appels = [item for item in response.output if item.type == "function_call"]
print(f"Nombre d'appels : {len(appels)}")
# => Nombre d'appels : 3

Exécuter les appels parallèles côté client

Recevoir trois appels d’un coup est inutile si ton code les exécute l’un après l’autre : tu perds tout le gain côté client. asyncio.gather est le minimum ; ajoute deux précautions pour la production — une limite de concurrence, pour ne pas ouvrir cinquante connexions simultanées vers un service qui n’en supporte que dix, et une gestion d’erreur par appel, pour qu’une défaillance isolée n’emporte pas les autres résultats.

async def executer_fonction(name: str, arguments: str) -> dict:
    args = json.loads(arguments)
    if name == "get_meteo":
        return await api_meteo(args["ville"])
    elif name == "get_taux_change":
        return await api_change(args["source"], args["cible"])

async def traiter_appels_paralleles(appels):
    taches = [
        executer_fonction(appel.name, appel.arguments)
        for appel in appels
    ]
    resultats = await asyncio.gather(*taches)

    return [
        {
            "type": "function_call_output",
            "call_id": appel.call_id,
            "output": json.dumps(resultat)
        }
        for appel, resultat in zip(appels, resultats)
    ]

# Exécution
resultats = asyncio.run(traiter_appels_paralleles(appels))

# Renvoi au modèle
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)
print(response_finale.output_text)

Désactiver les appels parallèles

parallel_tool_calls=False force le modèle à n’émettre qu’un seul appel par réponse. Utilise ce paramètre délibérément : il échange la latence contre la sécurité. Réserve-le aux fonctions qui écrivent, modifient ou déclenchent quelque chose d’externe.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Process these three orders",
    tools=tools,
    parallel_tool_calls=False  # Un appel par réponse
)

Cas d’usage pour désactiver le parallélisme :

  • Opérations devant s’exécuter dans un ordre spécifique
  • Fonctions avec effets de bord qui interfèrent entre elles
  • Quand le résultat d’un appel conditionne le suivant

Appels séquentiels avec une boucle

L’exécution séquentielle n’est pas contrôlée par un paramètre : elle émerge de la boucle. Tu exécutes l’appel, renvoies le résultat, et le modèle décide de l’étape suivante en fonction de ce qu’il vient d’apprendre. C’est précisément ce qui distingue une chaîne dynamique d’un plan rigide : si l’étape 2 révèle que l’étape 3 est inutile, le modèle ne l’appellera pas.

def boucle_function_calling(prompt: str, tools: list, max_tours: int = 10):
    """Boucle complète pour l'appel de fonctions séquentiel."""
    messages_input = prompt
    tour = 0

    while tour < max_tours:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages_input,
            tools=tools,
            parallel_tool_calls=False
        )

        # Vérification des appels de fonctions
        appels = [i for i in response.output if i.type == "function_call"]

        if not appels:
            # Le modèle a terminé, répond avec du texte
            return response.output_text

        # Exécution de chaque appel
        resultats = []
        for appel in appels:
            resultat = executer_fonction_sync(appel.name, appel.arguments)
            resultats.append({
                "type": "function_call_output",
                "call_id": appel.call_id,
                "output": json.dumps(resultat)
            })

        # Préparation du tour suivant
        messages_input = response.output + resultats
        tour += 1

    return "Limite de tours atteinte"

Exemple concret : Pipeline de traitement

Un cas typique où l’exécution séquentielle est obligatoire, car chaque étape consomme ce que la précédente a produit :

tools_pipeline = [
    {
        "type": "function",
        "name": "valider_commande",
        "description": "Verify order validity (stock, price, customer)",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"}
            },
            "required": ["commande_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "calculer_livraison",
        "description": "Calculate shipping fees and delays. "
                       "Requires a validated order.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "mode": {"type": "string", "enum": ["standard", "express"]}
            },
            "required": ["commande_id", "mode"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "confirmer_commande",
        "description": "Confirm the order and trigger payment. "
                       "Requires prior validation and shipping calculation.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "livraison_id": {"type": "string"}
            },
            "required": ["commande_id", "livraison_id"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# Le modèle appellera naturellement dans cet ordre :
# 1. valider_commande
# 2. calculer_livraison (en utilisant le résultat de l'étape 1)
# 3. confirmer_commande (en utilisant les résultats des étapes 1 et 2)
resultat = boucle_function_calling(
    "Process order CMD-42567 with express shipping",
    tools_pipeline
)

Modèle hybride : Parallèle puis séquentiel

En pratique, la plupart des flux de travail réels suivent ce modèle mixte : une phase de collecte où tout peut s’exécuter simultanément, suivie d’une phase de traitement qui respecte les dépendances. Tu n’as besoin de coder rien de spécial pour cela — c’est la conséquence naturelle de la boucle, à condition que tes descriptions rendent les dépendances claires.

# Tour 1 : Collecte de données parallèle
# Le modèle appelle get_client ET get_stock en parallèle

# Tour 2 : Décision séquentielle basée sur les résultats
# Le modèle appelle valider_commande avec les informations collectées

# Tour 3 : Action finale
# Le modèle appelle confirmer_commande

Ce modèle semble naturel : le modèle parallélise automatiquement quand les appels sont indépendants, puis enchaîne séquentiellement lorsqu’une dépendance apparaît.

Főbb megállapítások

  • Le modèle parallélise automatiquement les appels indépendants
  • Utilise asyncio.gather pour exécuter les appels parallèles côté client
  • Désactive avec parallel_tool_calls=False quand l’ordre compte
  • Implémente une boucle pour les workflows en plusieurs étapes
  • Les descriptions de fonctions guident le modèle sur les dépendances entre les étapes