Auteur : Priya Sharma – Architecte API et Consultante en Intégration de l’IA
La capacité de créer des systèmes intelligents capables de comprendre des instructions, de raisonner et d’agir de manière autonome transforme notre interaction avec la technologie. Au cœur de cette transformation se trouvent des agents IA – des entités logicielles conçues pour effectuer des tâches en utilisant la puissance des Large Language Models (LLMs) et des outils externes. Bien que le concept puisse sembler complexe, des frameworks comme LangChain ont considérablement simplifié le processus de développement, rendant la création d’agents accessible à un plus large public.
En tant qu’architecte API et consultante en intégration de l’IA, j’ai vu de mes propres yeux l’incroyable potentiel des agents IA bien conçus. Ils peuvent automatiser des flux de travail complexes, fournir une assistance personnalisée et débloquer de nouvelles capacités pour les entreprises et les particuliers. Ce guide pratique vous guidera à travers le processus de construction d’agents IA solides en utilisant l’API LangChain, de la compréhension des composants principaux à l’implémentation d’exemples pratiques et concrets. À la fin, vous aurez une base solide pour concevoir et déployer vos propres agents intelligents, prêts à relever une multitude de défis.
Comprendre les Agents IA et le Rôle de LangChain
Avant d’explorer le code, clarifions ce qu’est un agent IA et pourquoi LangChain est un outil indispensable pour leur construction. Un agent IA est un système qui utilise un LLM comme son « cerveau » pour décider quelles actions entreprendre. Contrairement à un simple appel LLM qui génère une seule réponse, un agent peut s’engager dans un processus de raisonnement en plusieurs étapes :
- Percevoir : Comprendre l’entrée de l’utilisateur ou l’état actuel.
- Raisonner : Déterminer le meilleur cours d’action en fonction de sa compréhension et des outils disponibles.
- Agir : Exécuter une ou plusieurs actions en utilisant des outils externes.
- Apprendre (facultatif mais puissant) : Incorporer des retours pour améliorer la performance future.
LangChain fournit le cadre nécessaire pour construire ces agents sophistiqués. Il offre une méthode structurée pour connecter les LLM à diverses sources de données et outils informatiques, leur permettant d’aller au-delà de la simple génération de texte. Pensez à LangChain comme au système d’exploitation de votre agent IA, fournissant le cadre pour son intelligence, sa mémoire et sa capacité à interagir avec le monde.
Composants Clés d’un Agent LangChain
Pour construire un agent avec LangChain, vous travaillerez principalement avec ces composants essentiels :
- Large Language Model (LLM) : Le noyau d’intelligence. Cela pourrait être les modèles GPT d’OpenAI, Claude d’Anthropic, ou des alternatives open-source. Le LLM traite les entrées, raisonne et produit des décisions.
- Outils : Fonctions que l’agent peut appeler pour interagir avec des systèmes externes ou effectuer des calculs spécifiques. Les exemples incluent la recherche sur Internet, l’interrogation d’une base de données, l’appel d’une calculatrice ou l’interaction avec une API personnalisée.
- Kit d’outils : Collections d’outils connexes conçus pour des cas d’utilisation spécifiques (ex : un « kit d’outils Wikipedia » ou un « kit d’outils agent CSV »).
- Exécutant de l’Agent : L’environnement d’exécution qui orchestre les actions de l’agent. Il prend les décisions du LLM, exécute les outils choisis et renvoie les résultats au LLM pour un raisonnement ultérieur.
- Mémoire : Permet à l’agent de conserver des informations des interactions précédentes, permettant des conversations cohérentes en plusieurs tours et une prise de décision contextuelle.
- Modèles d’Invite : Définissent comment l’entrée utilisateur et d’autres informations sont formatées pour le LLM, guidant son processus de raisonnement.
Configurer Votre Environnement et Premiers Pas
Avant d’écrire le code de l’agent, assurez-vous que votre environnement Python est prêt. Vous aurez besoin de Python 3.8+ et de la bibliothèque LangChain, ainsi que de tout fournisseur de LLM que vous comptez utiliser.
Installation
Installez LangChain et un fournisseur de LLM (ex : OpenAI) :
pip install langchain langchain-openai
pip install python-dotenv # Pour gérer les clés API en toute sécuritéGérez vos clés API en toute sécurité. Créez un fichier .env dans la racine de votre projet :
OPENAI_API_KEY="your_openai_api_key_here"Ensuite, chargez-le dans votre script Python :
import os
from dotenv import load_dotenv
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")Interaction de Base avec le LLM
Pour confirmer votre configuration, faisons un simple appel au LLM :
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
llm = ChatOpenAI(model="gpt-4o", temperature=0) # Utilisant un modèle puissant avec une sortie déterministe
messages = [
HumanMessage(content="Quelle est la capitale de la France ?")
]
response = llm.invoke(messages)
print(response.content)Cette interaction de base confirme que votre connexion LLM fonctionne. Maintenant, équipons notre LLM avec des outils.
Créer des Outils pour Votre Agent IA
Les outils sont les mains et les pieds de l’agent, lui permettant d’interagir avec le monde extérieur. LangChain rend la définition des outils simple. Chaque outil doit avoir un nom clair, une description, et une fonction qui effectue l’action.
Exemple : Un Outil Calculatrice Simple
Créons un outil qui peut effectuer des arithmétiques de base. Bien que les LLM puissent faire des mathématiques simples, les outils externes sont plus fiables pour des calculs complexes.
from langchain.tools import tool
@tool
def calculator(expression: str) -> str:
"""Évalue une expression mathématique et retourne le résultat.
L'entrée doit être une chaîne contenant une expression mathématique valide, par ex., '2 + 2' ou '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Erreur lors de l'évaluation de l'expression : {e}"
# Vous pouvez tester l'outil directement
print(calculator.invoke("10 * 5 + 3"))Remarquez le décorateur @tool. Cela convertit automatiquement votre fonction en un outil LangChain. La docstring est cruciale car elle sert de description de l’outil, que le LLM utilise pour comprendre quand et comment l’utiliser.
Exemple : Un Outil de Recherche Web (Utilisant Tavily)
La plupart des agents puissants ont besoin d’accès à des informations à jour. Un outil de recherche web est fondamental. Nous utiliserons Tavily, une API de recherche spécifiquement conçue pour RAG (Retrieval Augmented Generation) et les cas d’utilisation des agents.
Tout d’abord, installez Tavily et configurez votre clé API dans votre fichier .env :
pip install tavily-pythonTAVILY_API_KEY="your_tavily_api_key_here"Ensuite, chargez-le :
import os
from dotenv import load_dotenv
from langchain_community.tools.tavily_search import TavilySearchResults
load_dotenv()
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# Créez l'outil de recherche Tavily
search = TavilySearchResults(max_results=3) # Obtenir les 3 meilleurs résultats
# Vous pouvez également personnaliser le nom et la description si nécessaire
# search.name = "web_search"
# search.description = "Recherche sur le web pour des informations."
# Testez l'outil de recherche
print(search.invoke("tutoriel sur l'agent LangChain"))En définissant ces outils, nous donnons à notre agent les capacités nécessaires pour étendre ses connaissances au-delà de ses données d’entraînement et effectuer des calculs avec précision.
Construire Votre Premier Agent LangChain
Avec notre LLM et nos outils prêts, nous pouvons maintenant assembler notre premier agent LangChain. Nous utiliserons la méthode « create_openai_functions_agent », qui est un moyen pratique de construire des agents utilisant les capacités d’appel de fonction d’OpenAI.
Étapes de Construction de l’Agent
- Définissez votre LLM : Le cerveau de votre agent.
- Définissez vos Outils : Les capacités que possède votre agent.
- Créez un Modèle d’Invite : Guider le LLM sur son comportement.
- Créez l’Agent : Combinez LLM, outils et invite.
- Créez l’Exécutant de l’Agent : L’environnement d’exécution qui exécute les décisions de l’agent.
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
# Charger les variables d'environnement
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# 1. Définir LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)
# 2. Définir les outils
@tool
def calculator(expression: str) -> str:
"""Évalue une expression mathématique et renvoie le résultat.
L'entrée doit être une chaîne contenant une expression mathématique valide, par ex., '2 + 2' ou '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Erreur lors de l'évaluation de l'expression : {e}"
search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Recherche sur le web des informations actuelles sur une requête donnée."
tools = [calculator, search]
# 3. Créer un modèle de prompts
prompt = ChatPromptTemplate.from_messages(
[
("system", "Vous êtes un assistant AI utile. Répondez aux questions aussi précisément que possible."),
MessagesPlaceholder(variable_name="chat_history"),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
# 4. Créer l'agent
agent = create_openai_functions_agent(llm, tools, prompt)
# 5. Créer l'exécuteur d'agent
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Exécuter l'agent
# print("--- Exécution de l'agent 1 (Calcul simple) ---")
# result1 = agent_executor.invoke({"input": "Quelle est 12345 * 6789 ?", "chat_history": []})
# print(result1["output"])
# print("\n--- Exécution de l'agent 2 (Recherche web) ---")
# result2 = agent_executor.invoke({"input": "Quelle est la capitale du Portugal et quelle est sa population actuelle ?", "chat_history": []})
# print(result2["output"])
# print("\n--- Exécution de l'agent 3 (Combiné) ---")
# result3 = agent_executor.invoke({"input": "Quelle est la racine carrée de 81 et qui a inventé le World Wide Web ?", "chat_history": []})
# print(result3["output"])Lorsque vous définissez verbose=True dans le AgentExecutor, vous verrez le processus de réflexion de l’agent : quels outils il considère, lequel il sélectionne, l’entrée qu’il fournit à l’outil, et la sortie de l’outil. C’est extrêmement utile pour le débogage et pour comprendre comment votre agent raisonne.
Comprendre le modèle de prompt
system: Définit la personnalité générale et les instructions pour l’agent.MessagesPlaceholder(variable_name="chat_history"): C’est ici que les tours de conversation précédents seront insérés, permettant la mémoire.human: L’entrée actuelle de l’utilisateur.MessagesPlaceholder(variable_name="agent_scratchpad"): C’est ici que le processus de réflexion interne de l’agent et les sorties des outils sont stockés pendant une seule invocation, permettant au LLM de raisonner étape par étape.
Ajouter de la mémoire et de l’état à votre agent AI
Un agent vraiment intelligent a besoin de mémoire pour maintenir le contexte au cours de plusieurs tours de conversation. LangChain propose divers types de mémoire, permettant à votre agent de se souvenir des interactions passées.
Pourquoi la mémoire est-elle importante
- Cohérence : Les agents peuvent se référer à des déclarations et des questions précédentes.
- Personnalisation : Les agents peuvent se souvenir des préférences de l’utilisateur ou des interactions passées.
- Efficacité : Évite de répéter des informations ou de demander des clarifications sur des détails déjà fournis.
Implémentation de ConversationBufferMemory
ConversationBufferMemory est un type de mémoire simple mais efficace qui stocke tous les messages précédents directement.
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferMemory # Importer la mémoire
# Charger les variables d'environnement
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# LLM et outils (identiques à avant)
llm = ChatOpenAI(model="gpt-4o", temperature=0)
@tool
def calculator(expression: str) -> str:
"""Évalue une expression mathématique et renvoie le résultat.
L'entrée doit être une chaîne contenant une expression mathématique valide, par ex., '2 + 2' ou '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Erreur lors de l'évaluation de l'expression : {e}"
search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Recherche sur le web des informations actuelles sur une requête donnée."
tools = [calculator, search]
# Créer un modèle de prompt (notez l'espace réservé `chat_history`)
prompt = ChatPromptTemplate.from_messages(
[
("system", "Vous êtes un assistant AI utile. Souvenez-vous des interactions précédentes et répondez aux questions aussi précisément que possible."),
MessagesPlaceholder(variable_name="chat_history"), # C'est ici que la mémoire sera injectée
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
# Initialiser la mémoire
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
# Créer l'agent
agent = create_openai_functions_agent(llm, tools, prompt)
# Créer l'exécuteur d'agent, en passant la mémoire
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)
# Exécuter l'agent avec mémoire
print("--- Exécution de l'agent avec mémoire ---")
print("\nUtilisateur : Quelle est la capitale de l'Espagne ?")
result1 = agent_executor.invoke({"input": "Quelle est la capitale de l'Espagne ?"})
print("Agent :", result1["output"])
print("\nUtilisateur : Quelle est sa population ?")
result2 = agent_executor.invoke({"input": "Quelle est sa population ?"})
print("Agent :", result2["output"])
print("\nUtilisateur : Et quelle est la population de la capitale de la France ?")
result3 = agent_executor.invoke({"input": "Et quelle est la population de la capitale de la France ?"})
print("Agent :", result3["output"])Dans cet exemple, l’agent se souvient de « Espagne » depuis le premier tour, et de « capitale de la France » depuis le troisième, lui permettant de fournir des réponses pertinentes sans avoir besoin de reformuler explicitement le pays. Le memory_key="chat_history" garantit que le contenu de la mémoire est correctement mappé au MessagesPlaceholder(variable_name="chat_history") dans notre modèle de prompt.
Autres types de mémoire
Articles connexes
- Au cœur des modèles de conception d’API efficaces
- API de streaming pour agents AI
- Qdrant vs FAISS : Lequel pour les startups
🕒 Published: