Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Combiner plusieurs outils en un seul appel

Lezione 19 di 20 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Combiner plusieurs outils en un seul appel
  2. Principe de combinaison
  3. Exemple complet : assistant analytique
  4. Gérer la boucle multi-outils
  5. Stratégies d’orchestration
  6. Modèle : agent multi-compétences
  7. Punti chiave

Mis à jour le 2 novembre 2026 selon la documentation OpenAI : l’outil Code Interpreter nécessite désormais un paramètre container (ajouté à tous les exemples), les parties de saisie texte utilisent le type input_text, et la recherche web utilise l’outil web_search (web_search_preview est désormais un outil obsolète sans filtres de domaine). Les fichiers générés sont récupérés via les fonctions fichiers_generes et telecharger de la leçon 10. Les fichiers joints à un message sont téléchargés avec l’objectif user_data, ce qu’OpenAI recommande pour les entrées du modèle (File inputs). Sources : Code Interpreter · Recherche web.

Combiner plusieurs outils en un seul appel

Jusqu’à présent, nous avons examiné chaque outil isolément. En production, les questions intéressantes prennent rarement cette forme. Demander « comment nos ventes se comparent-elles au marché ? » implique de récupérer une donnée interne, une donnée externe, puis de les comparer. Trois outils, trois sources, un seul appel.

Ce qui change, c’est qui décide de l’ordre. Tu ne programmes pas la séquence : tu déclares les outils disponibles et décris le résultat attendu, et le modèle établit son propre plan. C’est pratique, mais c’est aussi le point de vigilance : un plan implicite est un plan que tu ne peux pas revoir. La dernière partie de cette leçon montre comment reprendre le contrôle lorsque l’ordre compte vraiment.

Principe de combinaison

Tous les outils sont déclarés dans le même tableau tools, et c’est là tout le mécanisme : il n’existe pas d’API de composition, seulement une liste de capacités disponibles. Le modèle lit ta demande, déduit les étapes nécessaires et appelle ce dont il a besoin, dans l’ordre qu’il juge utile. Un outil déclaré mais inutile pour la tâche ne sera tout simplement pas appelé : cela ne coûte rien au-delà des quelques tokens de sa description.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare our sales forecasts with market trends, "
          "then create a comparison chart.",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_previsions"]},
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Le modèle va :

  1. Récupérer les prévisions internes via File Search
  2. Récupérer les tendances du marché via Web Search
  3. Générer un graphique de comparaison via Code Interpreter

Exemple complet : assistant analytique

with open("donnees_ventes.csv", "rb") as f:
    fichier = client.files.create(file=f, purpose="user_data")

tools = [
    # Recherche dans les documents internes
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Recherche web pour le contexte marché
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Exécution de code pour l'analyse
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Fonction pour sauvegarder le rapport
    {
        "type": "function",
        "name": "sauvegarder_rapport",
        "description": "Save an analysis report to the document system",
        "parameters": {
            "type": "object",
            "properties": {
                "titre": {"type": "string"},
                "contenu": {"type": "string"},
                "categorie": {
                    "type": "string",
                    "enum": ["analyse", "prevision", "audit", "comparaison"]
                },
                "tags": {
                    "type": "array",
                    "items": {"type": "string"}
                }
            },
            "required": ["titre", "contenu", "categorie", "tags"],
            "additionalProperties": False
        },
        "strict": True
    }
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Based on this sales file: "
                "1. Analyze trends over the last 12 months "
                "2. Compare with our annual goals (search the docs) "
                "3. Search the web for market trends "
                "4. Generate a comparison chart "
                "5. Write a summary report "
                "6. Save the report"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=tools,
    instructions=(
        "You are a senior business analyst. "
        "Use all tools at your disposal to produce "
        "a complete, sourced analysis."
    )
)

Gérer la boucle multi-outils

Il existe ici une asymétrie dont tu dois tenir compte, car elle détermine la structure de ton code. Les outils intégrés — Web Search, File Search, Code Interpreter — s’exécutent chez OpenAI : le modèle les appelle, obtient le résultat et continue, le tout en un seul aller-retour. Tes fonctions personnalisées, en revanche, s’exécutent de ton côté : le modèle ne peut que demander leur exécution, puis il cède la main et attend.

D’où la boucle ci-dessous. Tant que la réponse contient des appels de fonction, tu les exécutes, retournes les résultats et redémarres. Fixe un nombre maximal d’itérations : un modèle qui rappellerait indéfiniment le même outil parce que le résultat ne le satisfait pas est un cas rare mais réel, et sans garde-fou, il consumera ton budget jusqu’à épuisement.

import json

def boucle_multi_outils(prompt, tools, fichiers=None, max_tours=15):
    """Function calling loop with multi-tool support."""
    content = [{"type": "input_text", "text": prompt}]
    if fichiers:
        for fid in fichiers:
            content.append({"type": "input_file", "file_id": fid})

    messages = [{"role": "user", "content": content}]

    for tour in range(max_tours):
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages,
            tools=tools,
            instructions="Use the necessary tools to answer completely."
        )

        # Built-in tools (web_search, file_search, code_interpreter)
        # are executed automatically on the server side.
        # We only handle custom function_call items.
        appels_custom = [
            item for item in response.output
            if item.type == "function_call"
        ]

        if not appels_custom:
            # No custom call: the model is finished
            return {
                "reponse": response.output_text,
                "tours": tour + 1,
                "tokens": response.usage.total_tokens
            }

        # Execute custom functions
        resultats = []
        for appel in appels_custom:
            resultat = dispatcher_fonctions(appel.name, appel.arguments)
            resultats.append({
                "type": "function_call_output",
                "call_id": appel.call_id,
                "output": json.dumps(resultat)
            })

        # Prepare the next turn
        messages = response.output + resultats

    return {"reponse": "Turn limit reached", "tours": max_tours}

Stratégies d’orchestration

Guider l’ordre des outils

L’orchestration automatique fonctionne bien tant que l’ordre n’a pas d’importance. Elle cesse de fonctionner lorsqu’une étape doit informer la suivante : rechercher dans tes documents avant le web, par exemple, car le vocabulaire interne conditionne la pertinence de la requête externe. Le prompt système est le levier : non pas comme une contrainte technique, mais comme une instruction méthodologique que le modèle suit d’autant mieux qu’elle est justifiée.

# Stratégie 1 : chercher d'abord, agir ensuite
instructions_recherche_dabord = (
    "Before any action, first search for the necessary information "
    "in internal documents and on the web. "
    "Do not propose actions until you have gathered all data."
)

# Stratégie 2 : analyse des données puis enrichissement
instructions_analyse_dabord = (
    "Start by analyzing the data with Code Interpreter. "
    "Then enrich your conclusions with web searches. "
    "Finally, compare with internal documents."
)

# Stratégie 3 : vérification croisée
instructions_verification = (
    "For each important piece of information, verify it in at least two sources: "
    "internal documents AND web search. Report any contradictions."
)

Limiter les outils par étape

L’approche opposée consiste à supprimer le choix. Plutôt qu’un seul appel avec la boîte à outils complète, tu découpes le flux de travail en plusieurs appels, chacun ne déclarant que l’outil de son étape spécifique. Tu perds l’orchestration automatique mais tu gagnes trois choses essentielles en production : un ordre garanti, un coût prévisible et des erreurs isolables. Pour un flux critique, c’est presque toujours le bon compromis.

# Étape 1 : collecte de données (pas de code)
response_collecte = client.responses.create(
    model="gpt-5.6-terra",
    input="Gather information on Project Alpha",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_projets"]},
        {"type": "web_search"}
    ]
)

# Étape 2 : analyse avec les données collectées
response_analyse = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Analyze this information and generate charts:\n"
          f"{response_collecte.output_text}",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Modèle : agent multi-compétences

Ce dernier exemple combine les deux approches : un routeur sélectionne la configuration des outils selon la nature de la demande, puis laisse le modèle orchestrer au sein de ce périmètre restreint. C’est le compromis qui tient la route en usage : assez de liberté pour absorber la variété des demandes, assez de structure pour garder les coûts et le comportement prévisibles.

class AgentMultiCompetences:
    def __init__(self, vector_stores: list[str], fonctions: list[dict]):
        self.client = OpenAI()
        self.tools = [
            {"type": "file_search", "vector_store_ids": vector_stores},
            {"type": "web_search", "search_context_size": "medium"},
            {"type": "code_interpreter", "container": {"type": "auto"}},
        ] + fonctions

    def traiter(self, requete: str, fichiers: list[str] = None) -> dict:
        return boucle_multi_outils(requete, self.tools, fichiers)

# Instancier l'agent
agent = AgentMultiCompetences(
    vector_stores=["vs_docs", "vs_contrats"],
    fonctions=[
        {
            "type": "function",
            "name": "envoyer_email",
            "description": "Send a notification email",
            "parameters": {
                "type": "object",
                "properties": {
                    "destinataire": {"type": "string"},
                    "sujet": {"type": "string"},
                    "corps": {"type": "string"}
                },
                "required": ["destinataire", "sujet", "corps"],
                "additionalProperties": False
            },
            "strict": True
        },
        {
            "type": "function",
            "name": "creer_tache",
            "description": "Create a task in the project manager",
            "parameters": {
                "type": "object",
                "properties": {
                    "titre": {"type": "string"},
                    "assignee": {"type": "string"},
                    "priorite": {"type": "string", "enum": ["basse", "moyenne", "haute"]},
                    "echeance": {"type": "string"}
                },
                "required": ["titre", "assignee", "priorite"],
                "additionalProperties": False
            },
            "strict": True
        }
    ]
)

# L'agent peut désormais :
# - Rechercher des documents
# - Chercher sur le web
# - Analyser des données
# - Envoyer des e-mails
# - Créer des tâches
resultat = agent.traiter(
    "Analyze Q1 sales, compare with goals, "
    "and create a task for the sales director if we are behind."
)

Punti chiave

  • Tous les outils coexistent dans le même tableau tools
  • Les outils intégrés s’exécutent côté serveur, les fonctions personnalisées côté client
  • Le modèle orchestre automatiquement l’ordre des appels
  • Guide la stratégie d’orchestration via le prompt système
  • Implémente une boucle pour gérer les appels de fonctions personnalisées