Recherche d'outils : Outils dynamiques
På denna sida
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éesinput_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.
Recherche d’outils : Outils dynamiques
Lorsque tu disposes 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. La recherche d’outils (Tool Search) résout ce problème en permettant au modèle de consulter un catalogue indexé pour trouver l’outil approprié.
Le problème des grands catalogues d’outils
Le coût d’un vaste catalogue d’outils est invisible de deux manières. D’abord, 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. Ensuite, 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 choisit parfois la mauvaise fonction ou hallucine des paramètres
Activer la recherche d’outils
La recherche d’outils inverse la logique : au lieu de tout présenter au modèle, tu indexes le catalogue et ne lui montres que ce qui correspond à la demande 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, mais 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 la recherche d'outils 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 demande, et non l’intégralité du catalogue.
Organiser le catalogue de fonctions
Deux principes suffisent à structurer un catalogue qui reste navigable. Préfixe les noms par domaine (crm_, billing_, inventory_) : la lecture des traces d’exécution devient immédiate et les collisions de noms disparaissent. Donne 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édige 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 tes 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 le 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 des 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 la recherche d’outils 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 garde 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()
}
}]
)
# Process function calls
for item in response.output:
if item.type == "function_call":
result = self.dispatcher(item.name, item.arguments)
# ... function calling loop
return response.output_text
def dispatcher(self, name: str, arguments: str):
"""Route the call to the correct service."""
# Your routing logic
pass
# Usage
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)
# The model automatically finds the right function
# among hundreds of possibilities
result = system.execute("How many vacation days does Marie Dupont have left?")
Viktiga punkter
- La recherche d’outils 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éfixe les noms de fonctions par domaine pour la lisibilité
- Combine la recherche d’outils avec des outils intégrés toujours disponibles