Appel de fonctions et intégration d’API
Maîtrisez la conception d’invites permettant aux LLM d’appeler des fonctions ou des API externes et d’interagir avec des systèmes du monde réel.
Appel de fonctions et intégration d’API est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. 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 Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 3 leçons au total.
Appeler des outils externes
Les LLM sont puissants, mais ils évoluent principalement dans un univers textuel. Que se passe-t-il lorsqu’ils ont besoin d’informations du monde réel ou doivent effectuer des actions ?
L’appel de fonctions permet aux LLM d’interagir avec des outils et des API externes ! Cela comble l’écart entre le langage et l’action, ce qui permet à l’IA de :
- Obtenir des informations actualisées (météo, cours des actions).
- Effectuer des actions (envoyer des courriels, prendre des rendez-vous).
- Se connecter à des bases de données ou à des outils personnalisés.
Cela ouvre de nouvelles possibilités pour les systèmes d’IA.
Rôle du LLM : suggérer des appels
Lorsque vous activez l’appel de fonctions, vous fournissez au LLM des descriptions des outils (fonctions) disponibles.
Au lieu de répondre directement, le LLM peut décider qu’un outil serait utile. Il produit alors une « suggestion » structurée d’appel de fonction, qui contient le nom de la fonction et ses arguments.
Important : Le LLM n’exécute pas lui-même la fonction. Il indique simplement à votre application quelle fonction appeler et avec quelles entrées.
Définir vos outils
Pour utiliser l’appel de fonctions, vous devez définir vos outils (fonctions) d’une manière compréhensible par le LLM. Cela consiste généralement à fournir :
- Un nom pour la fonction (par exemple,
get_current_weather). - Une description de ce qu’elle fait (ce qui est essentiel pour que le LLM fasse le bon choix).
- Les paramètres qu’elle accepte, avec leurs types et leurs descriptions (par exemple,
location: string).
Ce « schéma » indique au LLM tout ce qu’il doit savoir pour suggérer un appel valide.
Définition d’un outil météorologique
Voici une définition conceptuelle en Python d’un outil météorologique. Remarquez la clarté de la description et des paramètres. C’est ce que vous mettriez à la disposition du LLM.
Cette fonction représente l’outil externe qu’un LLM « appellerait » en théorie.
def get_current_weather(location: str, unit: str = "celsius"):
"""
Get the current weather in a given location.
Args:
location (str): The city and state, e.g. "London, UK"
unit (str): The unit of temperature, "celsius" or "fahrenheit"
Returns:
dict: Weather information.
"""
# In a real app, this would call a weather API
if location == "London, UK":
return {"temperature": "15", "unit": unit, "forecast": "cloudy"}
elif location == "New York, USA":
return {"temperature": "20", "unit": unit, "forecast": "sunny"}
else:
return {"temperature": "N/A", "unit": unit, "forecast": "unknown"}
Concevoir des instructions pour les outils
Pour encourager le LLM à utiliser vos outils, votre instruction doit énoncer clairement l’intention de l’utilisateur. Le LLM décide ensuite si un outil peut être utile.
Vous n’indiquez pas explicitement au LLM « appelez get_weather ». Vous posez plutôt une question qui le suggère :
- « Quel temps fait-il à Londres ? »
- « Pouvez-vous me réserver une réunion pour demain ? »
Le LLM, muni des descriptions des outils, déduira qu’un appel de fonction est nécessaire.
Suggestion d’appel du LLM
Lorsque le LLM décide d’utiliser un outil, il ne vous fournit pas de réponse directe. Il renvoie plutôt un objet structuré, généralement au format JSON, qui indique la fonction à appeler et ses arguments.
Votre application analyse ensuite cette sortie.
Voici ce que pourrait suggérer un LLM si on lui demandait : « Quel temps fait-il à Londres ? » :
{
"tool_calls": [
{
"id": "call_abc123",
"function": {
"name": "get_current_weather",
"arguments": "{\"location\": \"London, UK\", \"unit\": \"celsius\"}"
},
"type": "function"
}
]
}Votre application exécute l’outil
Après avoir reçu la suggestion d’appel de fonction du LLM, votre application prend le relais :
- Elle identifie la fonction demandée (par exemple,
get_current_weather). - Elle extrait les arguments (par exemple,
"London, UK"). - Elle exécute la véritable fonction Python (ou effectue l’appel d’API) dans l’environnement de votre application.
C’est ici que l’action du « monde réel » se déroule en dehors du LLM.
Le LLM traite la sortie de l’outil
Après l’exécution de la fonction par votre application, celle-ci reçoit un résultat (par exemple, {"temperature": "15", ...}).
Ce résultat est ensuite renvoyé au LLM, avec l’historique de la conversation initiale et la demande d’appel de fonction.
Le LLM utilise alors ces nouvelles informations pour générer une réponse en langage naturel à la question initiale de l’utilisateur.
Interaction de bout en bout
Mettons tout cela en pratique. Cet exemple montre le déroulement suivant : la question d’un utilisateur amène un LLM à suggérer un appel de fonction, votre application l’exécute, puis le LLM fournit une answer finale.
Il s’agit d’une représentation simplifiée de la boucle d’interaction.
def get_current_weather(location, unit="celsius"):
if location == "London, UK":
return {"temp": "15", "unit": unit, "forecast": "cloudy"}
return {"temp": "N/A", "unit": unit, "forecast": "unknown"}
def simulate_llm_response(user_query):
# LLM 'thinks' and decides to call a tool
if "weather in London" in user_query:
return {
"type": "tool_call",
"function": "get_current_weather",
"args": {"location": "London, UK"}
}
return {"type": "text", "content": "I cannot help with that."}
def simulate_llm_final_response(tool_output):
# LLM processes tool output and gives natural language
temp = tool_output.get("temp", "N/A")
forecast = tool_output.get("forecast", "unknown")
return f"The weather in London is {temp} degrees and {forecast}."
def main():
user_input = "What is the weather in London, UK?"
print(f"User: {user_input}")
llm_output = simulate_llm_response(user_input)
if llm_output["type"] == "tool_call":
func_name = llm_output["function"]
func_args = llm_output["args"]
print(f"LLM suggested calling: {func_name}({func_args})")
# Execute the function
tool_result = get_current_weather(**func_args)
print(f"Tool output: {tool_result}")
# Feed result back to LLM
final_answer = simulate_llm_final_response(tool_result)
print(f"LLM's final answer: {final_answer}")
else:
print(f"LLM: {llm_output['content']}")
if __name__ == "__main__":
main()
Vérification des appels de fonctions
Imaginez qu’un LLM renvoie une demande d’appel de fonction. Quelle est la prochaine étape immédiate que votre application doit effectuer ?
Récapitulatif : les outils en action
Dans cette leçon, nous avons étudié comment les LLM peuvent interagir avec le monde réel grâce à l’appel de fonctions et à l’intégration d’API.
Nous avons appris que :
- Vous définissez des outils (fonctions) avec des descriptions et des paramètres.
- Le LLM suggère quel outil appeler et avec quels arguments.
- Votre application exécute l’outil réel et renvoie le résultat.
- Le LLM utilise ensuite ce résultat pour formuler une réponse finale et éclairée.
Cette technique puissante permet aux LLM d’aller au-delà de la simple génération de texte, en leur donnant la possibilité d’effectuer des actions et de récupérer des informations à jour.
Questions Fréquemment Posées
La leçon « Appel de fonctions et intégration d’API » est-elle gratuite ?
Oui — le texte complet de « Appel de fonctions et intégration d’API » 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 Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Appel de fonctions et intégration d’API » ?
Maîtrisez la conception d’invites permettant aux LLM d’appeler des fonctions ou des API externes et d’interagir avec des systèmes du monde réel. Tu pratiques AI Prompt Engineering 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 Prompt Engineering ?
Aucune expérience préalable n'est requise. AI Prompt Engineering 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 3.
Combien de temps prend la leçon « Appel de fonctions et intégration d’API » ?
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 Prompt Engineering ?
Oui. Chaque leçon AI Prompt Engineering 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
- Appel de fonctions et intégration d’API
- Systèmes d’invites multi-agents
- Outils et extensions personnalisés pour les LLM