Tool Search: Outils dynamiques
På denna sida
Tool Search : Outils dynamiques
Un agent de démonstration se débrouille très bien avec trois ou quatre outils. Un agent d’entreprise, en revanche, en accumule inévitablement des dizaines, parfois des centaines : facturation, RH, CRM, documents, planification. À cette échelle, envoyer le catalogue entier au modèle à chaque requête devient inefficace et coûteux en tokens. Tool Search résout ce problème en sélectionnant dynamiquement les outils pertinents pour chaque demande.
Le problème de la surabondance d’outils
Imagine un agent disposant de 50 outils. À chaque appel d’API, les schémas de ces 50 outils sont envoyés dans le prompt. Cela consomme des milliers de tokens et peut embrouiller le modèle : plus la liste est longue, plus les descriptions se ressemblent, et plus le modèle hésite entre des outils voisins. Les coûts augmentent tandis que la précision chute – la pire des combinaisons.
# Problème : trop d'outils
agent = Agent(
name="Super Agent",
instructions="You can do anything.",
tools=[tool_1, tool_2, tool_3, ... , tool_50], # 50 outils = beaucoup de tokens
)
Activer Tool Search
Tool Search utilise un index sémantique pour sélectionner les outils pertinents en fonction de la requête. Tu déclares tes outils comme d’habitude, mais le paramètre tool_use_behavior="auto" permet au modèle de choisir dans le catalogue au lieu de tout charger d’emblée. Dans l’exemple ci-dessous, une demande d’envoi de rappel de paiement ne déclenchera pas les outils RH, et vice versa.
from agents import Agent, Runner, function_tool
# Définir de nombreux outils
@function_tool
def create_invoice(client: str, amount: float) -> str:
"""Creates an invoice for a client."""
return f"Invoice created for {client}: €{amount}"
@function_tool
def send_reminder(invoice_id: str) -> str:
"""Sends a payment reminder for an unpaid invoice."""
return f"Reminder sent for invoice {invoice_id}"
@function_tool
def generate_hr_report(month: str) -> str:
"""Generates a human resources report for a given month."""
return f"HR report generated for {month}"
@function_tool
def schedule_interview(candidate: str, date: str) -> str:
"""Schedules a job interview with a candidate."""
return f"Interview scheduled with {candidate} on {date}"
# Beaucoup d'autres outils...
agent = Agent(
name="Enterprise Agent",
instructions="You manage company operations.",
tools=[
create_invoice,
send_reminder,
generate_hr_report,
schedule_interview,
# ... 50 autres outils
],
tool_use_behavior="auto", # Le modèle sélectionne dynamiquement
)
Modèle : Sélection manuelle des outils
Si tu souhaites un contrôle total sur la sélection des outils, implémente ta propre logique. Le principe est simple : un petit agent routeur lit la requête et nomme simplement le domaine pertinent. Tu construis ensuite l’agent spécialisé à la volée avec uniquement les outils de ce domaine. Une phrase comme « envoyer un rappel pour la facture F-2026-114 » ressort du routeur avec la réponse accounting, et l’agent d’exécution ne voit jamais les outils RH.
from agents import Agent, Runner, function_tool
# Grouper les outils par domaine
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]
# Un agent routeur qui sélectionne le domaine
router = Agent(
name="Router",
instructions="""Determine the domain of the request.
Respond only with 'accounting' or 'hr'.""",
model="gpt-5.6-terra", # Rapide et peu coûteux pour le routage
output_type=str,
)
async def handle_request(message: str):
# Étape 1 : Déterminer le domaine
route = await Runner.run(router, message)
domain = route.final_output.strip().lower()
# Étape 2 : Créer l'agent spécialisé avec les bons outils
if domain == "accounting":
tools = accounting_tools
instructions = "You manage the company's accounting."
elif domain == "hr":
tools = hr_tools
instructions = "You manage human resources."
else:
tools = accounting_tools + hr_tools
instructions = "You manage company operations."
specialized_agent = Agent(
name=f"{domain.capitalize()} Agent",
instructions=instructions,
tools=tools,
model="gpt-5.6-terra",
)
result = await Runner.run(specialized_agent, message)
return result.final_output
L’utilisation de gpt-5.6-terra pour le routage et l’exécution appartient à la génération précédente de modèles ; le raisonnement derrière ce schéma reste identique avec la famille GPT-5.6, où les paramètres d’effort distinguent le routeur rapide de l’exécuteur.
Modèle : Outils dynamiques conscients du contexte
La sélection ne dépend pas seulement de la question posée ; elle dépend aussi de celui qui la pose. Tu peux adapter les outils disponibles en fonction de l’utilisateur connecté, faisant d’une pierre deux coups : moins de tokens envoyés et, surtout, des contrôles d’accès appliqués avant même que le modèle ne raisonne. Un employé commercial obtient des outils de devis, mais delete_account n’existe tout simplement pas dans son agent.
from dataclasses import dataclass
@dataclass
class UserContext:
role: str # "admin", "manager", "employee"
department: str
def get_tools_for_role(ctx: UserContext) -> list:
"""Returns authorized tools based on role."""
base_tools = [search_document, view_schedule]
if ctx.role in ("admin", "manager"):
base_tools.extend([create_invoice, generate_hr_report])
if ctx.role == "admin":
base_tools.extend([modify_permissions, delete_account])
if ctx.department == "sales":
base_tools.extend([search_client, create_quote])
return base_tools
async def create_agent_for_user(ctx: UserContext):
tools = get_tools_for_role(ctx)
return Agent(
name="Custom Agent",
instructions=f"You assist a {ctx.role} in the {ctx.department} department.",
tools=tools,
model="gpt-5.6-terra",
)
Optimiser les descriptions d’outils
Quel que soit le mécanisme de sélection choisi, il repose sur une seule matière : le texte de tes descriptions. La qualité de ces descriptions impacte directement la pertinence de la sélection. Compare les deux déclarations ci-dessous : la première ne dit rien sur le scénario d’utilisation, tandis que la seconde nomme les entrées, la sortie et le moment opportun pour l’utiliser.
# Mauvais : description vague
@function_tool
def process_data(data: str) -> str:
"""Processes data."""
return "OK"
# Bon : description précise et contextualisée
@function_tool
def calculate_gross_margin(revenue: float, production_cost: float) -> str:
"""Calculates gross margin as a percentage from revenue
and production cost. Useful for quarterly financial analysis."""
margin = ((revenue - production_cost) / revenue) * 100
return f"Gross margin: {margin:.1f}% (Revenue: €{revenue}, Costs: €{production_cost})"
Une bonne description d’outil ressemble à une bonne docstring : elle explique quand utiliser l’outil, pas seulement ce qu’il fait. Prends dix minutes pour revoir les descriptions de ton agent, en te demandant pour chacune si un collègue pourrait choisir le bon outil en lisant uniquement cette phrase. C’est exactement l’exercice que le modèle effectue.
Viktiga punkter
- Tool Search sélectionne dynamiquement les outils pertinents pour chaque requête
- Avec de nombreux outils, un agent routeur peut déterminer le domaine au préalable
- Adapte les outils disponibles selon le rôle et le contexte de l’utilisateur
- La qualité des descriptions d’outils impacte la précision de la sélection
- Utilise un modèle léger pour un routage rapide et un modèle performant pour l’exécution