LangChain, LangGraph, LangSmith : le guide clair (2026)

L'essentiel en 30 secondes

LangChain sert à construire des applications et des agents d'IA : relier un modèle de langage à vos données et à vos outils. Il est open source et gratuit.
LangGraph est le moteur sur lequel tournent les agents LangChain. Il leur permet de reprendre après une panne, d'attendre une validation humaine et de se souvenir.
LangSmith sert à piloter : voir ce que fait l'agent, mesurer la qualité de ses réponses, suivre les coûts et le déployer. C'est une plateforme commerciale, avec une offre gratuite.
Le lien entre les deux : installer LangChain installe d'office le kit LangSmith, et deux variables d'environnement suffisent à tout tracer. Mais LangSmith fonctionne aussi sans LangChain.

Le problème que ces outils résolvent

Un modèle de langage seul répond à une question. Une application utile en entreprise doit faire bien plus : lire vos documents, interroger votre base de données ou votre ERP, garder le fil d'une conversation, s'arrêter pour demander l'accord d'un responsable, et prouver qu'elle répond juste.

Deux difficultés apparaissent alors. La première est de construire : assembler le modèle, les outils et les données sans tout réécrire à chaque changement de fournisseur. La seconde est de maîtriser : comprendre pourquoi l'agent s'est trompé mardi dernier, vérifier qu'une modification n'a rien cassé, savoir ce que coûte chaque conversation.

Une image aide à fixer les idées. Si votre agent était un avion, LangChain serait l'atelier et les pièces standard qui servent à le construire, LangGraph le plan de vol et le pilote automatique, et LangSmith la boîte noire, la tour de contrôle et le simulateur de vol réunis.

LangChain : l'atelier pour construire vos agents

En une phrase : LangChain donne des briques prêtes à l'emploi pour brancher un modèle d'IA sur vos outils et vos données, sans dépendre d'un seul fournisseur.

Créé en octobre 2022 par Harrison Chase, le projet est devenu une entreprise en 2023. La version 1.0 est sortie le 22 octobre 2025, et la branche actuelle est la 1.4 en Python. Le framework existe en Python et en JavaScript/TypeScript, sous licence MIT.

Ce qu'il apporte concrètement :

Une interface unique pour les modèles. OpenAI, Anthropic, Google, Mistral, ou un modèle local via Ollama : changer de fournisseur revient à changer une ligne.
Des outils. Une simple fonction Python, documentée, devient une action que l'agent peut déclencher : consulter un stock, créer un ticket, chercher un client. Les serveurs MCP sont aussi pris en charge.
Un agent prêt à l'emploi. La fonction create_agent gère la boucle complète : l'agent réfléchit, appelle un outil, lit le résultat, puis répond.
Des middlewares. Ce sont des points de contrôle autour de cette boucle : validation humaine avant une action sensible, résumé des longues conversations, masquage des données personnelles, limite du nombre d'appels, modèle de secours en cas de panne.
Des connecteurs de données pour le RAG, c'est-à-dire répondre à partir de vos propres documents : chargement de fichiers, découpage, bases vectorielles.

Voici un agent complet, avec un outil métier. Il s'installe avec pip install -U langchain "langchain[openai]" :

from langchain.agents import create_agent

def stock_disponible(reference: str) -> str:
    """Renvoie le stock disponible pour une référence produit."""
    return f"{reference} : 120 unités en stock"  # en vrai : requête à votre base

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[stock_disponible],
    system_prompt="Tu es l'assistant logistique de l'entreprise.",
)

resultat = agent.invoke(
    {"messages": [{"role": "user", "content": "Combien reste-t-il de PAR-500 ?"}]}
)
print(resultat["messages"][-1].content)

Le modèle lit la question, comprend qu'il doit appeler stock_disponible avec la référence PAR-500, puis formule la réponse. Pour passer chez un autre fournisseur, il suffit de modifier la ligne model=.

Pour des agents plus autonomes (planification, sous-agents, espace de travail de fichiers), LangChain propose aussi Deep Agents, un assemblage plus complet construit sur create_agent.

LangGraph : le moteur sous le capot

En une phrase : LangGraph est ce qui permet à un agent d'accomplir un travail long et fiable, de reprendre là où il s'était arrêté et d'attendre une décision humaine.

LangGraph décrit une application comme un graphe : des nœuds (les étapes), des arêtes (les enchaînements, éventuellement conditionnels) et un état partagé qui circule de l'un à l'autre. Ce modèle apporte des garanties qu'une simple boucle n'offre pas :

Exécution durable. L'état est sauvegardé à chaque étape (checkpoints). Après une panne ou un redémarrage, l'agent repart du dernier point sauvegardé.
Humain dans la boucle. Le graphe peut s'interrompre, par exemple avant de valider une commande, attendre une réponse pendant des heures, puis reprendre.
Mémoire. À court terme dans une conversation, à long terme d'une session à l'autre.
Mélange du déterministe et de l'IA. Certaines étapes suivent des règles fixes (contrôle, calcul, envoi), d'autres laissent le modèle décider.
Diffusion en continu. Les résultats intermédiaires s'affichent au fur et à mesure.

Depuis la version 1.0, chaque agent créé avec create_agent est un graphe LangGraph. La règle pratique est simple : commencez avec create_agent, et descendez dans LangGraph quand votre processus impose des étapes, des branches ou des validations que vous voulez contrôler finement.

LangSmith : la tour de contrôle

En une phrase : LangSmith vous montre ce que fait réellement votre agent, mesure la qualité de ses réponses et le fait tourner en production.

Ouvert à tous depuis février 2024 et édité par la même entreprise, LangSmith est une plateforme commerciale. Son kit de développement (SDK) est, lui, open source. La plateforme se présente désormais comme indépendante du framework : elle trace aussi bien un agent LangChain qu'un appel direct à l'API d'OpenAI ou une application construite avec un autre outil.

Ses principaux modules :

Observabilité. Chaque exécution devient une trace : appels au modèle, outils déclenchés, documents récupérés, durée, nombre de tokens, coût. Des tableaux de bord et des alertes suivent les erreurs, la latence et les dépenses.
Évaluation. Vous constituez un jeu de questions de référence, puis vous notez les réponses avec des évaluateurs : un modèle « juge », du code, ou des experts métier via des files d'annotation. Chaque modification du prompt ou du modèle se compare à la précédente, avant la mise en production. Les mêmes évaluateurs peuvent noter le trafic réel.
Prompts versionnés. Un espace pour tester les prompts et en garder l'historique.
Déploiement. LangSmith Deployment, anciennement LangGraph Platform, exécute vos agents en production : reprise sur panne, tâches longues, validations humaines, montée en charge. Il est disponible dans le cloud, en hybride ou chez vous.
Nouveautés de 2026 : Engine, qui regroupe les échecs de production et propose des correctifs ; Fleet, pour créer des agents sans code ; des bacs à sable pour exécuter le code généré par les agents ; une passerelle LLM, en bêta.

Avec LangChain, activer le traçage ne demande aucune ligne de code, seulement des variables d'environnement :

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="votre-clé"
export LANGSMITH_PROJECT="assistant-logistique"
# Compte hébergé en Europe :
export LANGSMITH_ENDPOINT="https://eu.api.smith.langchain.com"

Relancez l'agent : chaque question, chaque appel à stock_disponible et chaque réponse apparaissent dans LangSmith. Sans LangChain, deux lignes suffisent pour tracer un appel direct à OpenAI :

from openai import OpenAI
from langsmith import traceable
from langsmith.wrappers import wrap_openai

client = wrap_openai(OpenAI())  # chaque appel au modèle est tracé

@traceable  # la fonction entière devient une trace
def assistant(question: str) -> str:
    reponse = client.chat.completions.create(
        model="gpt-5.5",
        messages=[{"role": "user", "content": question}],
    )
    return reponse.choices[0].message.content

Comment ils s'emboîtent : les dépendances

C'est la partie la plus souvent mal comprise. Voici ce que déclarent réellement les paquets Python publiés sur PyPI (versions d'octobre 2026) :

langchain (1.4) dépend de langchain-core et de langgraph. Installer LangChain installe donc toujours LangGraph : c'est son moteur.
langgraph (1.2) dépend de langchain-core, mais pas du paquet langchain. On peut utiliser LangGraph seul.
langchain-core (1.7) contient les briques communes : messages, modèles, outils. Il dépend du SDK langsmith. C'est pour cela que le traçage fonctionne nativement, sans rien installer de plus.
langchain-openai, langchain-anthropic, etc. sont les connecteurs vers chaque fournisseur. Ils dépendent de langchain-core.
langsmith (0.14), le SDK, ne dépend d'aucun paquet LangChain. C'est ce qui lui permet de servir n'importe quel framework.

Trois conséquences pratiques :

Avoir le SDK installé ne veut pas dire envoyer des données. Rien ne part vers LangSmith tant que LANGSMITH_TRACING n'est pas activé.
Aucun outil n'impose l'autre. LangChain fonctionne sans compte LangSmith, et LangSmith sans LangChain. Leur force est d'être pensés ensemble.
Figez vos versions. Ces bibliothèques évoluent très vite : langchain-core a connu au moins vingt-cinq versions entre juin et octobre 2026. Un fichier de dépendances verrouillé (uv.lock, poetry.lock ou un requirements.txt à versions exactes) évite les mauvaises surprises en production.

Combien ça coûte ?

LangChain, LangGraph et Deep Agents sont gratuits et open source. Vous payez seulement le fournisseur du modèle (au token) et votre hébergement.

LangSmith propose trois offres (tarifs publics consultés en octobre 2026) :

Developer : gratuit, 1 utilisateur, jusqu'à 5 000 traces par mois, puis paiement à l'usage. Idéal pour démarrer.
Plus : 39 $ par utilisateur et par mois, utilisateurs illimités, jusqu'à 10 000 traces par mois et un petit déploiement serverless inclus.
Enterprise : sur devis, avec facturation annuelle. C'est la seule offre qui permet l'hébergement hybride ou chez vous.

Au-delà des quotas, la consommation (traces, déploiements, bacs à sable) est facturée en « LangChain Standard Units » à 1 $ l'unité. Les traces de base sont conservées 14 jours ; une conservation étendue à 180 jours est payante. Les startups financées par du capital-risque peuvent obtenir jusqu'à 10 000 $ de crédits.

Un repère utile : une trace correspond à une exécution complète de l'agent, avec toutes ses étapes. Sur un trafic important, tracer un échantillon plutôt que la totalité suffit souvent et maîtrise la facture.

Où vont vos données ?

C'est la question à poser avant de tracer des échanges avec des clients, des patients ou des fournisseurs.

Cloud : les données sont hébergées aux États-Unis ou en Europe, selon la région du compte. LangChain indique ne pas entraîner de modèles sur vos données.
Masquage : LANGSMITH_HIDE_INPUTS=true et LANGSMITH_HIDE_OUTPUTS=true empêchent l'envoi du contenu des échanges. Des anonymiseurs, à base d'expressions régulières ou de l'outil Presidio de Microsoft, remplacent les noms, téléphones et adresses e-mail avant l'envoi.
Hybride (Enterprise) : la console reste chez LangChain, mais les agents et leurs données tournent dans votre infrastructure.
Auto-hébergé (Enterprise) : toute la plateforme est installée sur votre cluster Kubernetes, et les traces ne quittent pas votre environnement.

Pour une PME ou une institution qui manipule des données sensibles, une démarche raisonnable consiste à démarrer en région Europe avec le masquage activé, puis à envisager l'hébergement interne si la réglementation l'exige. Si un outil d'observabilité auto-hébergé et gratuit est impératif, des alternatives open source existent, comme Langfuse.

Par où commencer

1. Un cas d'usage précis et mesurable, par exemple répondre aux questions fréquentes sur votre catalogue ou vos procédures.
2. Un prototype avec create_agent et un ou deux outils métier.
3. LangSmith dès le premier jour. L'offre gratuite suffit pour voir ce que fait l'agent.
4. Un jeu de 20 à 50 questions de référence, avec les réponses attendues, pour mesurer la qualité à chaque changement.
5. Des garde-fous : validation humaine des actions sensibles, masquage des données personnelles.
6. LangGraph et le déploiement quand le processus se complexifie ou que l'agent part en production.
7. Une surveillance continue de la qualité, de la latence et du coût.

Ce que nous en retenons

LangChain construit, LangGraph exécute, LangSmith observe, évalue et déploie. Les deux premiers sont gratuits et ouverts ; le troisième est la couche de pilotage, celle qui fait passer un prototype impressionnant à un agent fiable en production.

Le vrai risque d'un projet d'IA n'est pas de ne pas savoir le construire. C'est de ne pas savoir ce qu'il fait une fois en service. Tracer et évaluer dès le départ coûte peu, et évite beaucoup.

Vous voulez un agent IA branché sur vos outils, avec la traçabilité et les garde-fous qu'exige la production ? Ou former vos équipes pour qu'elles le construisent elles-mêmes ? Parlez-nous de votre projet.

Sources : documentation officielle LangChain, LangGraph et LangSmith, page tarifs LangChain, métadonnées des paquets PyPI (consultées le 29 octobre 2026).

LangChain et LangSmith : construire et piloter vos agents IA