Tool Search : outils dynamiques
Op deze pagina
Leçon mise à jour le 2 novembre 2026 sur la base de la documentation OpenAI : l’outil Code Interpreter nécessite désormais un paramètre
container(ajouté à tous les exemples), les parties de texte en entrée sont typées commeinput_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. Sources : Code Interpreter · Recherche web.
Tool Search : outils dynamiques
Lorsque vous disposez de dizaines, voire de centaines de fonctions, les déclarer toutes à chaque appel devient contre-productif : le modèle perd en précision et les coûts explosent. Tool Search résout ce problème en permettant au modèle de rechercher l’outil approprié dans un catalogue indexé.
Le problème des grands catalogues d’outils
Le coût d’un vaste catalogue d’outils est invisible de deux manières. Premièrement, financièrement : chaque définition de fonction est envoyée avec chaque requête, y compris les quatre-vingt-dix-huit qui ne seront pas utilisées. À grande échelle, cela finit par dépasser le coût des réponses elles-mêmes. Deuxièmement, et plus gravement, qualitativement : au-delà de quelques dizaines d’outils aux périmètres qui se chevauchent, le modèle fait de moins bons choix. Trop d’options dégradent la prise de décision, ici comme ailleurs.
# 5 fonctions = ~500 jetons de contexte
# 50 fonctions = ~5000 jetons de contexte
# 200 fonctions = impossible à gérer efficacement
# Le modèle perd en précision lorsqu'il y a trop de fonctions
# Il sélectionne parfois la mauvaise fonction ou hallucine des paramètres
Activer Tool Search
Tool Search inverse la logique : au lieu de tout présenter au modèle, vous indexez le catalogue et ne lui montrez que ce qui correspond à la requête actuelle. Le mécanisme repose sur une recherche sémantique sur les descriptions, c’est pourquoi la section suivante n’est pas un simple conseil de style ; c’est une exigence pour que le système fonctionne.
from openai import OpenAI
client = OpenAI()
# Déclarer un grand nombre de fonctions
all_functions = [
{
"type": "function",
"name": "create_invoice",
"description": "Create a new invoice for a customer",
"parameters": {"type": "object", "properties": {"client_id": {"type": "string"}}, "required": ["client_id"]}
},
{
"type": "function",
"name": "cancel_invoice",
"description": "Cancel an existing invoice",
"parameters": {"type": "object", "properties": {"invoice_id": {"type": "string"}}, "required": ["invoice_id"]}
},
# ... des dizaines d'autres fonctions
]
# Utiliser Tool Search pour laisser le modèle trouver la bonne fonction
response = client.responses.create(
model="gpt-5.6-terra",
input="Cancel invoice FAC-2026-0042",
tools=[{
"type": "tool_search",
"tool_search": {
"tools": all_functions
}
}]
)
Le modèle ne reçoit dans son contexte que les fonctions pertinentes pour la requête, et non l’intégralité du catalogue.
Organiser le catalogue de fonctions
Deux principes suffisent à structurer un catalogue qui reste navigable. Préfixez les noms par domaine (crm_, billing_, inventory_) : la lecture des traces d’exécution devient immédiate et les collisions de noms disparaissent. Donnez ensuite à chaque fonction un périmètre clair : deux fonctions dont les descriptions se chevauchent produiront des choix instables, qu’un humain ou un moteur vectoriel effectue l’appel.
crm_catalog = [
{
"type": "function",
"name": "crm_search_customer",
"description": "Search for a customer in the CRM by name, email, or ID. "
"Use to find information about an existing customer.",
"parameters": {
"type": "object",
"properties": {
"term": {"type": "string", "description": "Search term"},
"field": {"type": "string", "enum": ["name", "email", "id"]}
},
"required": ["term"],
"additionalProperties": False
},
"strict": True
},
{
"type": "function",
"name": "crm_create_customer",
"description": "Create a new customer in the CRM. "
"Use when a customer does not yet exist.",
"parameters": {
"type": "object",
"properties": {
"name": {"type": "string"},
"email": {"type": "string"},
"company": {"type": "string"}
},
"required": ["name", "email", "company"],
"additionalProperties": False
},
"strict": True
}
]
billing_catalog = [
{
"type": "function",
"name": "bill_create_invoice",
"description": "Create an invoice. Requires an existing customer.",
"parameters": {
"type": "object",
"properties": {
"client_id": {"type": "string"},
"lines": {"type": "array", "items": {"type": "object", "properties": {
"description": {"type": "string"},
"amount": {"type": "number"}
}}}
},
"required": ["client_id", "lines"],
"additionalProperties": False
},
"strict": True
}
]
# Fusionner tous les catalogues
full_catalog = crm_catalog + billing_catalog
Bonnes pratiques pour les descriptions
Rédigez des descriptions pour la recherche, pas pour la documentation. « Récupérer les données client » ne sera jamais trouvé par une requête concernant l’« historique des commandes » ou les « coordonnées de facturation » : les mots que vos utilisateurs tapent réellement doivent apparaître dans le texte indexé. Une description utile nomme des cas d’usage et le vocabulaire métier, pas les détails d’implémentation.
# Mauvais : trop générique
{"name": "get_data", "description": "Retrieve data"}
# Bon : spécifique avec contexte d'utilisation
{
"name": "hr_check_leave_balance",
"description": "Check an employee's leave balance (vacation, personal time, sick leave). "
"Returns remaining days by leave type. "
"Use when an employee asks how many days they have left."
}
# Bon : avec synonymes pour améliorer la recherche
{
"name": "acct_reconcile_bank",
"description": "Bank reconciliation: compare accounting entries "
"with bank transactions. Account reconciliation. "
"Use to verify consistency between accounting records "
"and bank statements."
}
Combiner Tool Search avec des outils fixes
Le mélange est le mode de fonctionnement standard en production. Quelques outils transversaux — heure, utilisateur actuel, recherche de documents — restent déclarés en permanence car ils servent presque toutes les requêtes, tandis que le catalogue métier reste dynamique. Cela maintient le contexte léger sans obliger le modèle à rechercher à chaque fois ce dont il a besoin.
response = client.responses.create(
model="gpt-5.6-terra",
input="Search the web for this month's sales and create the corresponding invoice",
tools=[
# Outils toujours disponibles
{"type": "web_search"},
{"type": "code_interpreter", "container": {"type": "auto"}},
# Catalogue dynamique
{
"type": "tool_search",
"tool_search": {
"tools": full_catalog # 200+ fonctions
}
}
]
)
Modèle : système multi-domaines
class MultiDomainSystem:
def __init__(self):
self.client = OpenAI()
self.catalogs = {}
def register_domain(self, name: str, functions: list[dict]):
"""Register a function catalog for a domain."""
self.catalogs[name] = functions
def full_catalog(self) -> list[dict]:
"""Merge all catalogs."""
result = []
for functions in self.catalogs.values():
result.extend(functions)
return result
def execute(self, query: str) -> str:
"""Execute a query with Tool Search across all domains."""
response = self.client.responses.create(
model="gpt-5.6-terra",
input=query,
tools=[{
"type": "tool_search",
"tool_search": {
"tools": self.full_catalog()
}
}]
)
# Traiter les appels de fonction
for item in response.output:
if item.type == "function_call":
result = self.dispatcher(item.name, item.arguments)
# ... boucle d'appel de fonction
return response.output_text
def dispatcher(self, name: str, arguments: str):
"""Route the call to the correct service."""
# Votre logique de routage
pass
# Utilisation
system = MultiDomainSystem()
system.register_domain("crm", crm_catalog)
system.register_domain("billing", billing_catalog)
system.register_domain("hr", hr_catalog)
system.register_domain("support", support_catalog)
# Le modèle trouve automatiquement la bonne fonction
# parmi des centaines de possibilités
result = system.execute("How many vacation days does Marie Dupont have left?")
Belangrijkste punten
- Tool Search résout le problème des grands catalogues de fonctions
- Le modèle ne reçoit que les fonctions pertinentes dans son contexte
- Des descriptions riches et spécifiques sont essentielles pour la précision
- Préfixez les noms de fonctions par domaine pour la lisibilité
- Combinez Tool Search avec des outils intégrés toujours disponibles