Agent IA avec LangChain : guide complet

Introduction

LangChain est devenu le framework de référence pour orchestrer des agents IA en Python. Ce guide couvre tout ce qu'il faut savoir pour construire un agent ia langchain fonctionnel : types d'agents, configuration, tools personnalisés et gestion de la mémoire.

Chaque section contient du code Python prêt à l'emploi. À la fin, vous aurez un agent capable de reasonner, d'utiliser des outils et de maintenir un contexte conversationnel.

Ce que vous allez apprendre : les 4 types d'agents LangChain, comment ajouter des tools, configurer la mémoire, et déployer en production.

Comment fonctionne un agent LangChain

Un agent LangChain n'est pas un modèle de langage. C'est un système de décision qui utilise un LLM comme cerveau pour choisir les actions à mener.

Quatre piliers le composent :

Pilier	Rôle
LLM	Moteur de raisonnement
Agent	Système de décision (quel outil invoquer)
Tools	Capacités d'action (recherche, calcul, API…)
Memory	Persistance du contexte conversationnel

1. Le LLM

Le modèle de langage est le cœur de l'agent. LangChain s'intègre avec OpenAI, Anthropic, Ollama et d'autres. Plus le modèle est capable, mieux l'agent raisonne.

2. L'Agent

L'agent reçoit les messages de l'utilisateur, le contexte disponible, et décide quelle action exécuter ensuite. Le type d'agent détermine le pattern de raisonnement.

3. Les Tools

Les tools sont les fonctions que l'agent peut appeler. LangChain fournit des dizaines de tools intégrés : recherche web, calculatrice, requêtes SQL, appels API…

4. La Memory

Sans mémoire, chaque conversation repart de zéro. La memory conserve l'historique des échanges pour que l'agent comprenne le contexte sur plusieurs tours.

Comprendre l'interaction de ces quatre piliers est essentiel pour architecturer des solutions robustes.

Les types d'agents LangChain

LangChain propose quatre types d'agents, chacun conçu pour un pattern de raisonnement différent.

Zero-shot React

L'agent le plus utilisé. Chaque action est décidée indépendamment, sans mémoire des échanges précédents. L'agent reçoit une description des tools disponibles et choisit le meilleur pour la tâche demandée.

Quand l'utiliser : tâches simples à un tour, automatisation de décisions uniques.

Conversational Agent

Variante orientée dialogue du zero-shot. Il maintient un buffer de messages pour les conversations multi-tours. Adapté aux chatbots et Q&A conversationnels.

Quand l'utiliser : dialogue multi-tours avec contexte partagé.

ReAct Agent

Combine raisonnement explicite et actions. À chaque étape, le LLM génère :

• Thought : la réflexion
• Action : la décision
• Observation : le résultat

Quand l'utiliser : tâches multi-étapes, exploration, raisonnement en chaîne.

Plan-and-Execute Agent

Pattern plus récent : l'agent planifie d'abord la séquence d'actions, puis les exécute une par une. Réduit les tokens sur les longues chaînes de tâches.

Quand l'utiliser : tâches complexes avec moins de latence importante.

Critère	Zero-shot	Conversational	ReAct	Plan-Execute
Mémoire	❌	✅	❌	❌
Raisonnement explicite	❌	❌	✅	Variable
Latence	Basse	Basse	Moyenne	Haute
Complexité max	Simple	Moyenne	Complexe	Très complexe

Setup et premier agent

Commençons par installer LangChain et créer un premier agent fonctionnel.

Prérequis

• Python 3.9+
• Clés API (OpenAI, Tavily…)

export OPENAI_API_KEY="sk-..."
export TAVILY_API_KEY="tvly-..."

pip install langchain langchain-openai langchain-community \
  langchain-core duckduckgo-search

Code complet — premier agent zero-shot

import os
from langchain.agents import AgentType, initialize_agent, load_tools
from langchain_openai import ChatOpenAI

# 1. Initialiser le LLM
llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0,
    api_key=os.getenv("OPENAI_API_KEY")
)

# 2. Charger les tools (recherche web via DuckDuckGo)
tools = load_tools(["ddg-search"])

# 3. Créer l'agent
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    handle_parsing_errors=True
)

# 4. Exécuter
result = agent.run("Quelles sont les tendances IA en 2026 ?")
print(result)

Output attendu :

> Entering new AgentExecutor chain...
I need to find current AI trends for 2026.
action: ddg-search
action_input: "AI trends 2026"
observation: Top AI trends in 2026 include...
I now know the final answer.
> Finished chain.

💡 verbose=True affiche le raisonnement de l'agent — indispensable pour débugger.

Ajouter des tools personnalisées

Les tools intégrés couvrent beaucoup de cas. Voici comment créer vos propres tools.

Créer un tool avec le décorateur @tool

from langchain_core.tools import tool

@tool
def temperature_converter(value: str, from_unit: str, to_unit: str) -> str:
    """Convertit une température entre unités.
    
    Args:
        value: Valeur numérique de la température
        from_unit: Unité source ('C', 'F', 'K')
        to_unit: Unité cible ('C', 'F', 'K')
    
    Returns:
        La température convertie arrondie à 2 décimales
    """
    valid_units = ['C', 'F', 'K']
    if from_unit not in valid_units or to_unit not in valid_units:
        return f"Unité non valide. Utiliser : {valid_units}"
    
    # Conversion en Celsius comme base
    if from_unit == 'C':
        celsius = float(value)
    elif from_unit == 'F':
        celsius = (float(value) - 32) * 5/9
    else:
        celsius = float(value) - 273.15
    
    # Conversion depuis Celsius vers cible
    if to_unit == 'C':
        result = celsius
    elif to_unit == 'F':
        result = celsius * 9/5 + 32
    else:
        result = celsius + 273.15
    
    return f"{value}°{from_unit} = {round(result, 2)}°{to_unit}"

# Tester
print(temperature_converter.invoke({"value": "100", "from_unit": "C", "to_unit": "F"}))
# → 100°C = 212.00°F

Enregistrer et utiliser le tool

from langchain.agents import AgentType, initialize_agent

custom_tools = [temperature_converter]
agent = initialize_agent(
    tools=custom_tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

result = agent.run("Convertis 37°C en Fahrenheit")
print(result)
# → 37°C = 98.60°F

Bonnes pratiques : soignez le docstring — il détermine quand et comment le LLM appelle le tool. Validez toujours les entrées. Retournez des types sérialisables (str ou dict).

La mémoire conversationnelle

Un agent sans mémoire réinitialise le contexte à chaque tour. Voici comment lui donner de la persistance.

ChatMessageHistory — la base

from langchain.memory import ChatMessageHistory
from langchain_core.messages import HumanMessage, AIMessage

history = ChatMessageHistory()
history.add_user_message("Mon entreprise s'appelle Acme Corp")
history.add_ai_message("Noté. Acme Corp — je m'en souviendrai.")

print(history.messages)
# [HumanMessage(content='Mon entreprise...'), AIMessage(content='Noté...')]

ConversationBufferMemory — tous les messages

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(
    return_messages=True,
    output_key="output",
    input_key="input"
)

memory.save_context(
    {"input": "Je veux un agent de veille IA"},
    {"output": "Un agent de veille IA vous alerterait sur les actualités. Voulez-vous une architecture ?"}
)

vars = memory.load_memory_variables({})
print(vars["history"])

ConversationSummaryMemory — pour les longues conversations

Quand la conversation s'allonge, garder chaque message coûte des tokens. ConversationSummaryMemory compresse l'historique en un résumé.

from langchain.memory import ConversationSummaryMemory

memory = ConversationSummaryMemory(
    llm=llm,  # Le LLM génère le résumé
    return_messages=True
)

memory.save_context({"input": "..."}, {"output": "..."})
vars = memory.load_memory_variables({})
print(vars["history"])

Même avec 50 échanges, la taille du contexte reste manageable grâce à la summarisation périodique.

Pattern complet — agent conversationnel avec tools + mémoire

import os
from langchain.agents import AgentType, initialize_agent
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain_core.tools import tool

# --- Tools ---
@tool
def search_news(query: str) -> str:
    """Recherche les dernières actualités sur un sujet.
    
    Args:
        query: Sujet de recherche
    
    Returns:
        Résumé des 5 dernières actualités
    """
    return f"Actualités récentes sur '{query}': ..."


# --- LLM ---
llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.3,
    api_key=os.getenv("OPENAI_API_KEY")
)

# --- Memory ---
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True,
    output_key="output"
)

# --- Agent ---
agent = initialize_agent(
    tools=[search_news],
    llm=llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    verbose=True,
    handle_parsing_errors=True
)

# --- Conversation ---
print(agent.run("Appelle mon entreprise Acme Corp"))
print(agent.run("Quelles sont les actualités IA pour Acme Corp ?"))
# L'agent utilise le contexte "Acme Corp" pour personnaliser la réponse.

🚀 Ce pattern est la base de la plupart des chatbots métier. L'agent conserve le contexte de marque, préférences et projets — sans base de données.

Outils complémentaires

LangChain ne s'arrête pas au code des agents. L'écosystème fournit des outils pour le monitoring et le déploiement.

Outil	Usage
LangSmith	Monitoring, tracing des appels, debug en production
LangServe	Déployer un agent comme API REST/GraphQL via FastAPI
LangChain Hub	Repository de prompts partagés par la communauté

export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="ls__..."
export LANGCHAIN_PROJECT="mon-projet"

Bonnes pratiques

• Commencer simple : un agent zero-shot avec 2 tools vaut mieux que 15 tools configurées d'emblée. Itérer en ajoutant des capacités progressivement.
• Gérer la context window : pour les longues conversations, basculez vers ConversationSummaryMemory dès que vous dépassez 10 échanges.
• Utiliser structured output : with_structured_output() limite les écarts de parsing.
• Tracker avec LangSmith : activez le tracing dès le développement pour identifier les loops et les appels inutiles.
• Prévoir les erreurs de parsing : handle_parsing_errors=True évite que l'agent se bloque sur un output mal formaté.
• Prévoir le retry : les appels API échouent. Wrappez les calls d'agent dans un decorator avec retry exponentiel.

FAQ

Qu'est-ce qu'un agent LangChain ?

Un agent LangChain est un système qui combine un LLM, des tools et une mémoire pour permettre à un modèle de langage de prendre des décisions, d'exécuter des actions et de maintenir un contexte conversationnel.

Comment ajouter des tools personnalisées ?

Utilisez le décorateur @tool depuis langchain_core.tools. Écrivez un docstring détaillé — il détermine 90% de la réussite de l'appel. Puis ajoutez le tool à la liste dans initialize_agent.

Quels sont les différents types d'agents ?

• ZERO_SHOT_REACT_DESCRIPTION : action unique, stateless
• CONVERSATIONAL_REACT_DESCRIPTION : dialogue avec mémoire
• CHAT_CONVERSATIONAL_REACT_DESCRIPTION : même chose en mode chat
• Plan-and-Execute : tâches multi-étapes

Comment gérer la mémoire d'un agent ?

ConversationBufferMemory conserve tous les messages — simple mais coûteux en tokens. ConversationSummaryMemory compresse via summarisation LLM — plus adapté aux conversations longues.

LangChain est-il adapté à la production ?

Oui. LangServe expose un agent comme API en quelques lignes. LangSmith offre le monitoring nécessaire. Les hébergeurs comme Vercel, Railway ou un VPS Linux fonctionnent bien. Pour la scalabilité horizontale, prévoyez un gestionnaire de tâches async (Celery, RQ).

Aller plus loin

Les agents LangChain s'inscrivent dans un écosystème plus large.

• Guide LangChain complet — chains, prompts, architecture générale
• Guide CrewAI — approche multi-agent avec rôles définis
• Guide OpenClaw — modèle d'agent modulaire par événements
• Créer un agent IA avec Python — patterns de base sans framework
• Outils agents IA — bases vectorielles, intégrations API, services externes