Créer des agents LangChain pour automatiser des tâches en Python

Configuration

Avant toute chose, configurons l’environnement de travail pour ce tutoriel.

Commencez par créer un nouvel environnement Conda :

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

Installez les packages LangChain et quelques bibliothèques nécessaires :

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Ajoutez le nouvel environnement Conda à Jupyter en tant que noyau :

$ ipython kernel install --user --name=langchain

Créez un fichier .env pour stocker les secrets tels que les clés API :

$ touch .env
$ vim .env  # Collez votre clé OPENAI

OPENAI_API_KEY='YOUR_KEY_HERE'

Récupérez votre clé API OpenAI depuis le fichier .env :

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Vérifiez que tout fonctionne en interrogeant GPT‑3.5 (modèle par défaut) d’OpenAI :

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Nous sommes prêts à commencer.

Qu’est‑ce qu’un agent LangChain ?

Prenons un moment pour réfléchir au cadre agent. Nous allons notamment voir en quoi il diffère du paradigme classique de la « chaîne » et quels sont ses composants. Comprendre pourquoi adopter une nouvelle approche de développement nous préparera à écrire le code.

Chaînes vs agents

La caractéristique clé des agents est leur capacité à choisir l’ordre optimal des actions pour résoudre un problème à partir d’un ensemble d’outils.

Par exemple, supposons que nous disposions de :

• Une API météo
• Un modèle ML pour recommander des vêtements
• L’API Strava pour des itinéraires à vélo
• Une base de données des préférences utilisateur
• Un modèle de reconnaissance d’images
• Un modèle de langage (génération de texte)

La résolution traditionnelle impliquerait d’utiliser une chaîne de certains de ces outils :

Chaîne 1 : recommandation vestimentaire selon la météo

1. Appeler l’API météo
2. Envoyer les données météo au modèle ML de vêtements
3. Générer des recommandations de tenues
4. Présenter les résultats à l’utilisateur

Chaîne 2 : suggestion d’itinéraires vélo selon la météo

1. Appeler l’API météo
2. Appeler l’API Strava pour les itinéraires populaires
3. Filtrer les itinéraires selon les conditions météo
4. Présenter les itinéraires adaptés à l’utilisateur

Chaîne 3 : analyse d’une photo de tenue

1. Recevoir la photo de la tenue de l’utilisateur
2. Utiliser un modèle de reconnaissance d’images pour identifier les pièces
3. Comparer avec la base des préférences utilisateur
4. Générer un retour via le modèle de génération de texte
5. Présenter l’analyse à l’utilisateur

Chaque chaîne résout un problème spécifique avec une séquence d’étapes prédéfinie et un sous‑ensemble d’outils. Elles ne peuvent pas s’adapter au‑delà de leur périmètre. Elles imposent aussi trois branches de développement séparées, peu efficaces en temps et en ressources.

Imaginez maintenant un système agentique avec accès à tous ces outils. Il pourrait :

1. Comprendre la requête ou le problème de l’utilisateur (en langage naturel via un modèle de langage)
2. Évaluer les outils pertinents (raisonnement)
3. Composer dynamiquement un workflow avec les outils les plus adaptés
4. Exécuter le workflow et l’ajuster en temps réel si nécessaire (action)
5. Évaluer le résultat et apprendre des interactions passées

Par exemple, si un utilisateur demande : « Que devrais‑je porter pour ma sortie vélo aujourd’hui ? », l’agent pourrait consulter l’API météo, analyser des itinéraires pertinents via Strava, recommander une tenue en tenant compte des préférences passées, puis générer une réponse personnalisée.

L’agent peut :

• Résoudre une grande variété de problèmes avec le même ensemble d’outils
• Créer des workflows sur mesure selon chaque situation
• Adapter son approche au contexte et aux besoins
• Apprendre des interactions pour s’améliorer

La capacité de LangChain à transformer des modèles de langage — qui, seuls, ne produisent que du texte — en moteurs de raisonnement capables d’exploiter des ressources externes pour agir est l’un de ses principaux atouts. En bref, LangChain permet de développer des agents autonomes puissants qui interagissent avec le monde réel.

Composants clés

Un agent LangChain se compose de plusieurs éléments, tels que des modèles de chat, des modèles d’invite (prompts), des outils externes et d’autres briques associées. Pour construire des agents efficaces, passons en revue chaque composant et son usage.

Modèles de langage et de chat

Créer un agent LangChain implique de nombreuses pièces. La première, la plus évidente, est un modèle de langage.

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

Les modèles de langage, comme GPT‑3.5 Turbo d’OpenAI, consomment et génèrent des chaînes de caractères. Souvent plus anciens, ils excellent pour répondre à des requêtes isolées.

Les modèles plus récents et plus puissants sont généralement des modèles de chat, capables de recevoir une séquence de messages en entrée et de renvoyer des messages de chat en sortie (plutôt que du texte brut) :

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

Autrement dit, les modèles de chat permettent une conversation en langage naturel. Dans l’exemple ci‑dessus, nous initialisons GPT‑4o‑mini avec un message système, puis une question utilisateur. Notez l’usage des classes SystemMessage et HumanMessage.

La variable output est un objet message, ce qui est attendu avec les modèles de chat :

type(output)

langchain_core.messages.ai.AIMessage

print(output.content)

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

Ils renvoient aussi des métadonnées utiles, accessibles en notation par points :

output.dict()

{'content': "Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!",
'additional_kwargs': {},
'response_metadata': {'token_usage': {'completion_tokens': 38,
  'prompt_tokens': 21,
  'total_tokens': 59},
 'model_name': 'gpt-4o-mini-2024-07-18',
 'system_fingerprint': 'fp_48196bc67a',
 'finish_reason': 'stop',
 'logprobs': None},
'type': 'ai',
'name': None,
'id': 'run-fde829bf-8f5f-4926-a1ed-ab53609ce03a-0',
'example': False,
'tool_calls': [],
'invalid_tool_calls': [],
'usage_metadata': {'input_tokens': 21,
 'output_tokens': 38,
 'total_tokens': 59}}

La plupart des agents utilisent des modèles de chat pour leurs connaissances mises à jour et leurs capacités conversationnelles. Cependant, pour des agents simples sans mémoire, des modèles de langage comme GPT‑3.5 peuvent suffire.

Modèles d’invite (prompts)

La manière la plus efficace d’interroger des modèles de langage ou de chat est d’utiliser des modèles d’invite. Ils structurent vos requêtes et injectent des variables dynamiquement, rendant vos interactions plus souples et réutilisables.

Dans LangChain, il existe plusieurs types de modèles, le plus basique étant la classe PromptTemplate. Elle peut être utilisée avec des modèles de langage (texte brut) :

from langchain_core.prompts import PromptTemplate
query_template = "Tell me about {book_name} by {author}."
prompt = PromptTemplate(input_variables=["book_name", "author"], template=query_template)
prompt.invoke({"book_name": "Song of Ice and Fire", "author": "GRRM"})

StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')

Créez une chaîne de caractères avec des espaces réservés pour les variables entre accolades. Passez ensuite ce modèle à la classe PromptTemplate avec les noms de variables pour construire votre prompt.

Appeler .invoke() avec des valeurs de variables permet d’apercevoir le prompt transmis au modèle.

Pour transmettre ce modèle d’invite à un modèle de langage, enchaînez‑le avec l’opérateur pipe :

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key)
# Create a chain
chain = prompt | llm
# Invoke the chain
output = chain.invoke({"book_name": "Deathly Hallows", "author": "J.K. Rowling"})
print(output[:100])

Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R

L’opérateur pipe (|) fait partie du LangChain Expression Language (LCEL), conçu pour chaîner plusieurs composants et outils LangChain.

type(chain)

langchain_core.runnables.base.RunnableSequence

Lorsque vous appliquez l’opérateur pipe à des objets LangChain, vous créez une instance de RunnableSequence. Une « runnable sequence » représente une chaîne d’objets supportant la méthode .invoke(), comme les modèles d’invite et les modèles de langage/chat.

Voyons maintenant une autre classe de modèle d’invite pour les modèles de chat :

from langchain_core.prompts import ChatPromptTemplate

Nous l’avons dit : les modèles de chat attendent une séquence de messages en entrée. L’entrée initiale est généralement un prompt système indiquant le comportement attendu. Avec la classe ChatPromptTemplate, on peut facilement créer des modèles de chat avec différentes « personnalités » :

chat_model = ChatOpenAI(api_key=api_key, model="gpt-4o-mini")
template = ChatPromptTemplate([
   ('system', 'You are a helpful AI bot. Your specialty is {specialty}.'),
   ('human', 'Explain the concept of {concept} based on your expertise.')
])

La classe attend une liste de messages rôlés en entrée. Chaque élément est un tuple (rôle, message) avec des variables entre accolades au besoin.

Une fois prêt, on crée des comportements variés avec le même opérateur pipe :

specialties = ["psychology", "economics", "politics"]
concept = "time"
# Call the model with different personalities
for s in specialties:
   chain = template | chat_model
   output = chain.invoke({"specialty": s, "concept": concept})
   print(output.content[:100], end="\n" + "-" * 25 + '\n')

Time is a complex and multifaceted concept that has been explored from various perspectives, includi
-------------------------
In economics, the concept of time is multifaceted and plays a crucial role in various theories and m
-------------------------
While my primary focus is on politics, I can provide a brief overview of the concept of time as it m
-------------------------

Outils

Nous avons mentionné que les agents choisissent une combinaison d’outils pour résoudre un problème donné, avec des LLM comme moteurs de raisonnement.

LangChain propose des intégrations avec des dizaines d’API et services pour permettre aux agents d’interagir avec le monde extérieur. La plupart sont disponibles dans le package langchain_community, d’autres dans langchain_core.

Par exemple, voici comment utiliser l’outil ArXiv pour récupérer des résumés d’articles sur divers sujets :

!pip install -Uq arxiv  # Install arXiv Python SDK

from langchain_community.tools import ArxivQueryRun
tool = ArxivQueryRun()
print(tool.invoke('Photosynthesis')[:250])

Published: 2019-08-28
Title: Photosynthesis on Exoplanets and Exomoons from Reflected Light
Authors: Manasvi Lingam, Abraham Loeb
Summary: Photosynthesis offers a convenient means of sustaining biospheres. We
quantify the constraints for photosynthes

Il existe une autre manière de charger des outils sans les importer par leur nom de classe :

from langchain_community.agent_toolkits.load_tools import load_tools
tools = load_tools(["arxiv", "dalle-image-generator"])

Ci‑dessus, nous chargeons simultanément les outils arXiv et le générateur d’images Dall‑E avec la fonction load_tools(). Les outils chargés de cette façon s’utilisent avec la même syntaxe :

# Call arXiv
print(tools[0].invoke("Kaggle")[:150])

Published: 2020-06-06
Title: StackOverflow vs Kaggle: A Study of Developer Discussions About Data Science
Authors: David Hin
Summary: Software develop

# Generate an image with DallE
output_image_url = tools[1].invoke("A magnificent chain in a cartoon.")
output_image_url

'https://oaidalleapiprodscus.blob.core.windows.net/...'

La fonction load_tools nécessite de connaître les noms de chaîne des classes d’outils, par exemple ArxivQueryRun versus « arxiv ». Pour vérifier rapidement le nom de chaîne d’un outil, utilisez get_all_tool_names :

from langchain_community.agent_toolkits.load_tools import get_all_tool_names
get_all_tool_names()[:10]

['sleep',
'wolfram-alpha',
'google-search',
'google-search-results-json',
'searx-search-results-json',
'bing-search',
'metaphor-search',
'ddg-search',
'google-lens',
'google-serper']

Notez que load_tools() n’est qu’un raccourci. Pour créer des agents, il est recommandé d’instancier les outils via leur constructeur afin de pouvoir les configurer finement selon leur comportement.

Guide pas à pas : créer des agents LangChain

Dans cette section, nous allons créer pas à pas des agents LangChain en nous appuyant sur les notions vues précédemment.

Dans les exemples qui suivent, nous construirons un agent capable d’expliquer n’importe quel sujet via trois médias : texte, image ou vidéo. Plus précisément, selon la question posée, l’agent choisira le format le plus pertinent.

C’est parti. Pensez à consulter la configuration de l’environnement au début de l’article. 

1. Définir les outils

Première étape après la configuration : définir les outils disponibles pour l’agent. Importons‑les :

from langchain_community.tools import WikipediaQueryRun  # pip install wikipedia
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_community.tools import YouTubeSearchTool  # pip install youtube_search
from langchain_community.tools.openai_dalle_image_generation import (
   OpenAIDALLEImageGenerationTool
)
from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper

Nous importons cinq classes :

• WikipediaAPIWrapper : configuration d’accès à l’API Wikipedia
• WikipediaQueryRun : génération de résumés de pages Wikipedia
• YouTubeSearchTool : recherche de vidéos YouTube sur des sujets
• DallEAPIWrapper : configuration d’accès au point de terminaison Dall‑E d’OpenAI
• OpenAIDALLEImageGenerationTool : génération d’images à partir de prompts

Lorsque l’utilisateur interroge notre agent, celui‑ci décide d’expliquer le sujet en texte via un article Wikipedia, de créer une image avec Dall‑E pour une compréhension visuelle, ou de proposer des vidéos YouTube pour aller plus loin.

Initialisons‑les, en commençant par l’outil Wikipedia :

wiki_api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=250)
wikipedia = WikipediaQueryRun(description="A tool to explain things in text format. Use this tool if you think the user’s asked concept is best explained through text.", api_wrapper=wiki_api_wrapper)
print(wikipedia.invoke("Mobius strip"))

Page: Möbius strip
Summary: In mathematics, a Möbius strip, Möbius band, or Möbius loop is a surface that can be formed by attaching the ends of a strip of paper together with a half-twist. As a mathematical object, it was discovered by Johann Benedi

Générateur d’images Dall‑E :

dalle_api_wrapper = DallEAPIWrapper(model="dall-e-3", size="1792x1024")
dalle = OpenAIDALLEImageGenerationTool(
   api_wrapper=dalle_api_wrapper, description="A tool to generate images. Use this tool if you think the user’s asked concept is best explained through an image."
)
output = dalle.invoke("A mountain bike illustration.")
print(output)

Outil de recherche YouTube :

youtube = YouTubeSearchTool(
   description="A tool to search YouTube videos. Use this tool if you think the user’s asked concept can be best explained by watching a video."
)
youtube.run("Oiling a bike's chain")

"['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu', 'https://www.youtube.com/watch?v=T6xyn1FGHiU&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu']"

Soignez particulièrement les descriptions d’outils. L’agent choisira lequel utiliser sur la base de ces descriptions. 

Plaçons maintenant les outils dans une liste :

tools = [wikipedia, dalle, youtube]

Nous pouvons déjà lier cet ensemble d’outils à un modèle de chat sans créer d’agent :

chat_model = ChatOpenAI(api_key=api_key)
model_with_tools = chat_model.bind_tools(tools)

Essayons d’appeler le modèle avec un message simple :

response = model_with_tools.invoke([HumanMessage("What's up?!")])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response: Hello! How can I assist you today?
Tools used in the response: []

La sortie montre qu’aucun outil lié n’a été utilisé pour générer la réponse. Posons maintenant une question qui force le modèle à aller au‑delà de ses données d’entraînement :

response = model_with_tools.invoke([
   HumanMessage("Can you generate an image of a mountain bike?")
])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response:
Tools used in the response: [{'name': 'openai_dalle', 'args': {'query': 'mountain bike'}, 'id': 'call_92GBfmsYtPi9TpGuIOFB1pG8', 'type': 'tool_call'}]

On voit qu’il n’y a pas de texte, mais Dall‑E d’OpenAI est mentionné. L’outil n’est pas encore appelé : le modèle suggère simplement de l’utiliser. Pour réellement l’appeler — passer à l’action — nous devons créer un agent.

2. Créer un agent simple

Après avoir défini le modèle et les outils, créons l’agent. LangChain propose une interface de haut niveau create_react_agent() depuis son package langgraph pour créer rapidement des agents ReAct (reason and act) :

from langgraph.prebuilt import create_react_agent
system_prompt = SystemMessage("You are a helpful bot named Chandler.")
agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)

Lors de l’initialisation avec un modèle de chat et une liste d’outils, nous passons un prompt système pour définir le comportement général. L’agent est prêt à recevoir des requêtes :

from pprint import pprint
response = agent.invoke({"messages": HumanMessage("What's up?")})
pprint(response["messages"])

[HumanMessage(content="What's up?", id='133b9380-cfe1-495a-98f7-b835c874bd57'),
AIMessage(content='Hello! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 112, 'total_tokens': 122}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-0a920c15-39b4-4857-ab51-6ea905575dba-0', usage_metadata={'input_tokens': 112, 'output_tokens': 10, 'total_tokens': 122})]

La réponse est logique : un simple texte sans appel d’outil. Posons maintenant une question plus ciblée :

response = agent.invoke({"messages": [
   HumanMessage('Explain how photosynthesis works.')
]})
print(len(response['messages']))

4

Cette fois, il y a quatre messages. Affichons les classes et le contenu :

for message in response['messages']:
   print(
       f"{message.__class__.__name__}: {message.content}"
   )  # Print message class name and its content
   print("-" * 20, end="\n")

HumanMessage: Explain how photosynthesis works.
--------------------
AIMessage:
--------------------
ToolMessage: Page: Photosynthesis
Summary: Photosynthesis ( FOH-tə-SINTH-ə-sis) is a system of biological processes by which photosynthetic organisms, such as most plants, algae, and cyanobacteria, convert light energy, typically from sunlight, into the chemical
--------------------
AIMessage: Photosynthesis is a biological process where photosynthetic organisms like plants, algae, and cyanobacteria convert light energy, usually from sunlight, into chemical energy. This process involves capturing light energy through pigments like chlorophyll in plant cells and using it to convert carbon dioxide and water into glucose and oxygen. Glucose serves as a source of energy for the plant, while oxygen is released into the atmosphere as a byproduct. Photosynthesis is crucial for the survival of plants and the balance of oxygen and carbon dioxide in the atmosphere.
--------------------

Parfait ! Le troisième message provient d’un appel d’outil — un résumé de page Wikipedia — et le dernier est la réponse du modèle de chat, qui s’appuie sur ce contenu.

Créons rapidement une fonction pour modulariser ces étapes :

def execute(agent, query):
   response = agent.invoke({'messages': [HumanMessage(query)]})
  
   for message in response['messages']:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
      
       print("-" * 20, end="\n")
  
   return response

3. Affiner le prompt système

Actualisons maintenant le prompt système avec des consignes détaillées sur le comportement attendu de l’agent :

system_prompt = SystemMessage(
   """
   You are a helpful bot named Chandler. Your task is to explain topics
   asked by the user via three mediums: text, image or video.
  
   If the asked topic is best explained in text format, use the Wikipedia tool.
   If the topic is best explained by showing a picture of it, generate an image
   of the topic using Dall-E image generator and print the image URL.
   Finally, if video is the best medium to explain the topic, conduct a YouTube search on it
   and return found video links.
   """
)

Recréons l’agent avec ce nouveau prompt système :

agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)
response = execute(agent, query='Explain the Fourier Series visually.')

HumanMessage: Explain the Fourier Series visually.
--------------------
AIMessage:
--------------------
ToolMessage: https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png?st=2024-08-09T18%3A36%3A46Z&se=2024-08-09T20%3A36%3A46Z&sp=r&sv=2024-08-04&sr=b&rscd=inline&rsct=image/png&skoid=d505667d-d6c1-4a0a-bac7-5c84a87759f8&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2024-08-09T17%3A56%3A46Z&ske=2024-08-10T17%3A56%3A46Z&sks=b&skv=2024-08-04&sig=Ly8F4jvakFeEtpZ/6jMliLq%2BG3Xs%2Bz1AmX1sL06%2BQ3U%3D
--------------------
AIMessage: Here is a visual representation of the Fourier Series:
![Fourier Series](https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png)
The Fourier Series is a way to represent a function as the sum of simple sine waves. It is used in many areas of mathematics and physics to analyze and understand periodic phenomena.
--------------------

Top ! D’après notre message (très explicite :), l’agent a choisi l’outil adapté. Voici l’image générée :

4. Ajouter de la mémoire aux agents

Pour l’instant, notre agent est sans état : il ne se souvient pas des échanges précédents :

response = execute(agent, query="What did I ask you in the previous query?")

HumanMessage: What did I ask you in the previous query?
--------------------
AIMessage: I'm sorry, I cannot remember the previous query as I don't have access to the conversation history. How can I assist you today?
--------------------

La manière la plus simple d’ajouter un historique de messages est d’utiliser la classe SqliteSaver de langgraph :

from langgraph.checkpoint.sqlite import SqliteSaver
memory = SqliteSaver.from_conn_string(':agent_history:')
agent = create_react_agent(chat_model, tools, checkpointer=memory, state_modifier=system_prompt)

Nous initialisons la mémoire avec la méthode .from_conn_string() de SqliteSaver, qui crée un fichier de base de données. Puis nous passons memory au paramètre checkpointer de create_react_agent().

Créons maintenant un dictionnaire de configuration :

config = {'configurable': {'thread_id': 'a1b2c3'}}

Ce dictionnaire définit un ID de fil de discussion pour distinguer les conversations, et il est transmis à la méthode .invoke() de notre agent. Mettons à jour la fonction execute() en conséquence :

def execute(agent, query, thread_id="a1b2c3"):
   config = {"configurable": {"thread_id": thread_id}}
   response = agent.invoke({'messages': [HumanMessage(query)]}, config=config)
   for message in response["messages"]:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
       print("-" * 20, end="\n")
   return response
Let’s test it again:
response = execute(
   agent, query="Explain how to oil a bike's chain using a YouTube video", thread_id="123"
)

HumanMessage: Explain how to oil a bike's chain using a YouTube video
--------------------
AIMessage:
--------------------
ToolMessage: ['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D', 'https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D']
--------------------
AIMessage: I found a couple of YouTube videos that explain how to oil a bike chain:
1. [Video 1: How to oil a bike chain](https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
2. [Video 2: Step-by-step guide on oiling a bike chain](https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
You can watch these videos to learn how to oil your bike's chain effectively.
--------------------

Demandons maintenant à l’agent de quoi il a été question auparavant :

response = execute(agent, query='What have I asked you so far?', thread_id='123')
print(response)

{'messages': [HumanMessage(content="Explain how to oil a bike's chain using a YouTube video",     id='8254142b-fb77-4958-8ad9-0a0283c6611a'), ...
]

Comme prévu, l’agent renvoie les messages précédents ! Il ne manque plus qu’une interface de chat à la ChatGPT pour obtenir un chatbot personnalisé.

Tendances et évolutions à venir

Tout au long de l’article, nous avons aperçu la trajectoire de LangChain en matière d’agents. Jusqu’à très récemment, LangChain s’appuyait surtout sur la classe AgentExecutor, progressivement remplacée par des agents langgraph.

Les agents LangChain « pure souche » sont très bien pour débuter, mais ils nécessitent plus de lignes de code que LangGraph pour un résultat équivalent. Et passé un certain niveau de complexité, le cadre AgentExecutor manque de flexibilité face à LangGraph pour construire des agents multi‑outils avancés.

C’est donc le bon moment pour surfer sur la vague et commencer directement avec LangGraph.

Nous vous recommandons également vivement d’utiliser LangSmith, devenu une brique essentielle de l’écosystème LangChain pour bâtir des applications LLM prêtes pour la production. Ses atouts clés :

• Débogage : LangSmith fournit des traces détaillées de l’exécution de votre agent pour faciliter l’identification et la correction des problèmes.
• Optimisation des performances : analysez l’usage des tokens, la latence et d’autres métriques pour améliorer l’efficacité de votre agent.
• Tests et évaluation : créez et gérez des jeux de tests pour évaluer rigoureusement la performance de votre agent sur divers scénarios.
• Supervision : en production, LangSmith offre un monitoring en temps réel pour suivre la performance et détecter rapidement les anomalies.

Voici comment démarrer avec LangSmith :

1. Créez un compte gratuit ici.
2. Définissez les variables d’environnement.

export LANGCHAIN_TRACING_V2="true"

export LANGCHAIN_API_KEY="..."

et vous êtes prêt ! Dès que vous commencez à interroger des modèles de langage/chat, LangSmith journalise diverses métriques pour chaque exécution :

Conclusion

Dans cet article, nous avons vu ce qui distingue les agents LangChain des chaînes et les briques nécessaires à leur construction. Nous avons d’abord présenté ce qu’est un agent et en quoi il diffère d’une chaîne plus traditionnelle en termes de flexibilité et de capacité de décision.

Nous avons ensuite passé en revue les composants clés pour bâtir un agent : modèles de chat, outils et modèles d’invite. Enfin, nous avons déroulé deux exemples pour créer des agents simples et avancés. Le traitement du langage naturel évolue en continu, et les agents LangChain sont à l’avant‑garde, ouvrant la voie à une IA plus intelligente et polyvalente.

Voici quelques ressources pour approfondir votre maîtrise de LangChain :

• Developing LLM Applications with LangChain Course 
• An Introduction to Prompt Engineering with LangChain 
• How to Build LLM Applications with LangChain Tutorial
• Building a GPT Model with Browsing Capabilities Using LangChain Tools
• LangChain vs LlamaIndex: A Detailed Comparison

Merci de votre lecture !