Terminez d'abord "Cours 3 : Des prompts aux flux de travail d’agent" pour débloquer cette leçon.Aller à la leçon précédente

Introduction

Un agent IA devient véritablement utile uniquement lorsqu’il peut sortir de sa propre fenêtre de contexte. L’appel d’outils est le mécanisme qui permet à un modèle de langage de décider qu’il doit récupérer une ligne dans une base de données, appeler une API météo ou déclencher une action serveur, puis de recevoir le résultat comme étape suivante de son raisonnement. Dans cette leçon, nous nous concentrons sur la conception de cette boucle pour qu’elle soit fiable au sein d’une application web.

Nous considérerons un outil comme une fonction simple avec trois éléments : un nom stable, un schéma JSON décrivant ses paramètres et une description indiquant au modèle quand l’utiliser. Tout le reste n’est que plomberie sur le frontend et le backend.

diagramme montrant la boucle Message utilisateur -> LLM décide l’appel d’outil -> Backend exécute la fonction -> Résultat de l’outil renvoyé au LLM -> Réponse finale à l’utilisateur

Schéma d’outil et Bases de l’appel de fonction

La plupart des API LLM modernes exposent la même forme. Vous passez un tableau de définitions d’outils, chacun contenant un nom, une description et un schéma de paramètres. Le modèle peut répondre par une demande structurée d’appeler l’un de ces outils, que votre backend exécute ensuite.

Voici une déclaration minimale d’un outil dans le style utilisé par le SDK Python d’OpenAI. Le schéma est ce que le modèle lit réellement pour décider quels arguments produire.

python
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a city. Use when the user asks about weather, temperature, or conditions in a specific location.",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "City name, e.g. 'Hanoi'"},
"unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
},
"required": ["city"]
}
}
}
]

Remarquez trois choix de conception qui comptent. Premièrement, la description est une instruction courte indiquant au modèle quand déclencher l’outil, rédigée dans la même voix que votre invite système. Deuxièmement, les paramètres utilisent le JSON Schema standard afin que les valeurs énumérées et les champs obligatoires soient imposés. Troisièmement, les valeurs par défaut sont exclues du schéma à moins que vous ne vouliez que le modèle les considère comme optionnelles.

Connecter les outils à un backend d’application web

Dans une vraie application web, l'agent ne s'exécute pas dans le navigateur. Le navigateur envoie la conversation vers votre backend, le backend appelle le LLM avec la liste d'outils, et lorsque le modèle renvoie un appel d'outil, votre serveur l'exécute réellement contre vos propres services. Le résultat est renvoyé au modèle sous forme de message d'outil, puis le modèle produit la réponse finale.

Un gestionnaire minimal FastAPI ressemble à ceci. Il détecte un appel d'outil dans la réponse, exécute la fonction Python correspondante et réinjecte la sortie dans la conversation.

python
from fastapi import FastAPI
from openai import OpenAI
app = FastAPI()
client = OpenAI()
def get_weather(city: str, unit: str = "celsius") -> dict:
# call your real weather provider here
return {"city": city, "unit": unit, "temp": 30, "condition": "sunny"}
dispatch = {"get_weather": get_weather}
@app.post("/chat")
def chat(messages: list):
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=messages,
tools=tools,
)
msg = response.choices[0].message
if msg.tool_calls:
for call in msg.tool_calls:
fn = dispatch[call.function.name]
args = json.loads(call.function.arguments)
result = fn(**args)
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
response = client.chat.completions.create(model="gpt-4o-mini", messages=messages, tools=tools)
return {"reply": response.choices[0].message.content}

Le dictionnaire de dispatch est le motif le plus propre pour les petits projets. Pour les systèmes plus importants, vous déplacez l'enregistrement des outils vers un objet registre afin que les outils puissent être ajoutés sans modifier le gestionnaire.

Conception des paramètres

La plupart des échecs d'outil viennent d'une mauvaise conception des paramètres, et non du modèle. Deux motifs réduisent cela de façon spectaculaire.

Tout d'abord, privilégiez des paramètres plats plutôt que des objets imbriqués. Un outil qui prend des champs séparés lat et lon est plus facile pour un modèle à remplir correctement qu'un outil qui prend un seul objet localisation imbriqué. Ensuite, reflétez le vocabulaire que vos utilisateurs utilisent réellement. Si les utilisateurs disent code postal, exposez un paramètre appelé zip_code, et non postal_code.

json
{
"name": "search_products",
"description": "Search the product catalog by keyword and optional filters.",
"parameters": {
"type": "object",
"properties": {
"keyword": {"type": "string", "description": "Search term, e.g. 'running shoes'"},
"max_price_usd": {"type": "number", "description": "Optional upper price limit in USD"},
"in_stock_only": {"type": "boolean", "description": "If true, only return items currently in stock"}
},
"required": ["keyword"]
}
}

Trois paramètres plats, l'un requis, le reste avec des valeurs par défaut raisonnables que le modèle peut laisser vide.

Pièges courants

Quelques erreurs apparaissent dans presque toutes les intégrations. Le modèle hallucine un nom d'outil qui n'existe pas, il faut donc toujours valider call.function.name par rapport à vos outils enregistrés avant le dispatch. Le modèle transmet une chaîne là où votre fonction attend un entier, il faut donc convertir les arguments selon le schéma avant d'appeler. Et l’agent entre dans une boucle infinie d'appels d'outils parce qu'il pense qu'il a encore besoin de plus d'informations, il faut donc limiter la boucle à trois à cinq itérations et proposer une réponse de repli s'il ne converge jamais.

Enregistrer chaque appel d'outil avec ses arguments et son résultat est l'habitude de débogage à plus fort levier. Lorsqu'il y a une rupture en production, ce journal est ce qui vous permettra de voir si le modèle a choisi le mauvais outil, choisi le bon outil avec les mauvais arguments, ou si votre backend a renvoyé une forme inattendue.

Résumé

L'appel d'outil transforme un chatbot en agent. Vous définissez les outils comme JSON Schema, vous les passez à chaque appel de LLM, vous exécutez ce que le modèle demande sur votre backend, et vous réinjectez le résultat sous forme de message d'outil. Une bonne conception des paramètres est plate, utilise le vocabulaire des utilisateurs et indique clairement les champs obligatoires. Validez toujours les noms d'outil, limitez la boucle et journalisez tout. Dans la prochaine leçon, nous superposons la planification et le raisonnement en plusieurs étapes sur cette boucle.

Entraînement

Point de contrôle de la leçon

Révisez la leçon et recevez des conseils sur votre travail.

0/1
Répondu · 0/1