Combiner plusieurs outils dans un seul appel
Pe această pagină
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 typeinput_text, et la recherche web utilise l’outilweb_search(web_search_previewest désormais un outil obsolète sans filtres de domaine). Les fichiers générés sont récupérés via les fonctionsfichiers_generesettelechargerde la leçon 10. Les fichiers joints à un message sont téléchargés avec l’objectifuser_data, ce qu’OpenAI recommande pour les entrées du modèle (File inputs). Sources : Code Interpreter · Recherche web.
Combiner plusieurs outils dans un seul appel
Jusqu’à présent, nous avons examiné chaque outil de manière isolée. 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. Vous ne programmez pas la séquence : vous déclarez les outils disponibles et décrivez 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 vous ne pouvez pas examiner. 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 votre 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="Comparez nos prévisions de ventes avec les tendances du marché, "
"puis créez un graphique de comparaison.",
tools=[
{"type": "file_search", "vector_store_ids": ["vs_previsions"]},
{"type": "web_search"},
{"type": "code_interpreter", "container": {"type": "auto"}}
]
)
Le modèle va :
- Récupérer les prévisions internes via File Search
- Récupérer les tendances du marché via Web Search
- 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 du 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": "Enregistrer un rapport d'analyse dans le système de documents",
"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": (
"Sur la base de ce fichier de ventes : "
"1. Analysez les tendances des 12 derniers mois "
"2. Comparez avec nos objectifs annuels (recherchez dans les docs) "
"3. Recherchez sur le web les tendances du marché "
"4. Générez un graphique de comparaison "
"5. Rédigez un rapport de synthèse "
"6. Enregistrez le rapport"
)},
{"type": "input_file", "file_id": fichier.id}
]
}],
tools=tools,
instructions=(
"Vous êtes un analyste d'affaires senior. "
"Utilisez tous les outils à votre disposition pour produire "
"une analyse complète et sourcée."
)
)
Gérer la boucle multi-outils
Il existe ici une asymétrie dont vous devez tenir compte, car elle détermine la structure de votre 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. Vos fonctions personnalisées, en revanche, s’exécutent de votre 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, vous les exécutez, renvoyez les résultats et recommencez. Fixez 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 consommera votre budget jusqu’à épuisement.
import json
def boucle_multi_outils(prompt, tools, fichiers=None, max_tours=15):
"""Boucle d'appel de fonctions avec support multi-outils."""
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="Utilisez les outils nécessaires pour répondre complètement."
)
# Les outils intégrés (web_search, file_search, code_interpreter)
# sont exécutés automatiquement côté serveur.
# Nous ne gérons que les éléments function_call personnalisés.
appels_custom = [
item for item in response.output
if item.type == "function_call"
]
if not appels_custom:
# Pas d'appel personnalisé : le modèle a terminé
return {
"reponse": response.output_text,
"tours": tour + 1,
"tokens": response.usage.total_tokens
}
# Exécuter les fonctions personnalisées
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)
})
# Préparer le tour suivant
messages = response.output + resultats
return {"reponse": "Limite de tours atteinte", "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 vos documents avant le web, par exemple, car le vocabulaire interne conditionne la pertinence de la requête externe. L’instruction 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 = (
"Avant toute action, recherchez d'abord les informations nécessaires "
"dans les documents internes et sur le web. "
"Ne proposez aucune action tant que vous n'avez pas rassemblé toutes les données."
)
# Stratégie 2 : analyse des données puis enrichissement
instructions_analyse_dabord = (
"Commencez par analyser les données avec Code Interpreter. "
"Enrichissez ensuite vos conclusions avec des recherches web. "
"Enfin, comparez avec les documents internes."
)
# Stratégie 3 : vérification croisée
instructions_verification = (
"Pour chaque information importante, vérifiez-la dans au moins deux sources : "
"documents internes ET recherche web. Signalez toute contradiction."
)
Limiter les outils par étape
L’approche opposée consiste à retirer le choix. Plutôt qu’un seul appel avec la boîte à outils complète, vous divisez le flux de travail en plusieurs appels, chacun ne déclarant que l’outil pour son étape spécifique. Vous perdez l’orchestration automatique mais gagnez trois choses importantes 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="Rassemblez des informations sur le Projet 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"Analysez ces informations et générez des graphiques :\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": "Envoyer un e-mail de notification",
"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": "Créer une tâche dans le gestionnaire de projet",
"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
# - Rechercher sur le web
# - Analyser des données
# - Envoyer des e-mails
# - Créer des tâches
resultat = agent.traiter(
"Analysez les ventes du T1, comparez-les aux objectifs, "
"et créez une tâche pour le directeur commercial si nous sommes en retard."
)
Puncte cheie
- 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
- Guidez la stratégie d’orchestration via l’instruction système
- Implémentez une boucle pour gérer les appels de fonctions personnalisées