Comment créer un agent IA avec appel de fonction et GPT-5
et les grands modèles linguistiques (LLM)
Grands modèles de langage (LLM) sont des systèmes d’IA avancés construits sur un réseau neuronal profond tel que des transformateurs et entraînés sur de grandes quantités de texte pour générer un langage semblable à celui de l’humain. Les LLM comme ChatGPT, Claude, Gemini et Grok peuvent s’attaquer à de nombreuses tâches difficiles et sont utilisés dans des domaines tels que la science, la santé, l’éducation et la finance.
Un agent d’IA étend les capacités des LLM pour résoudre des tâches qui dépassent leurs connaissances pré-entraînées. Un LLM peut rédiger un tutoriel Python à partir de ce qu’il a appris lors de la formation. Si vous lui demandez de réserver un vol, la tâche nécessite l’accès à votre calendrier, une recherche sur le Web et la capacité d’entreprendre des actions, celles-ci dépassent les connaissances pré-formées du LLM. Certaines des actions courantes comprennent :
- Prévisions météorologiques: Le LLM se connecte à un outil de recherche Web pour récupérer les dernières prévisions météorologiques.
- Agent de réservation : Un agent IA qui peut consulter le calendrier d’un utilisateur, effectuer des recherches sur le Web pour visiter un site de réservation comme Expedia afin de trouver les options disponibles pour les vols et les hôtels, les présenter à l’utilisateur pour confirmation et effectuer la réservation au nom de l’utilisateur.
Comment fonctionne un agent IA
Les agents d’IA forment un système qui utilise un grand modèle linguistique pour planifier, raisonner et prendre des mesures pour interagir avec son environnement à l’aide d’outils suggérés par le raisonnement du modèle pour résoudre une tâche particulière.
Structure de base d’un agent IA
- Un grand modèle de langage (LLM) : le LLM est le cerveau d’un agent IA. Il prend en compte l’invite, les plans et les raisons d’un utilisateur tout au long de la demande et divise le problème en étapes qui déterminent les outils qu’il doit utiliser pour accomplir la tâche.
- Un outil est le cadre que l’agent utilise pour effectuer une action basée sur le plan et le raisonnement du Large Language Model. Si vous demandez à un LLM de réserver une table pour vous dans un restaurant, les outils possibles qui seront utilisés incluent un calendrier pour vérifier votre disponibilité et un outil de recherche sur le Web pour accéder au site Web du restaurant et faire une réservation pour vous.
Prise de décision illustrée d’un agent d’IA de réservation
Les agents IA peuvent accéder à différents outils en fonction de la tâche. Un outil peut être un magasin de données, tel qu’une base de données. Par exemple, un agent du support client pourrait accéder aux détails du compte et à l’historique des achats d’un client et décider quand récupérer ces informations pour aider à résoudre un problème.
Les agents d’IA sont utilisés pour résoudre un large éventail de tâches, et de nombreux agents puissants sont disponibles. Les agents de codage, en particulier les IDE agents tels que Cursor, Windsurf et GitHub Copilot, aident les ingénieurs à écrire et déboguer du code plus rapidement et à créer des projets rapidement. Les agents de codage CLI tels que Claude Code et Codex CLI peuvent interagir avec le bureau et le terminal d’un utilisateur pour effectuer des tâches de codage. ChatGPT prend en charge les agents qui peuvent effectuer des actions telles que la réservation au nom d’un utilisateur. Les agents sont également intégrés aux flux de travail du support client pour communiquer avec les clients et résoudre leurs problèmes.
Appel de fonction
L’appel de fonction est une technique permettant de connecter un grand modèle de langage (LLM) à des outils externes tels que des API ou des bases de données. Il est utilisé dans la création d’agents IA pour connecter les LLM aux outils. Dans l’appel de fonction, chaque outil est défini comme une fonction de code (par exemple, une API météo pour récupérer les dernières prévisions) ainsi qu’un schéma JSON qui spécifie les paramètres de la fonction et indique au LLM quand et comment appeler la fonction pour une tâche donnée.
Le type de fonction défini dépend de la tâche pour laquelle l’agent est conçu. Par exemple, pour un agent du support client, nous pouvons définir une fonction capable d’extraire des informations à partir de données non structurées, telles que des PDF contenant des détails sur les produits d’une entreprise.
Dans cet article, je vais montrer comment utiliser l’appel de fonction pour créer un agent de recherche Web simple en utilisant GPT-5 comme grand modèle de langage.
Structure de base d’un agent de recherche Web
La logique principale derrière l’agent de recherche Web :
- Définissez une fonction de code pour gérer la recherche sur le Web.
- Définissez des instructions personnalisées qui guident le grand modèle de langage pour déterminer quand appeler la fonction de recherche Web en fonction de la requête. Par exemple, si la requête porte sur la météo actuelle, l’agent de recherche Web reconnaîtra la nécessité de rechercher sur Internet pour obtenir les derniers bulletins météorologiques. Cependant, si la requête lui demande d’écrire un didacticiel sur un langage de programmation tel que Python, auquel il peut répondre grâce à ses connaissances pré-entraînées, il n’appellera pas la fonction de recherche Web et répondra directement à la place.
Condition préalable
Créez un compte OpenAI et générez une clé API
1 : Créer un Compte OpenAI si tu n’en as pas
2 : Générer une clé API
Configurer et activer l’environnement
python3 -m venv env
source env/bin/activateExporter la clé API OpenAI
export OPENAI_API_KEY="Your Openai API Key"Configurer Tavily pour la recherche sur le Web
Tavily est un outil de recherche Web spécialisé pour les agents IA. Créez un compte sur Tavily.comet une fois votre profil configuré, une clé API sera générée que vous pourrez copier dans votre environnement. Les nouveaux comptes reçoivent 1 000 crédits gratuits pouvant être utilisés pour jusqu’à 1 000 recherches sur le Web.
Exporter la clé API TAVILY
export TAVILY_API_KEY="Your Tavily API Key"Installer des packages
pip3 install openai
pip3 install tavily-pythonCréation d’un agent de recherche Web avec appel de fonction étape par étape
Étape 1 : Créer une fonction de recherche sur le Web avec Tavily
Une fonction de recherche Web est implémentée à l’aide de Tavily, servant d’outil pour l’appel de fonction dans l’agent de recherche Web.
from tavily import TavilyClient
import os
tavily = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
def web_search(query: str, num_results: int = 10):
try:
result = tavily.search(
query=query,
search_depth="basic",
max_results=num_results,
include_answer=False,
include_raw_content=False,
include_images=False
)
results = result.get("results", [])
return {
"query": query,
"results": results,
"sources": [
{"title": r.get("title", ""), "url": r.get("url", "")}
for r in results
]
}
except Exception as e:
return {
"error": f"Search error: {e}",
"query": query,
"results": [],
"sources": [],
}Répartition du code de fonction Web
Tavily est initialisé avec sa clé API. Dans le web_search fonction, les étapes suivantes sont effectuées :
- La fonction de recherche Tavily est appelée pour effectuer une recherche sur Internet et récupérer les 10 meilleurs résultats.
- Les résultats de la recherche et leurs sources correspondantes sont renvoyés.
Cette sortie renvoyée servira de contexte pertinent à l’agent de recherche Web : que nous définirons plus loin dans cet article, pour récupérer des informations à jour pour les requêtes (invites) qui nécessitent des données en temps réel telles que les prévisions météorologiques.
Étape 2 : Créer un schéma d’outil
Le schéma de l’outil définit des instructions personnalisées pour un modèle d’IA indiquant quand il doit appeler un outil, dans ce cas, l’outil qui sera utilisé dans une fonction de recherche Web. Il précise également les conditions et les actions à entreprendre lorsque le modèle appelle un outil. Un schéma d’outil json est défini ci-dessous en fonction du Structure du schéma de l’outil OpenAI.
tool_schema = [
{
"type": "function",
"name": "web_search",
"description": """Execute a web search to fetch up to date information. Synthesize a concise,
self-contained answer from the content of the results of the visited pages.
Fetch pages, extract text, and provide the best available result while citing 1-3 sources (title + URL).
If sources conflict, surface the uncertainty and prefer the most recent evidence.
""",
"strict": True,
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Query to be searched on the web.",
},
},
"required": ["query"],
"additionalProperties": False
},
},
]
Propriétés du schéma d’outil
- taper: Spécifie que le type d’outil est une fonction.
- nom: le nom de la fonction qui sera utilisée pour l’appel de l’outil, qui est recherche_web.
- description: Décrit ce que le modèle d’IA doit faire lors de l’appel de l’outil de recherche Web. Il demande au modèle de rechercher sur Internet à l’aide du recherche_web fonction pour récupérer des informations à jour et extraire les détails pertinents pour générer la meilleure réponse.
- strict: Si elle est définie sur true, cette propriété demande au LLM de suivre strictement les instructions du schéma de l’outil.
- paramètres : Définit les paramètres qui seront transmis au recherche_web fonction. Dans ce cas, il n’y a qu’un seul paramètre : requête qui représente le terme de recherche à rechercher sur Internet.
- requis: Indique au LLM que la requête est un paramètre obligatoire pour le recherche_web fonction.
- Propriétés supplémentaires : il est défini sur false, ce qui signifie que l’outil objet arguments ne peut inclure aucun paramètre autre que ceux définis sous paramètres.propriétés.
Étape 3 : Créer l’agent de recherche Web à l’aide de GPT-5 et de l’appel de fonction
Enfin, je créerai un agent avec lequel nous pourrons discuter, qui pourra effectuer des recherches sur le Web lorsqu’il aura besoin d’informations à jour. j’utiliserai GPT-5-miniun modèle rapide et précis d’OpenAI, ainsi que des appels de fonctions pour invoquer le schéma de l’outil et le fonction de recherche sur le Web déjà défini.
from datetime import datetime, timezone
import json
from openai import OpenAI
import os
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# tracker for the last model's response id to maintain conversation's state
prev_response_id = None
# a list for storing tool's results from the function call
tool_results = []
while True:
# if the tool results is empty prompt message
if len(tool_results) == 0:
user_message = input("User: ")
""" commands for exiting chat """
if isinstance(user_message, str) and user_message.strip().lower() in {"exit", "q"}:
print("Exiting chat. Goodbye!")
break
else:
user_message = tool_results.copy()
# clear the tool results for the next call
tool_results = []
# obtain current's date to be passed into the model as an instruction to assist in decision making
today_date = datetime.now(timezone.utc).date().isoformat()
response = client.responses.create(
model = "gpt-5-mini",
input = user_message,
instructions=f"Current date is {today_date}.",
tools = tool_schema,
previous_response_id=prev_response_id,
text = {"verbosity": "low"},
reasoning={
"effort": "low",
},
store=True,
)
prev_response_id = response.id
# Handles model response's output
for output in response.output:
if output.type == "reasoning":
print("Assistant: ","Reasoning ....")
for reasoning_summary in output.summary:
print("Assistant: ",reasoning_summary)
elif output.type == "message":
for item in output.content:
print("Assistant: ",item.text)
elif output.type == "function_call":
# obtain function name
function_name = globals().get(output.name)
# loads function arguments
args = json.loads(output.arguments)
function_response = function_name(**args)
tool_results.append(
{
"type": "function_call_output",
"call_id": output.call_id,
"output": json.dumps(function_response)
}
)Répartition du code étape par étape
from openai import OpenAI
import os
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
prev_response_id = None
tool_results = []- Initialisation de l’API du modèle OpenAI avec une clé API.
- Initialisation de deux variables prev_response_id et outil_results. prev_response_id garde une trace de la réponse du modèle pour maintenir l’état de la conversation, et outil_results est une liste qui stocke les sorties renvoyées par le recherche_web appel de fonction.
Le chat s’exécute à l’intérieur du boucle. Un utilisateur saisit un message et le modèle appelé avec le schéma de l’outil accepte le message, le raisonne, décide s’il doit appeler l’outil de recherche Web, puis la sortie de l’outil est renvoyée au modèle. Le modèle génère une réponse contextuelle. Cela continue jusqu’à ce que l’utilisateur quitte le chat.
Présentation du code de la boucle
if len(tool_results) == 0:
user_message = input("User: ")
if isinstance(user_message, str) and user_message.strip().lower() in {"exit", "q"}:
print("Exiting chat. Goodbye!")
break
else:
user_message = tool_results.copy()
tool_results = []
today_date = datetime.now(timezone.utc).date().isoformat()
response = client.responses.create(
model = "gpt-5-mini",
input = user_message,
instructions=f"Current date is {today_date}.",
tools = tool_schema,
previous_response_id=prev_response_id,
text = {"verbosity": "low"},
reasoning={
"effort": "low",
},
store=True,
)
prev_response_id = response.id- Vérifie si le outil_results est vide. Si tel est le cas, l’utilisateur sera invité à saisir un message, avec la possibilité de quitter en utilisant sortie ou q.
- Si le outil_results n’est pas vide, message_utilisateur sera défini sur les sorties de l’outil collectées à envoyer au modèle. outil_results est autorisé pour éviter de renvoyer le même sorties de l’outil à la prochaine itération de boucle.
- La date actuelle (date_aujourd’hui) est obtenu pour être utilisé par le modèle pour prendre des décisions en fonction du temps.
- Appels client.responses.create pour générer la réponse du modèle et il accepte les paramètres suivants :
- modèle : réglé sur gpt-5-mini.
- input : accepte le message de l’utilisateur.
- instructions : définir sur la date actuelle (aujourd’hui_date).
- tools : défini sur le schéma d’outils défini précédemment.
- previous_response_id : défini sur l’identifiant de la réponse précédente afin que le modèle puisse maintenir l’état de conversation.
- text : la verbosité est définie sur faible pour que la réponse du modèle reste concise.
- raisonnement : GPT-5-mini est un modèle de raisonnement, définissez l’effort de raisonnement sur un niveau faible pour une réponse plus rapide. Pour les tâches plus complexes, nous pouvons le régler sur un niveau élevé.
- store : indique au modèle de stocker la réponse actuelle afin qu’elle puisse être récupérée plus tard et contribue à la continuité de la conversation.
- prev_response_id
for output in response.output:
if output.type == "reasoning":
print("Assistant: ","Reasoning ....")
for reasoning_summary in output.summary:
print("Assistant: ",reasoning_summary)
elif output.type == "message":
for item in output.content:
print("Assistant: ",item.text)
elif output.type == "function_call":
# obtain function name
function_name = globals().get(output.name)
# loads function arguments
args = json.loads(output.arguments)
function_response = function_name(**args)
# append tool results list with the the function call's id and function's response
tool_results.append(
{
"type": "function_call_output",
"call_id": output.call_id,
"output": json.dumps(function_response)
}
)Cela traite la sortie de réponse du modèle et effectue les opérations suivantes :
- Si le type de sortie est un raisonnement, imprimez chaque élément du résumé du raisonnement.
- Si le type de sortie est un message, parcourez le contenu et imprimez chaque élément de texte.
- Si le type de sortie est un appel de fonction, obtenez le nom de la fonction, analysez ses arguments et transmettez-les à la fonction (recherche_web) pour générer une réponse. Dans ce cas, la réponse de la recherche Web contient des informations à jour pertinentes par rapport au message de l’utilisateur. Ajoute enfin la réponse et l’identifiant de l’appel de fonction à outil_results. Cela permet à la boucle suivante de renvoyer le résultat de l’outil au modèle.
Code complet pour l’agent de recherche Web
from datetime import datetime, timezone
import json
from openai import OpenAI
import os
from tavily import TavilyClient
tavily = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
def web_search(query: str, num_results: int = 10):
try:
result = tavily.search(
query=query,
search_depth="basic",
max_results=num_results,
include_answer=False,
include_raw_content=False,
include_images=False
)
results = result.get("results", [])
return {
"query": query,
"results": results,
"sources": [
{"title": r.get("title", ""), "url": r.get("url", "")}
for r in results
]
}
except Exception as e:
return {
"error": f"Search error: {e}",
"query": query,
"results": [],
"sources": [],
}
tool_schema = [
{
"type": "function",
"name": "web_search",
"description": """Execute a web search to fetch up to date information. Synthesize a concise,
self-contained answer from the content of the results of the visited pages.
Fetch pages, extract text, and provide the best available result while citing 1-3 sources (title + URL). "
If sources conflict, surface the uncertainty and prefer the most recent evidence.
""",
"strict": True,
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Query to be searched on the web.",
},
},
"required": ["query"],
"additionalProperties": False
},
},
]
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# tracker for the last model's response id to maintain conversation's state
prev_response_id = None
# a list for storing tool's results from the function call
tool_results = []
while True:
# if the tool results is empty prompt message
if len(tool_results) == 0:
user_message = input("User: ")
""" commands for exiting chat """
if isinstance(user_message, str) and user_message.strip().lower() in {"exit", "q"}:
print("Exiting chat. Goodbye!")
break
else:
# set the user's messages to the tool results to be sent to the model
user_message = tool_results.copy()
# clear the tool results for the next call
tool_results = []
# obtain current's date to be passed into the model as an instruction to assist in decision making
today_date = datetime.now(timezone.utc).date().isoformat()
response = client.responses.create(
model = "gpt-5-mini",
input = user_message,
instructions=f"Current date is {today_date}.",
tools = tool_schema,
previous_response_id=prev_response_id,
text = {"verbosity": "low"},
reasoning={
"effort": "low",
},
store=True,
)
prev_response_id = response.id
# Handles model response's output
for output in response.output:
if output.type == "reasoning":
print("Assistant: ","Reasoning ....")
for reasoning_summary in output.summary:
print("Assistant: ",reasoning_summary)
elif output.type == "message":
for item in output.content:
print("Assistant: ",item.text)
# checks if the output type is a function call and append the function call's results to the tool results list
elif output.type == "function_call":
# obtain function name
function_name = globals().get(output.name)
# loads function arguments
args = json.loads(output.arguments)
function_response = function_name(**args)
# append tool results list with the the function call's id and function's response
tool_results.append(
{
"type": "function_call_output",
"call_id": output.call_id,
"output": json.dumps(function_response)
}
)Lorsque vous exécutez le code, vous pouvez facilement discuter avec l’agent pour poser des questions nécessitant les dernières informations, telles que la météo actuelle ou les dernières versions de produits. L’agent répond avec des informations à jour ainsi que les sources correspondantes sur Internet. Vous trouverez ci-dessous un exemple de sortie du terminal.
User: What is the weather like in London today?
Assistant: Reasoning ....
Assistant: Reasoning ....
Assistant: Right now in London: overcast, about 18°C (64°F), humidity ~88%, light SW wind ~16 km/h, no precipitation reported. Source: WeatherAPI (current conditions) — https://www.weatherapi.com/
User: What is the latest iPhone model?
Assistant: Reasoning ....
Assistant: Reasoning ....
Assistant: The latest iPhone models are the iPhone 17 lineup (including iPhone 17, iPhone 17 Pro, iPhone 17 Pro Max) and the new iPhone Air — announced by Apple on Sept 9, 2025. Source: Apple Newsroom — https://www.apple.com/newsroom/2025/09/apple-debuts-iphone-17/
User: Multiply 500 by 12.
Assistant: Reasoning ....
Assistant: 6000
User: exit
Exiting chat. Goodbye!Vous pouvez voir les résultats avec leurs sources Web correspondantes. Lorsque vous lui demandez d’effectuer une tâche qui ne nécessite pas d’informations à jour, comme des calculs mathématiques ou l’écriture de code, l’agent répond directement sans aucune recherche sur le Web.
Remarque : L’agent de recherche Web est un agent simple à outil unique. Les systèmes agentiques avancés orchestrent plusieurs outils spécialisés et utilisent une mémoire efficace pour maintenir le contexte, planifier et résoudre des tâches plus complexes.
Conclusion
Dans cet article, j’ai expliqué comment fonctionne un agent IA et comment il étend les capacités d’un grand modèle de langage pour interagir avec son environnement, effectuer des actions et résoudre des tâches grâce à l’utilisation d’outils. J’ai également expliqué l’appel de fonction et comment il permet aux LLM d’appeler des outils. J’ai montré comment créer un schéma d’outil pour l’appel de fonction qui définit quand et comment un LLM doit appeler un outil pour effectuer une action. J’ai défini une fonction de recherche Web à l’aide de Tavily pour récupérer des informations sur le Web, puis j’ai montré étape par étape comment créer un agent de recherche Web en utilisant l’appel de fonction et GPT-5-mini comme LLM. Au final, nous avons construit un agent de recherche Web capable de récupérer des informations à jour sur Internet pour répondre aux requêtes des utilisateurs.
Consultez mon dépôt GitHub, Cours GenAI où j’ai publié plus de cours sur divers sujets liés à l’IA générative. Il comprend également un guide sur la construction d’un RAG agentique utilisant l’appel de fonction.
Contactez-moi via :
E-mail: [email protected]
Linkedin : https://www.linkedin.com/in/ayoola-olafenwa-003b901a9/
Références
https://platform.openai.com/docs/guides/function-calling?api-mode=responses
https://docs.tavily.com/documentation/api-reference/endpoint/search
