Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Appels parallèles

Lektion 6 av 14 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Plusieurs outils dans une seule réponse
  2. Le paramètre parallel_tool_calls
  3. Gestion des appels parallèles
  4. Véritable exécution parallèle côté client
  5. Désactivation des appels parallèles
  6. Appels parallèles avec différents outils
  7. Gestion des erreurs en parallèle
  8. Viktiga punkter

Plusieurs outils dans une seule réponse

L’une des fonctionnalités les plus puissantes de l’appel de fonctions Grok est sa capacité à renvoyer plusieurs appels d’outils dans une seule réponse. Au lieu d’effectuer un aller-retour pour chaque fonction, le modèle identifie toutes les informations dont il a besoin et génère chaque appel en parallèle.

Le paramètre parallel_tool_calls

Les appels parallèles sont activés par défaut. Le paramètre parallel_tool_calls contrôle ce comportement :

# Activé par défaut (pas besoin de le spécifier)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # C'est la valeur par défaut
)

Lorsqu’un utilisateur demande : « Quelle est la météo à Paris et à Lyon ? », le modèle renvoie deux tool_calls dans la même réponse :

{
  "tool_calls": [
    {
      "id": "call_001",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Paris\"}"
      }
    },
    {
      "id": "call_002",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Lyon\"}"
      }
    }
  ]
}

Gestion des appels parallèles

Ton code doit gérer un tableau de tool_calls, et non pas un seul :

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Exécuter toutes les fonctions
    tool_results = []
    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)
        result = execute_function(tool_call.function.name, args)
        tool_results.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result)
        })

    # Renvoyer TOUS les résultats au modèle
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Tous les résultats
    ]

    final = client.chat.completions.create(
        model="grok-4.5",
        messages=messages,
        tools=tools
    )

Point critique : tu dois renvoyer tous les résultats des outils, pas seulement le premier. Chaque résultat est lié à son tool_call_id correspondant.

Véritable exécution parallèle côté client

Le modèle renvoie les appels en parallèle, mais ton code doit les exécuter en parallèle. En Python, utilise asyncio ou concurrent.futures :

import concurrent.futures

def execute_parallel(tool_calls):
    results = []
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = {}
        for tc in tool_calls:
            args = json.loads(tc.function.arguments)
            future = executor.submit(execute_function, tc.function.name, args)
            futures[future] = tc.id

        for future in concurrent.futures.as_completed(futures):
            call_id = futures[future]
            result = future.result()
            results.append({
                "role": "tool",
                "tool_call_id": call_id,
                "content": json.dumps(result)
            })
    return results

L’exécution parallèle réduit considérablement la latence totale. Si chaque appel API prend 200 ms, deux appels séquentiels prennent 400 ms, tandis que deux appels parallèles prennent environ 200 ms.

Désactivation des appels parallèles

Dans certains cas, tu souhaiteras des appels séquentiels :

response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False
)

Désactive le parallélisme chaque fois que l’indépendance des appels n’est pas garantie. Le cas le plus évident est la dépendance aux données : si le résultat d’un outil alimente les arguments du suivant — par exemple, rechercher un ID client avant de récupérer ses commandes —, leur exécution en parallèle provoquera au mieux une erreur, et au pire un résultat incorrect silencieux. La logique métier impose la même contrainte : créer un utilisateur avant de lui attribuer un rôle est non négociable, et seul le mode séquentiel le garantit. Deux autres raisons pratiques complètent le tableau : une API externe soumise à des limites de requêtes simultanées gérera mal une rafale d’appels parallèles, et pendant le développement, le mode séquentiel rend le suivi des appels infiniment plus lisible — un appel, un résultat, un journal, dans l’ordre.

Appels parallèles avec différents outils

Le modèle peut également appeler différents outils en parallèle :

# Demande : "Réserve une table et donne-moi la météo pour ce soir"
# Le modèle renvoie :
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Ceci est particulièrement utile pour les assistants polyvalents qui doivent collecter des informations provenant de sources différentes.

Gestion des erreurs en parallèle

Lorsqu’un appel échoue mais que d’autres réussissent, renvoie toujours tous les résultats. Le modèle gère les erreurs individuelles :

results = []
for tc in message.tool_calls:
    try:
        result = execute_function(tc.function.name, args)
        results.append({
            "role": "tool",
            "tool_call_id": tc.id,
            "content": json.dumps(result)
        })
    except Exception as e:
        results.append({
            "role": "tool",
            "tool_call_id": tc.id,
            "content": json.dumps({"error": str(e)})
        })

Viktiga punkter

  • Les appels parallèles sont activés par défaut (parallel_tool_calls: true)
  • Le modèle renvoie plusieurs tool_calls dans une seule réponse
  • Tu dois renvoyer tous les résultats, chacun lié à son tool_call_id
  • Implémente une exécution parallèle côté client pour réduire la latence
  • Désactive le parallélisme lorsqu’il existe des dépendances entre les appels
  • Gère les erreurs individuellement — ne bloque pas tout pour une seule défaillance