Auteur : Priya Sharma – Architecte d’API et Consultante en Intégration 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 façon d’interagir avec la technologie. Au cœur de cette transformation se trouvent les agents IA – des entités logicielles conçues pour effectuer des tâches en utilisant la puissance des Modèles de Langage de Grande Taille (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 public plus large.
En tant qu’architecte d’API et consultante en intégration 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 comme pour les particuliers. Ce guide pratique vous conduira à travers le processus de construction d’agents IA solides en utilisant l’API LangChain, depuis la compréhension des composants clés jusqu’à 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 quelle action entreprendre. Contrairement à un appel LLM simple 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 plan 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 (optionnel mais puissant) : Incorporer des retours pour améliorer les performances futures.
LangChain fournit l’infrastructure nécessaire pour construire ces agents sophistiqués. Il offre un moyen structuré de connecter les LLMs avec diverses sources de données et outils computationnels, leur permettant d’aller au-delà de la simple génération de texte. Considérez LangChain comme le 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 clés :
- Modèle de Langage de Grande Taille (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 sort des décisions.
- Outils : Fonctions que l’agent peut appeler pour interagir avec des systèmes externes ou effectuer des calculs spécifiques. Des exemples incluent la recherche sur le web, les requêtes à une base de données, l’appel d’une calculatrice ou l’interaction avec une API personnalisée.
- Kit d’Outils : Collections d’outils liés conçus pour des cas d’utilisation spécifiques (par exemple, un « kit d’outils Wikipedia » ou un « kit d’outils agent CSV »).
- Exécuteur d’Agent : Le runtime qui orchestré 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 plus approfondi.
- Mémoire : Permet à l’agent de conserver des informations des interactions précédentes, favorisant des conversations cohérentes et une prise de décision contextuelle.
- Modèles de Prompt : 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 du code d’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 (par exemple, 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 Basique avec le LLM
Pour confirmer votre configuration, faisons un simple appel LLM :
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
llm = ChatOpenAI(model="gpt-4o", temperature=0) # Utilisation d'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 basique confirme que votre connexion LLM fonctionne. Maintenant, donnons à notre LLM des outils.
Création d’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 simplifie la définition des outils. Chaque outil doit avoir un nom clair, une description et une fonction qui exécute l’action.
Exemple : Un Outil de Calculatrice Simple
Créons un outil qui peut effectuer des calculs arithmétiques de base. Bien que les LLMs puissent faire des mathématiques simples, les outils externes sont plus fiables pour les 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 exemple, '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"))Notez le décorateur @tool. Cela convertit automatiquement votre fonction en un outil LangChain. La docstring est cruciale car elle sert de description à 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éder à des informations à jour. Un outil de recherche web est fondamental. Nous allons utiliser Tavily, une API de recherche spécialement conçue pour RAG (Retrieval Augmented Generation) et les cas d’utilisation d’agents.
Tout d’abord, installez Tavily et définissez votre clé API dans votre fichier .env :
pip install tavily-pythonTAVILY_API_KEY="your_tavily_api_key_here"Ensuite, chargez-la :
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éer l'outil de recherche Tavily
search = TavilySearchResults(max_results=3) # Obtenez les 3 meilleurs résultats
# Vous pouvez également personnaliser le nom et la description si nécessaire
# search.name = "web_search"
# search.description = "Recherche d'informations sur le web."
# Tester l'outil de recherche
print(search.invoke("tutoriel agent LangChain"))En définissant ces outils, nous donnons à notre agent les capacités dont il a besoin 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 fonctions d’OpenAI.
Étapes de Construction de l’Agent
- Définir votre LLM : Le cerveau de votre agent.
- Définir vos Outils : Les capacités possédées par votre agent.
- Créer un Modèle de Prompt : Guider le LLM sur son comportement.
- Créer l’Agent : Combiner LLM, outils et prompt.
- Créer l’Exécuteur d’Agent : Le runtime 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 retourne le résultat.
L'entrée doit être une chaîne contenant une expression mathématique valide, par exemple, '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 prompt
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 de l'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": "Quel 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 l’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. Cela est extrêmement utile pour le débogage et la compréhension du raisonnement de votre agent.
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 une 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 véritablement intelligent a besoin de mémoire pour maintenir le contexte à travers plusieurs tours d’une conversation. LangChain fournit différents 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.
- Efficiency : Évite de répéter des informations ou de demander des éclaircissements 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 (comme auparavant)
llm = ChatOpenAI(model="gpt-4o", temperature=0)
@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 exemple, '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 le placeholder `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 de l'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 qu'en est-il de la population de la capitale de la France ?")
result3 = agent_executor.invoke({"input": "Et qu'en est-il de la population de la capitale de la France ?"})
print("Agent :", result3["output"])Dans cet exemple, l’agent se souvient de « Espagne » lors du premier tour, et de « la capitale de la France » lors du troisième, lui permettant de fournir des réponses pertinentes sans avoir besoin de redire explicitement le pays. Le memory_key="chat_history" assure 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
- Entrer au cœur des modèles de conception d’API efficaces
- APIs de streaming pour agents AI
- Qdrant vs FAISS : Lequel pour les startups
🕒 Published: