En 2026, LangChain s’est imposé comme le framework de référence pour construire des agents IA en Python et JavaScript. Avec plus de 90 000 étoiles sur GitHub et une adoption massive par des entreprises comme Notion, Replit ou Klarna, il est devenu le point d’entrée incontournable pour quiconque veut aller au-delà de simples appels API vers un LLM.
Ce guide vous accompagne pas à pas, de l’installation à un agent opérationnel capable de naviguer sur le web, appeler des APIs externes et retenir le contexte des conversations. Durée estimée : 30 à 60 minutes pour un développeur Python intermédiaire.
Prérequis : Python 3.11+, une clé API OpenAI ou Anthropic, et un terminal.
Commencez par créer un environnement virtuel isolé pour ne pas polluer votre système.
python -m venv .venv
source .venv/bin/activate # Linux/Mac
# .venv\Scripts\activate # Windows
pip install langchain langchain-openai langchain-community python-dotenv
pip install duckduckgo-search # pour les tools de recherche webCréez ensuite un fichier .env à la racine du projet :
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-... # optionnel si vous préférez ClaudeChargez ces variables au démarrage de votre script :
from dotenv import load_dotenv
load_dotenv()Avant de coder le premier agent, il est essentiel de maîtriser les briques de base. LangChain s’articule autour de six abstractions clés.
LangChain distingue deux interfaces pour interagir avec un modèle :
system, user, assistant). C’est l’interface moderne, compatible avec GPT-5, Claude 3.5, Gemini 2.0, etc.from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)
response = llm.invoke("Explique le machine learning en 3 phrases.")
print(response.content)Les PromptTemplate permettent de structurer vos prompts avec des variables dynamiques. Ils rendent le code réutilisable et testable.
from langchain_core.prompts import ChatPromptTemplate
prompt = ChatPromptTemplate.from_messages([
("system", "Tu es un expert en {domaine}. Réponds toujours en français."),
("human", "{question}")
])
# La chaîne pipe | compose les éléments
chain = prompt | llm
result = chain.invoke({"domaine": "finance d'entreprise", "question": "Qu'est-ce qu'un ratio d'endettement ?"})
print(result.content)Une Chain est une séquence d’étapes connectées. L’opérateur | de LangChain (LCEL — LangChain Expression Language) permet de les composer de manière déclarative.
from langchain_core.output_parsers import StrOutputParser
# Chain simple : prompt → LLM → parser texte
chain = prompt | llm | StrOutputParser()
# Chain séquentielle : la sortie d'une chain devient l'entrée de la suivante
resume_prompt = ChatPromptTemplate.from_messages([
("system", "Résume le texte suivant en 3 bullet points."),
("human", "{texte}")
])
chain_complete = (
chain
| (lambda x: {"texte": x})
| resume_prompt
| llm
| StrOutputParser()
)La mémoire permet à votre agent de retenir le contexte des échanges précédents. LangChain propose plusieurs types :
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI
from langchain.chains import ConversationChain
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.5)
memory = ConversationBufferMemory(return_messages=True)
conversation = ConversationChain(llm=llm, memory=memory)
print(conversation.predict(input="Bonjour, je m'appelle Marie."))
print(conversation.predict(input="Quel est mon prénom ?"))
# L'agent se souvient : "Votre prénom est Marie."Les Tools sont des fonctions que l’agent peut appeler pour interagir avec le monde extérieur : recherche web, calculs, bases de données, APIs tierces. Chaque tool a un nom, une description, et une fonction Python associée.
from langchain_core.tools import tool
@tool
def calculer_tva(montant_ht: float) -> str:
"""Calcule le montant TTC à partir d'un montant HT en euros (TVA 20%)."""
tva = montant_ht * 0.20
ttc = montant_ht + tva
return f"Montant HT : {montant_ht}€ | TVA : {tva:.2f}€ | TTC : {ttc:.2f}€"Un Agent est un LLM qui décide lui-même quels tools appeler et dans quel ordre, en fonction de l’objectif donné. LangChain supporte plusieurs stratégies :
Thought) et action (Action) jusqu’à avoir la réponse. Compatible avec tous les LLMs.Voici un agent complet qui peut rechercher sur le web et résumer les résultats. Code commenté ligne par ligne.
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.tools import tool
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.prompts import PromptTemplate
load_dotenv()
# 1. Initialiser le LLM
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.2)
# 2. Définir les tools disponibles
search = DuckDuckGoSearchRun()
search.name = "recherche_web"
search.description = "Recherche des informations récentes sur internet. Utilise cet outil pour répondre à des questions sur l'actualité ou des faits précis."
@tool
def calculatrice(expression: str) -> str:
"""Évalue une expression mathématique simple. Ex: '150 * 1.2' ou '(500 + 300) / 4'"""
try:
# eval limité aux opérations numériques
result = eval(expression, {"__builtins__": {}}, {})
return str(result)
except Exception as e:
return f"Erreur de calcul : {e}"
tools = [search, calculatrice]
# 3. Prompt ReAct standard
prompt_template = """Réponds à la question suivante en utilisant les outils disponibles si nécessaire.
Tu as accès aux outils suivants :
{tools}
Format obligatoire :
Question: la question d'entrée
Thought: réfléchis à ce que tu dois faire
Action: le nom de l'outil à utiliser, parmi [{tool_names}]
Action Input: l'entrée pour l'outil
Observation: le résultat de l'outil
... (répète Thought/Action/Observation si nécessaire)
Thought: J'ai maintenant la réponse finale
Final Answer: la réponse finale en français
Question: {input}
Thought: {agent_scratchpad}"""
prompt = PromptTemplate.from_template(prompt_template)
# 4. Créer l'agent ReAct
agent = create_react_agent(llm=llm, tools=tools, prompt=prompt)
# 5. Créer l'executor (gère la boucle d'itération)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True, # affiche le raisonnement step-by-step
max_iterations=5, # évite les boucles infinies
handle_parsing_errors=True
)
# 6. Exécuter
result = agent_executor.invoke({
"input": "Quels sont les derniers modèles LLM sortis en 2025 ? Donne-moi aussi le coût de 10 000 tokens à 0.15$ pour mille tokens."
})
print(result["output"])Ce second exemple intègre une mémoire de conversation et un appel API réel (ici : récupération du cours d’une action via l’API Yahoo Finance).
from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
import requests
llm = ChatOpenAI(model="gpt-4o", temperature=0.1)
# Tool : appel API externe (cours bourse)
@tool
def get_cours_action(ticker: str) -> str:
"""Récupère le cours actuel d'une action en bourse. Exemple: 'AAPL', 'MSFT', 'MC.PA'"""
try:
url = f"https://query1.finance.yahoo.com/v8/finance/chart/{ticker}?interval=1d&range=1d"
headers = {"User-Agent": "Mozilla/5.0"}
resp = requests.get(url, headers=headers, timeout=5)
data = resp.json()
price = data["chart"]["result"][0]["meta"]["regularMarketPrice"]
currency = data["chart"]["result"][0]["meta"]["currency"]
return f"{ticker}: {price} {currency}"
except Exception as e:
return f"Impossible de récupérer le cours de {ticker} : {e}"
tools = [get_cours_action]
# Prompt avec placeholder pour l'historique
prompt = ChatPromptTemplate.from_messages([
("system", "Tu es un assistant financier expert. Utilise les outils disponibles pour répondre avec précision. Réponds en français."),
MessagesPlaceholder(variable_name="chat_history"),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
])
# Agent OpenAI Tools (plus fiable que ReAct pour les appels structurés)
agent = create_openai_tools_agent(llm=llm, tools=tools, prompt=prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Gestion de l'historique par session
store = {}
def get_session_history(session_id: str) -> ChatMessageHistory:
if session_id not in store:
store[session_id] = ChatMessageHistory()
return store[session_id]
agent_with_memory = RunnableWithMessageHistory(
executor,
get_session_history,
input_messages_key="input",
history_messages_key="chat_history",
)
config = {"configurable": {"session_id": "session_001"}}
# Test de la mémoire persistante
print(agent_with_memory.invoke({"input": "Quel est le cours d'Apple ?"}, config=config)["output"])
print(agent_with_memory.invoke({"input": "Et Microsoft ?"}, config=config)["output"])
print(agent_with_memory.invoke({"input": "Compare les deux prix que tu viens de m'indiquer."}, config=config)["output"])
# L'agent se souvient des deux cours précédents sans les rechercherLangGraph est le complément naturel de LangChain pour les workflows complexes. La distinction est nette en pratique.
| Critère | LangChain | LangGraph |
|---|---|---|
| Usage principal | Agent avec boucle libre | Workflow multi-étapes contrôlé |
| Structure | Linéaire ou dynamique | Graphe d’états (nodes + edges) |
| Contrôle du flux | Le LLM décide | Vous définissez les transitions |
| Débogage | Limité | Visualisation du graphe complète |
| Cas d’usage idéal | Agent Q&R, chatbot, recherche | Pipeline multi-agents, approbation humaine, processus métier |
Règle simple : si votre workflow a des branchements conditionnels, des étapes de validation humaine, ou plusieurs agents spécialisés qui collaborent, utilisez LangGraph. Pour un agent simple qui répond à des questions, LangChain suffit.
Un agent en production nécessite une API HTTP. FastAPI est le choix naturel en Python.
# main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from agent import agent_executor # votre agent défini ailleurs
app = FastAPI(title="Agent IA - AutomateIA")
class QueryRequest(BaseModel):
question: str
session_id: str = "default"
@app.post("/agent/query")
async def query_agent(request: QueryRequest):
try:
result = agent_executor.invoke({"input": request.question})
return {"response": result["output"], "session_id": request.session_id}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.get("/health")
async def health():
return {"status": "ok"}FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]Estimation des coûts pour une PME : avec GPT-5-mini à 0,15$/million de tokens en input et 0,60$ en output, un agent qui traite 500 requêtes/jour avec une moyenne de 2 000 tokens par échange coûte environ 3 à 8€/mois. GPT-5 classique multiplierait ce coût par 15 à 20.
Un agent configuré avec un tool de recherche web scrape quotidiennement les actualités de vos 5 concurrents principaux, les filtre par pertinence, et envoie un résumé synthétique chaque matin par email. Temps de développement : 2 jours. Économie estimée : 3h/semaine d’une assistante commerciale.
Couplé à votre CRM via une API, l’agent analyse les informations d’un prospect entrant (secteur, taille, problème exprimé), pose des questions de qualification via votre formulaire web en conversation dynamique, et attribue un score avant de créer la fiche dans HubSpot ou Salesforce. Taux de qualification amélioré de 30 à 40% selon les retours terrain.
L’agent reçoit des CVs en PDF, les analyse selon vos critères de recrutement, génère une fiche d’évaluation structurée et classe les candidats par adéquation au poste. Intégré à Notion ou Airtable pour le suivi. Traitement de 100 CVs en 20 minutes au lieu de 2 jours.
| Framework | Point fort | Limite |
|---|---|---|
| LangChain | Écosystème complet, 700+ intégrations | Abstraction parfois complexe, breaking changes fréquents |
| LlamaIndex | Excellent pour RAG et bases de connaissances | Moins adapté aux agents purs |
| Haystack | Robuste pour la production enterprise | Courbe d’apprentissage plus raide |
| AutoGen (Microsoft) | Multi-agents conversationnels puissants | Plus verbeux, moins d’intégrations |
| CrewAI | Orchestration d’équipes d’agents simple | Jeune, moins stable en prod |
Pour une PME qui démarre, LangChain reste le meilleur point d’entrée grâce à sa documentation, sa communauté et le nombre d’exemples disponibles. LlamaIndex complète parfaitement LangChain si votre cas d’usage principal est la recherche dans des documents internes (contrats, notices, FAQ).
1. Oublier de limiter les itérations. Sans max_iterations, un agent peut tourner en boucle indéfiniment et consommer des centaines d’appels API. Fixez toujours une limite raisonnable (5 à 10 selon la complexité).
2. Prompts trop vagues pour les tools. La description d’un tool est lue par le LLM pour décider quand l’appeler. Une description imprécise entraîne des usages incorrects ou des non-usages. Soyez explicite : mentionnez les cas d’usage, le format d’entrée attendu, et un exemple.
3. Stocker des secrets dans le code. N’écrivez jamais de clés API directement dans vos scripts. Utilisez toujours un fichier .env avec python-dotenv, ou des variables d’environnement injectées par votre orchestrateur Docker/Kubernetes.
4. Ignorer les coûts en développement. verbose=True pendant les tests génère beaucoup d’appels. Utilisez GPT-5-mini ou un modèle local (Ollama + Mistral) pour le développement, et réservez GPT-5 pour la production si nécessaire.
5. Négliger la gestion des erreurs. Les APIs LLM retournent des timeouts, des rate limits, des erreurs de parsing. Enveloppez toujours vos appels dans des blocs try/except et définissez un comportement de fallback clair.
6. Utiliser ConversationBufferMemory en production sans limite. Sur des conversations longues, la mémoire buffer explose le contexte et les coûts. Utilisez ConversationSummaryBufferMemory avec un max_token_limit adapté.
LangChain offre en 2026 un écosystème mature et complet pour passer d’un simple appel LLM à un agent IA autonome capable d’interagir avec le monde réel. Les concepts sont accessibles à tout développeur Python intermédiaire, et les premiers résultats concrets sont obtenables en moins d’une journée.
Pour une PME, la valeur réside moins dans la sophistication technique que dans l’identification des bons cas d’usage : tâches répétitives à haute fréquence, traitement de volumes importants d’informations non structurées, ou processus nécessitant une synthèse intelligente continue.
La prochaine étape logique est d’explorer LangGraph pour les workflows multi-agents, ou d’intégrer un système RAG (Retrieval-Augmented Generation) pour que vos agents puissent puiser dans votre base de connaissances interne.
Vous souhaitez déployer un agent IA adapté à votre métier ? Nos équipes spécialisées en automatisation IA accompagnent les PME de l’idéation au déploiement production, avec un audit gratuit pour identifier vos meilleurs cas d’usage.
🚀
Faites découvrir nos conseils experts à votre réseau
💡 Partagez nos conseils d'experts avec votre réseau professionnel
Passez à l'action
Audit gratuit en 48h — ROI estimé, plan d'action personnalisé, sans engagement.
