Fonctionnement des appels de fonctions
Comprenez l’aller-retour complet : le modèle choisit un outil, votre code l’exécute, vous renvoyez le résultat, puis le modèle poursuit son traitement.
Fonctionnement des appels de fonctions est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.
Appel de fonctions : le schéma fondamental
L'appel de fonctions est le protocole qui transforme un LLM en agent. Le modèle choisit une fonction dans une liste que vous fournissez, renseigne les arguments, puis vous l'exécutez.
Ce schéma est pris en charge par OpenAI, Anthropic, Google, Cohere, Mistral et la plupart des grands modèles OSS avec les bons réglages fins.
L'aller-retour en cinq étapes
- Vous envoyez les messages et les définitions d'outils
- Le modèle renvoie soit une réponse finale OR un tool_call
- Vous exécutez l'outil avec les arguments du modèle
- Vous ajoutez le résultat comme message d'outil
- Vous rappelez le modèle avec l'historique mis à jour
Répétez les étapes 2 à 5 jusqu'à ce que le modèle renvoie une réponse finale.
Étape 1 : définir les outils
Les définitions d'outils sont des schémas JSON qui décrivent chaque fonction :
tools = [{
'type': 'function',
'function': {
'name': 'get_weather',
'description': 'Current weather for a city',
'parameters': {
'type': 'object',
'properties': {
'city': {'type': 'string'}
},
'required': ['city']
}
}
}]
import json
print(json.dumps(tools, indent=2))
Étape 2 : premier appel du modèle
Envoyez les messages et les outils :
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': 'Weather in Paris?'}],
tools=tools,
)
message = response.choices[0].message
print(message.tool_calls)
# [ToolCall(name='get_weather', arguments='{"city": "Paris"}')]Étape 3 : exécuter l'outil
Acheminez l'appel vers votre fonction Python :
import json
def get_weather(city: str) -> dict:
# ...call your weather API...
return {'city': city, 'temp_c': 18, 'condition': 'cloudy'}
tool_call = message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_weather(**args)Étape 4 : ajouter le résultat de l'outil
Ajoutez un message d'outil avec l'ID correspondant :
messages.append(message) # the assistant message with tool_calls
messages.append({
'role': 'tool',
'tool_call_id': tool_call.id,
'content': json.dumps(result)
})Étape 5 : deuxième appel du modèle
Rappelez le modèle : il dispose maintenant du résultat de l'outil et produit une réponse destinée à l'utilisateur :
final = client.chat.completions.create(
model='gpt-4o-mini',
messages=messages,
tools=tools,
)
print(final.choices[0].message.content)
# 'It is currently 18 degrees and cloudy in Paris.'La boucle de l'agent
Placez cette logique dans une boucle while : le modèle peut appeler plusieurs outils à la suite :
while True:
response = client.chat.completions.create(model=MODEL, messages=messages, tools=tools)
msg = response.choices[0].message
messages.append(msg)
if not msg.tool_calls:
return msg.content # final answer
for tc in msg.tool_calls:
result = dispatch(tc)
messages.append({'role': 'tool', 'tool_call_id': tc.id, 'content': json.dumps(result)})Appels d'outils en parallèle
Les modèles modernes renvoient plusieurs tool_calls dans une même réponse. Exécutez-les en parallèle lorsque c'est possible sans danger :
import asyncio
async def run_tools(tool_calls):
coros = [dispatch_async(tc) for tc in tool_calls]
return await asyncio.gather(*coros)finish_reason : tool_calls
Vous pouvez également vérifier finish_reason au lieu de rechercher tool_calls :
if response.choices[0].finish_reason == 'tool_calls':
# the model wants to call tools
...
elif response.choices[0].finish_reason == 'stop':
# done
...Erreurs courantes
- Oublier d'ajouter le message de l'assistant avant le résultat de l'outil
- Utiliser le mauvais tool_call_id
- Envoyer les résultats des outils comme des messages utilisateur
- Laisser la boucle s'exécuter sans limite : définissez MAX_STEPS
Terminaison de la boucle
Comment savoir quand l'agent a terminé ?
Récapitulatif
L'appel de fonctions est le schéma le plus important de tout ce cours. Maîtrisez-le avant de poursuivre.
Questions Fréquemment Posées
La leçon « Fonctionnement des appels de fonctions » est-elle gratuite ?
Oui — le texte complet de « Fonctionnement des appels de fonctions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Fonctionnement des appels de fonctions » ?
Comprenez l’aller-retour complet : le modèle choisit un outil, votre code l’exécute, vous renvoyez le résultat, puis le modèle poursuit son traitement. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Agents ?
Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Fonctionnement des appels de fonctions » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?
Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Fonctionnement des appels de fonctions
- Définir des schémas d’outils (JSON Schema)
- Choisir les outils à l’exécution
- Renvoyer les résultats au modèle