Salt la conținutul principal
Română— Alege o limbă
Meniu

Tool Search: Outils dynamiques

Lecția 15 din 20 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Tool Search : Outils dynamiques
  2. Le problème des grands catalogues d’outils
  3. Activer Tool Search
  4. Organiser le catalogue de fonctions
  5. Bonnes pratiques pour les descriptions
  6. Combiner Tool Search avec des outils fixes
  7. Modèle : Système multi-domaines
  8. Puncte cheie

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 comme 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 à l’aide des fonctions fichiers_generes et telecharger de 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 choisit parfois la mauvaise fonction ou hallucine des paramètres

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 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 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?")

Puncte cheie

  • 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