LangChain : guide complet 2026

LangChain est le framework d'orchestration de référence pour construire des applications LLM en Python. Il permet de composer des chaînes de traitement, de créer des agents qui appellent des outils, et de gérer la mémoire conversationnelle — le tout avec une interface unifiée quel que soit le LLM utilisé. Ce guide couvre l'architecture, les composants essentiels et les patterns concrets pour aller de zéro à un agent fonctionnel en production.

---

Résumé rapide

Aspect	LangChain
Langage	Python (+ JS/TS via LangChain.js)
Version stable	v0.3+ (LCEL)
Interface principale	Runnable + LCEL (`
Agents	ReAct, OpenAI Tools, custom
Mémoire	Buffer, Summary, Redis, PostgreSQL
Companion officiel	LangGraph (workflows avec état)
Licence	MIT

---

Qu'est-ce que LangChain et pourquoi l'utiliser

LangChain est né en 2022 d'un constat simple : les LLM sont puissants isolément, mais leur vraie valeur émerge quand on les connecte à des données, des outils et une logique applicative. Le framework s'est imposé comme la couche d'orchestration standard pour ce besoin.

Le problème qu'il résout

Sans framework, construire une application LLM implique de gérer manuellement : la construction des prompts, la gestion du contexte et de la mémoire, les appels aux différents providers LLM, la logique de retry et de fallback, et l'intégration avec les outils externes. LangChain abstrait tout cela.

L'approche LCEL

Depuis la version 0.2, LangChain a unifié ses composants autour de LCEL (LangChain Expression Language). Chaque composant implémente l'interface Runnable et peut être composé avec l'opérateur | :

chain = prompt | llm | output_parser
result = chain.invoke({"question": "..."})

Cette syntaxe permet aussi le streaming, le batch et l'async de manière uniforme :

# Streaming
for chunk in chain.stream({"question": "..."}):
    print(chunk, end="", flush=True)

# Async
result = await chain.ainvoke({"question": "..."})

# Batch
results = chain.batch([{"question": "A"}, {"question": "B"}])

Position dans l'écosystème

LangChain est un framework d'orchestration généraliste. Il excelle pour les agents multi-outils, les pipelines avec logique conditionnelle, et les applications qui combinent LLM, APIs et bases de données. Pour le RAG documentaire pur, LlamaIndex offre plus de fonctionnalités out-of-the-box. Pour les workflows multi-agents avec état persistent, LangGraph est le complément naturel.

---

Architecture et composants essentiels

Runnables et LCEL

Tout dans LangChain moderne implémente Runnable. Les composants de base :

• PromptTemplate / ChatPromptTemplate : construit le prompt à partir de variables
• LLM / ChatModel : appelle le modèle de langage
• OutputParser : transforme la sortie brute en structure utile (string, JSON, Pydantic)
• Retriever : interroge une source de données (vector store, base SQL, API)

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model="gpt-4o", temperature=0)
prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant technique expert en Python."),
    ("human", "{question}")
])
parser = StrOutputParser()

chain = prompt | llm | parser

Agents

Un agent est une boucle où le LLM décide quelle action effectuer, observe le résultat et décide de la prochaine étape jusqu'à obtenir une réponse finale.

LangChain supporte plusieurs stratégies d'agents :

• ReAct : le LLM raisonne (Thought) puis agit (Action). Robuste et transparent.
• OpenAI Tool Calling : le LLM appelle des fonctions via function calling natif. Plus fiable sur les modèles OpenAI/Anthropic.
• Structured Chat : agent avec schémas Pydantic pour les sorties structurées.

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o", temperature=0)
prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant utile. Utilise les outils disponibles."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

Tools

Un tool est une fonction que l'agent peut appeler. LangChain fournit deux façons de les définir :

Via le décorateur @tool (recommandé) :

from langchain_core.tools import tool

@tool
def recherche_web(query: str) -> str:
    """Recherche des informations sur le web. Utiliser pour les questions d'actualité."""
    # implémentation ici
    return résultat

@tool
def calcul(expression: str) -> float:
    """Évalue une expression mathématique Python. Ex: '2 + 2 * 10'"""
    return eval(expression)

La docstring est critique : c'est elle que le LLM lit pour décider d'utiliser le tool ou non. Soyez précis et concret.

Intégrations prêtes à l'emploi : LangChain fournit des tools pour DuckDuckGo, Wikipedia, Arxiv, Gmail, GitHub, Slack, et des dizaines d'autres via langchain-community.

Mémoire

La mémoire permet à l'agent de maintenir un contexte conversationnel :

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

Types de mémoire disponibles :

Type	Usage
ConversationBufferMemory	Garde tout l'historique (conversations courtes)
ConversationBufferWindowMemory	Garde les N derniers échanges
ConversationSummaryMemory	Résume l'historique pour économiser des tokens
ConversationSummaryBufferMemory	Hybride : résumé + buffer récent

Pour la persistance entre sessions, connectez à Redis ou PostgreSQL via RedisChatMessageHistory.

Vector Stores et RAG

LangChain s'intègre avec tous les vector stores majeurs (Pinecone, Weaviate, Qdrant, Chroma, pgvector). Pattern RAG standard :

from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain

embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documents, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

combine_docs_chain = create_stuff_documents_chain(llm, prompt)
rag_chain = create_retrieval_chain(retriever, combine_docs_chain)

result = rag_chain.invoke({"input": "Quelle est la politique de retour ?"})

---

Exemple concret : agent de veille IA avec LangChain

Objectif : un agent qui recherche des actualités sur un sujet, les résume et génère un briefing structuré.

Étape 1 — Définir les tools

from langchain_core.tools import tool
from langchain_community.tools import DuckDuckGoSearchRun

search = DuckDuckGoSearchRun()

@tool
def recherche_actualites(sujet: str) -> str:
    """Recherche les dernières actualités sur un sujet tech ou IA."""
    return search.run(f"{sujet} 2026 actualité")

@tool
def formater_briefing(contenu: str, titre: str) -> str:
    """Formate un briefing structuré à partir du contenu collecté."""
    return f"# Briefing : {titre}\n\n{contenu}"

Étape 2 — Configurer l'agent

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o", temperature=0.3)

prompt = ChatPromptTemplate.from_messages([
    ("system", """Tu es un analyste IA spécialisé en veille technologique.
    Pour chaque demande de veille :
    1. Recherche les informations pertinentes
    2. Synthétise les points clés
    3. Formate un briefing actionnable"""),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

tools = [recherche_actualites, formater_briefing]
agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=5)

Étape 3 — Lancer la veille

result = executor.invoke({
    "input": "Fais une veille sur LangGraph et les agents multi-étapes cette semaine"
})
print(result["output"])

L'agent va appeler recherche_actualites, analyser les résultats, puis formater_briefing pour produire un rapport structuré. Avec verbose=True, vous voyez chaque étape de raisonnement — utile pour déboguer et optimiser les prompts.

---

Bonnes pratiques

Erreurs fréquentes

• Trop d'outils : au-delà de 6-7 outils, les LLM (même GPT-4o) peinent à choisir correctement. Regroupez les tools par domaine fonctionnel ou utilisez un routeur qui délègue à des sous-agents spécialisés.
• Docstrings vagues : une docstring comme "Cherche des informations" est inutile. Soyez précis sur ce que le tool fait, quand l'utiliser, et le format attendu des arguments.
• Pas d'épinglage de version : LangChain change d'API régulièrement. Épinglez langchain==0.x.y dans requirements.txt et testez chaque mise à jour avant de déployer.
• Mémoire sans limite : ConversationBufferMemory sans fenêtre peut exploser le contexte sur de longues sessions. Utilisez ConversationSummaryBufferMemory avec un max_token_limit explicite.

Patterns à connaître

• Fallback : chain.with_fallbacks([backup_chain]) pour gérer les erreurs de provider.
• Retry : llm.with_retry(stop_after_attempt=3) pour les timeouts.
• Streaming : préférer .astream() pour les interfaces utilisateur pour éviter l'effet "réponse bloquée".
• LangSmith : activez le tracing avec LANGCHAIN_TRACING_V2=true en développement. Indispensable pour déboguer les appels d'agents complexes.

Limites connues

• LangChain est un couteau suisse : pour un RAG documentaire poussé (reranking, chunking sémantique, retrievers hybrides), LlamaIndex sera plus adapté.
• Pour les workflows multi-agents avec état persistant et logique conditionnelle complexe, LangGraph est le prolongement naturel de LangChain — pas un remplacement, un complément.

---

Questions fréquentes

LangChain est-il toujours pertinent en 2026 ?

Oui. LangChain reste le framework d'orchestration le plus utilisé pour les applications LLM Python. La migration vers LCEL (v0.2+) a corrigé les principaux reproches sur la complexité et la verbosité. Son écosystème d'intégrations (50+ LLM, 100+ tools, 30+ vector stores) est imbattable.

Quelle est la différence entre LangChain et LangGraph ?

LangChain gère les chaînes et agents séquentiels. LangGraph est une extension pour les workflows avec état partagé, cycles et branches conditionnelles. LangGraph est recommandé dès que votre agent a besoin de revisiter une étape, de maintenir un état complexe entre plusieurs turns, ou de coordonner plusieurs agents en parallèle.

Comment LangChain gère-t-il la mémoire entre sessions ?

Par défaut, la mémoire est en RAM (perdue au redémarrage). Pour la persistance, LangChain s'intègre avec RedisChatMessageHistory, PostgresChatMessageHistory ou MongoDBChatMessageHistory. Fournissez un session_id unique par utilisateur pour isoler les conversations.

LangChain fonctionne-t-il avec des LLM open source ?

Oui. LangChain supporte Ollama, Mistral, LLaMA, Cohere, et tout modèle compatible OpenAI API. Remplacez ChatOpenAI par ChatOllama(model="mistral") — l'interface reste identique, ce qui facilite les migrations entre providers.

Faut-il utiliser LangChain ou construire from scratch ?

Utilisez LangChain si : vous intégrez plusieurs LLM ou tools, vous avez besoin de mémoire conversationnelle, vous itérez rapidement. Construisez from scratch si : votre use case est très spécifique, vous optimisez chaque token, ou les abstractions LangChain deviennent un obstacle. Pour 90% des projets, LangChain fait gagner du temps.

---

Articles liés

LangChain est le point d'entrée le plus solide pour orchestrer des agents LLM en Python. Pour les workflows complexes avec état, combinez-le avec LangGraph. Pour le RAG documentaire, LlamaIndex est le complément idéal. Explorez les frameworks concurrents pour choisir l'architecture la plus adaptée à votre projet.

• LangGraph : orchestration d'agents avec état
• LangChain vs LlamaIndex : comparaison complète
• CrewAI : agents collaboratifs en Python
• Meilleur framework agent IA en 2026
• Créer un agent IA en Python : tutoriel pas à pas