LangChain : Framework LLM, RAG, Agents Python 2026

LangChain est un framework open-source Python (et TypeScript/JavaScript) permettant de construire des applications basées sur les LLM (Large Language Models) : chatbots, pipelines RAG (Retrieval-Augmented Generation), agents autonomes, copilotes métier, assistants vocaux. Créé en octobre 2022 par Harrison Chase (alors ingénieur chez Robust Intelligence), LangChain s'est imposé en quelques mois comme la lingua franca des développeurs IA, avec plus de 96 000 étoiles GitHub, 1 800 contributeurs et plus de 40 millions de téléchargements PyPI mensuels en mai 2026. Le framework propose des abstractions de haut niveau (chains, agents, tools, memory, output parsers) au-dessus des API LLM (OpenAI, Anthropic, Mistral, Cohere, Google, Hugging Face) et orchestre les briques d'un pipeline RAG : document loaders, text splitters, embeddings, vector stores (Chroma, Pinecone, Weaviate, Qdrant, FAISS, pgvector, Milvus). Depuis 2024, LangChain a été modularisé en langchain-core, langchain-community, langchain-openai (et >450 packages partenaires), accompagné de l'écosystème LangChain : LCEL (LangChain Expression Language) pour composer les pipelines, LangSmith (observabilité, traces, évaluations), LangGraph (multi-agent stateful avec mémoire long-terme, GA mars 2025) et LangServe (déploiement REST). Cette page entity-first détaille la définition, l'histoire, l'architecture, le langage LCEL, les composants (chains, agents, tools, memory, output parsers, document loaders, splitters, vector stores, embeddings, callbacks), les outils satellites (LangSmith, LangGraph, LangServe, LangChain.js), la sécurité (prompt injection, output validation, sandbox tools), les CVE historiques (CVE-2023-46229 SSRF, CVE-2024-2965 PALChain, CVE-2024-3571 PromptTemplate), la conformité, le comparatif vs LlamaIndex, Pydantic AI, OpenAI Assistants et Haystack, ainsi qu'une FAQ.

Définition : qu'est-ce que LangChain ?

LangChain est un framework de développement d'applications LLM publié sous licence MIT et maintenu par la société LangChain Inc. (San Francisco), fondée par Harrison Chase et Ankush Gola. Il s'adresse aux développeurs Python (package langchain) et JavaScript/TypeScript (package @langchain/core), avec l'objectif de fournir des abstractions composables pour orchestrer un ou plusieurs LLM dans un pipeline applicatif.

Concrètement, LangChain fournit :

• Des interfaces standardisées pour appeler des LLM (chat models, completion models, embeddings) indépendamment du fournisseur (OpenAI, Anthropic, Mistral, Google, Cohere, Hugging Face, Ollama, vLLM, etc.).
• Le langage LCEL pour composer prompts, modèles, parsers et retrievers via un opérateur |.
• Des composants RAG prêts à l'emploi : document loaders, text splitters, embeddings, vector stores, retrievers.
• Des abstractions agents et tools permettant à un LLM d'invoquer des fonctions externes (HTTP, DB, code, MCP).
• Des modules memory pour conserver l'historique conversationnel (buffer, summary, vector-backed).
• Des output parsers structurés (Pydantic, JSON Schema, regex) avec correction automatique en cas d'erreur.
• Un système de callbacks et tracing pour l'observabilité (intégré nativement avec LangSmith).

LangChain n'est pas un modèle ni un service hébergé : c'est une bibliothèque cliente qui s'installe avec pip install langchain langchain-openai langchain-community. Le framework est complémentaire des outils d'inférence locale (voir notre comparatif LM Studio vs Ollama) et s'intègre avec n'importe quelle API LLM compatible (voir Intégrer une API LLM).

Histoire : d'un side-project d'octobre 2022 à 96k étoiles GitHub

LangChain est publié pour la première fois sur GitHub le 22 octobre 2022 par Harrison Chase, alors ML engineer chez Robust Intelligence (cybersécurité IA). Le projet répond à un besoin observé en interne : composer des chaînes de prompts pour interroger ChatGPT-3.5 sur des données privées. Le nom "LangChain" vient de l'idée de chaîner des opérations sur du langage naturel.

Jalons :

• 2022 (octobre) : commit initial v0.0.1, support OpenAI et abstractions Chain/Agent.
• 2022 (novembre) : sortie de ChatGPT, explosion d'intérêt pour LangChain (étoiles ×10 en 4 semaines).
• 2023 (février) : levée seed de 10 M$ menée par Benchmark, Harrison Chase quitte Robust Intelligence et fonde LangChain Inc.
• 2023 (avril) : Series A de 20 M$ menée par Sequoia Capital, valorisation 200 M$.
• 2023 (juillet) : sortie de LangSmith (closed beta), plateforme d'observabilité.
• 2023 (octobre) : sortie de LangServe (déploiement REST API basé sur FastAPI/Pydantic).
• 2023 (octobre) : publication de la CVE-2023-46229 (SSRF dans SitemapLoader), score CVSS 9.8.
• 2023 (décembre) : refactor majeur en langchain-core et langchain-community (séparation API stable / intégrations).
• 2024 (janvier) : sortie de LangChain v0.1.0 (première version stable, gel des breaking changes sur core).
• 2024 (janvier) : sortie de LangGraph (premier preview), bibliothèque multi-agent stateful.
• 2024 (février) : levée Series B 25 M$, valorisation 1,2 Md$ (licorne IA).
• 2024 (avril) : sortie de LangChain v0.2.0, suppression progressive de langchain monolithique au profit des packages partenaires.
• 2024 (mai) : CVE-2024-2965 (PALChain RCE) et CVE-2024-3571 (PromptTemplate code injection).
• 2024 (septembre) : LangChain v0.3.0, migration Pydantic v2 obligatoire.
• 2025 (mars) : LangGraph 1.0 GA, persistence layer, time-travel debugging, support multi-tenant.
• 2025 (juin) : intégration native MCP (Model Context Protocol) via langchain-mcp-adapters.
• 2025 (octobre) : LangChain v0.4.0, suppression définitive des classes legacy LLMChain et ConversationChain, full-LCEL.
• 2026 (février) : Series C 175 M$ menée par IVP, valorisation 1,5 Md$, équipe ~140 personnes.
• 2026 (mai) : LangChain v0.5.x, support natif structured outputs Anthropic et OpenAI, caching layer distribuée, intégration Claude Opus 4.7.

Harrison Chase reste CEO en 2026, Ankush Gola CTO. La société compte plus de 140 employés (ingénieurs, DevRel, support enterprise), un programme LangChain Academy (cours gratuits), et un sommet annuel Interrupt (San Francisco, ~1 200 participants en 2025).

Architecture modulaire : langchain-core, community, partenaires

Depuis la v0.1 (janvier 2024), LangChain a abandonné la structure monolithique pour une architecture en couches qui dissocie les abstractions stables des intégrations à évolution rapide :

• langchain-core : interfaces et abstractions stables (Runnable, BaseChatModel, BaseRetriever, BaseTool, BaseOutputParser, PromptTemplate). Aucune dépendance lourde, ~50 ko. SemVer strict.
• langchain : chaînes et agents prédéfinis, retrievers complexes, mémoires. Construit sur core.
• langchain-community : intégrations communautaires (>500 connecteurs : loaders, vector stores, LLM tiers). Installation optionnelle.
• Packages partenaires (>450) : langchain-openai, langchain-anthropic, langchain-mistralai, langchain-google-vertexai, langchain-cohere, langchain-aws, langchain-chroma, langchain-pinecone, etc. Maintenus conjointement avec les éditeurs.
• Standalone libraries : langgraph, langsmith, langserve, langchain-text-splitters — versions et roadmaps indépendantes.

Cette modularisation a été motivée par les chaînes de dépendances explosives de la v0.0.x (>200 packages tirés par défaut, conflits Pydantic v1/v2, vulnérabilités transitives). En 2026, une installation minimale de LangChain pèse environ 15 Mo contre 320 Mo pour la version monolithique de mi-2023.

LCEL : LangChain Expression Language

LCEL (LangChain Expression Language) est le DSL déclaratif introduit en août 2023 et devenu obligatoire en v0.4. Il s'appuie sur le protocole Runnable de langchain-core et l'opérateur | (pipe Python) pour composer des pipelines de manière fluide. Exemple minimal :

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_anthropic import ChatAnthropic

prompt = ChatPromptTemplate.from_template("Resume cet article : {text}")
model = ChatAnthropic(model="claude-sonnet-4-5")
parser = StrOutputParser()

chain = prompt | model | parser
result = chain.invoke({"text": "..."})

Avantages clés de LCEL :

• Streaming natif via chain.stream(...) — chaque token est yield dès qu'il sort du modèle.
• Async natif via chain.ainvoke(...), astream, abatch — intégration FastAPI / asyncio sans wrapper.
• Batch parallèle via chain.batch([...]) — exploitation automatique des limites concurrentes du provider.
• Composition parallèle avec RunnableParallel({"a": chain1, "b": chain2}) — exécution concurrente.
• Fallbacks avec chain.with_fallbacks([backup_chain]) en cas d'erreur (rate-limit, timeout).
• Retries avec chain.with_retry(stop_after_attempt=3), exponential backoff configurable.
• Tracing automatique vers LangSmith si LANGCHAIN_TRACING_V2=true est défini.

LCEL remplace les anciennes classes LLMChain, ConversationChain, SequentialChain, supprimées en v0.4. La migration depuis les classes legacy est documentée dans le guide LCEL Migration officiel.

Chains : chaînes de traitement composées

Une chain est une séquence d'opérations LLM exposées comme un objet Runnable. LangChain fournit des chain helpers de haut niveau pour les patterns récurrents :

• create_stuff_documents_chain : injecte tous les documents dans un seul prompt (cas classique RAG court).
• create_retrieval_chain : combine un retriever et une stuff chain pour un RAG complet.
• create_history_aware_retriever : reformule la question utilisateur en intégrant l'historique avant la recherche vectorielle.
• create_sql_query_chain : génère une requête SQL à partir d'une question NL et du schéma.
• create_extraction_chain_pydantic : extrait des entités structurées via Pydantic v2.
• create_summarize_chain : résumé map-reduce ou refine sur des corpus longs.

Toutes ces chaînes retournent des Runnable composables avec d'autres pipelines LCEL. Les chaînes legacy basées sur BaseChain et __call__ sont dépréciées depuis v0.2.

Agents : ReAct, tool-calling, structured agents

Un agent est un LLM doté de la capacité d'invoquer des tools (fonctions Python) pour résoudre une tâche. LangChain a historiquement implémenté plusieurs paradigmes :

• ReAct (Reasoning + Acting) : prompt template imposant un format Thought / Action / Observation, parsé par regex. Robuste mais verbeux et sensible aux hallucinations de format.
• OpenAI Functions / Tools : utilise les capacités natives function calling des modèles (OpenAI, Anthropic, Mistral, Google), JSON Schema généré depuis Pydantic.
• Structured Chat Agent : variante générique compatible avec tout LLM produisant du JSON.
• Self-Ask With Search : pattern recherche web itérative.
• Plan-and-Execute : génère un plan en N étapes, puis exécute chaque étape (BabyAGI-like).

En 2026, l'API recommandée est create_tool_calling_agent (LCEL-native, multi-provider) ou directement LangGraph pour les architectures multi-agent. Les anciens AgentExecutor et initialize_agent sont dépréciés. Pour les patterns avancés (supervisor, hierarchical, swarm), voir notre analyse des failles LangGraph.

Tools : fonctions exposées au LLM

Un tool est une fonction Python annotée et exposée au LLM via JSON Schema. LangChain propose plusieurs façons de les définir :

• Décorateur @tool : la signature et la docstring deviennent le schéma. Le plus simple.
• Sous-classe BaseTool : contrôle fin (args_schema Pydantic, run/arun async, return_direct).
• Tool from function : Tool.from_function(...) pour wrapper une fonction existante.
• Toolkits : ensembles de tools cohérents (SQLDatabaseToolkit, GitHubToolkit, GmailToolkit, JIRA, Slack, etc.).

Plus de 200 tools community sont disponibles : recherche web (Tavily, SerpAPI, DuckDuckGo, Brave), code interpreter (E2B, Bearly), DB (Postgres, MongoDB, Redis), MCP servers (depuis 2025). Recommandation sécurité : tout tool exposant une commande shell, du SQL ou du HTTP doit être sandboxé et passer par une couche de validation Pydantic stricte (cf. CVE-2024-2965).

Memory : historique et contexte conversationnel

Les composants memory permettent de conserver l'historique entre les appels :

• ConversationBufferMemory : buffer brut, simple mais coûteux en tokens pour les longues conversations.
• ConversationBufferWindowMemory : conserve les N derniers tours.
• ConversationSummaryMemory : résume l'historique au-delà d'un seuil avec un LLM.
• ConversationSummaryBufferMemory : hybride (buffer récent + résumé du reste).
• VectorStoreRetrieverMemory : retrieve les souvenirs pertinents par similarité (mémoire long-terme).
• EntityMemory : extrait et suit les entités nommées (personnes, organisations, projets).

En 2026, les classes legacy de memory sont remplacées par les primitives LangGraph (checkpointer, store) qui offrent persistance Redis/Postgres, support multi-utilisateur et thread-safety.

Output parsers : structuration des sorties

Les output parsers convertissent une réponse LLM textuelle en structure typée. Variantes :

• StrOutputParser : extrait le texte brut.
• JsonOutputParser : parse JSON, supporte le streaming partiel.
• PydanticOutputParser : valide contre un schéma Pydantic v2, génère automatiquement les format instructions à inclure dans le prompt.
• StructuredOutputParser : alternative légère à Pydantic basée sur ResponseSchema.
• OutputFixingParser : enveloppe un parser et retente avec un appel LLM correctif si le parsing échoue.
• RetryWithErrorOutputParser : conserve le prompt original et passe l'erreur au LLM pour correction.

En 2026, l'API model.with_structured_output(MyPydanticModel) est privilégiée car elle exploite directement les capacités natives structured outputs d'OpenAI (depuis août 2024) et tool-call as JSON d'Anthropic, garantissant une sortie conforme au schéma sans besoin de parser textuel.

Document loaders : ingestion de >160 formats

Les document loaders convertissent des fichiers ou flux en objets Document (texte + métadonnées). LangChain en propose plus de 160 :

• Fichiers : PDF (PyMuPDF, PyPDF, Unstructured, PDFPlumber), DOCX, XLSX, CSV, JSON, HTML, Markdown, EPUB, PPTX, MP3 (Whisper).
• Web : WebBaseLoader, RecursiveURLLoader, SitemapLoader (CVE-2023-46229 corrigée), Firecrawl, Apify, Browserbase.
• Cloud : S3, GCS, Azure Blob, Google Drive, OneDrive, Dropbox, Notion, Confluence, SharePoint.
• SaaS : Slack, Gmail, Outlook, Discord, Telegram, Twitter, Reddit, Stripe, Salesforce, HubSpot.
• Code : GitLoader (par commit/branch), GitHub issues, BitBucket, language-aware splitters.
• Bases de données : SQL, MongoDB, Airtable, Notion DB, Hugging Face Datasets.

Les loaders retournent des List[Document] où chaque document porte un page_content et des metadata (source, page, author, last_modified). Recommandation : préférer Unstructured.io ou Docling (IBM) pour le parsing PDF complexe avec OCR et tables.

Text splitters : chunking pour RAG

Les text splitters découpent les documents en chunks de taille adaptée au modèle d'embedding et au LLM. Stratégies :

• RecursiveCharacterTextSplitter : découpe récursive sur séparateurs hiérarchiques (\n\n, \n, . , ). Le défaut conseillé.
• CharacterTextSplitter : split simple sur un séparateur unique.
• TokenTextSplitter : split par tokens (tiktoken, spaCy, NLTK) pour respecter une limite stricte.
• MarkdownHeaderTextSplitter : préserve la hiérarchie H1/H2/H3 dans les métadonnées.
• HTMLHeaderTextSplitter : équivalent pour HTML.
• SemanticChunker (langchain-experimental) : découpe sur les ruptures sémantiques détectées par embeddings — coûteux mais qualité supérieure.
• Language-aware splitter : split syntactique pour Python, JS, Java, Go, Rust, etc.

Le tuning des paramètres chunk_size (typiquement 500-1500 tokens) et chunk_overlap (10-20% du chunk_size) impacte directement le rappel du RAG. Voir notre guide RAG complet.

Vector stores : Chroma, Pinecone, Weaviate, Qdrant, FAISS

LangChain s'intègre avec plus de 80 vector stores. Les principaux en 2026 :

L'API LangChain expose similarity_search, similarity_search_with_score, max_marginal_relevance_search (MMR pour diversifier les résultats) et asimilarity_search. Les paramètres clés sont k (top-k), filter (metadata filtering) et fetch_k (pour MMR). Pour sécuriser le pipeline, voir Sécuriser un pipeline RAG.

Embeddings models : OpenAI, Cohere, Voyage, BGE

Les embeddings convertissent texte en vecteurs denses. LangChain supporte tous les principaux fournisseurs :

• OpenAI : text-embedding-3-small (1536d, 0,02 $/1M tokens), text-embedding-3-large (3072d, 0,13 $/1M).
• Cohere : embed-v4.0 multilingue, support image (multimodal embeddings).
• Voyage AI (Anthropic) : voyage-3, voyage-3-large, voyage-code-3, voyage-finance-2.
• Mistral : mistral-embed (1024d).
• Google : text-embedding-004 (Vertex AI), gemini-embedding.
• Hugging Face / sentence-transformers : BGE-M3, E5, GTE, Nomic, MixedBread (open-source, self-hosted).
• Ollama : nomic-embed-text, mxbai-embed-large en local.

Pour optimiser le coût et la latence, on combine souvent quantization binaire/scalaire des vecteurs (cf. notre article AWQ Quantization) avec un re-rank par cross-encoder (Cohere Rerank, BGE-Reranker) sur le top-50 pour produire un top-5 final.

Callbacks : observabilité, logging, streaming

Le système de callbacks permet d'intercepter les événements du pipeline :

• on_llm_start, on_llm_new_token, on_llm_end, on_llm_error — cycle de vie des appels LLM.
• on_chain_start, on_chain_end, on_chain_error — chaînes complètes.
• on_tool_start, on_tool_end, on_tool_error — invocations d'outils.
• on_retriever_start, on_retriever_end — recherches vectorielles.

Callbacks natifs : StdOutCallbackHandler, FileCallbackHandler, StreamingStdOutCallbackHandler, et LangChainTracer (vers LangSmith). Intégrations tierces : OpenTelemetry, Langfuse, Helicone, Arize Phoenix, Honeycomb. En 2026, l'instrumentation OTel est first-class et compatible avec n'importe quel collecteur APM.

LangSmith : observabilité, évaluation, prompt registry

LangSmith est la plateforme SaaS d'observabilité de LangChain Inc., disponible sur smith.langchain.com (plan Free 5k traces/mois, Plus 39 $/seat, Enterprise sur devis avec déploiement self-hosted Kubernetes). Fonctionnalités :

• Traces : capture chaque appel LLM/tool/retriever avec inputs/outputs/latence/coûts.
• Datasets : versioning de jeux de tests avec annotations humaines.
• Évaluations : metrics built-in (correctness, helpfulness, harmlessness) ou LLM-as-judge custom, exécution batch.
• Prompt registry : versioning Git-like des prompts, alias production/staging.
• A/B testing : split du trafic entre versions de chaînes en production.
• Annotations queues : workflow d'annotation humaine pour fine-tuning ou RLHF.
• Alertes : Slack/PagerDuty/email sur seuils de latence, coût, taux d'erreur.

LangSmith fonctionne indépendamment de LangChain et peut tracer du code OpenAI SDK natif, Anthropic SDK, ou tout pipeline custom via le SDK langsmith. Conformité : SOC 2 Type II, GDPR/RGPD, résidence données EU disponible. C'est la principale source de revenus de LangChain Inc. en 2026.

LangGraph : multi-agent stateful avec mémoire

LangGraph est la bibliothèque d'orchestration multi-agent stateful de LangChain, GA en mars 2025. Inspirée des finite state machines et de Pregel (Google), elle modélise un système d'agents comme un graphe de nœuds (fonctions Python ou LLM) reliés par des edges (déterministes ou conditionnels), avec un état partagé typé (TypedDict ou Pydantic).

Caractéristiques clés :

• Persistence layer : checkpointers MemorySaver, SqliteSaver, PostgresSaver, RedisSaver — reprise après crash, multi-tenant.
• Time-travel debugging : rewind à n'importe quelle étape passée et fork pour explorer une branche alternative.
• Human-in-the-loop : interrupts pour valider une étape sensible (paiement, suppression DB) avant exécution.
• Patterns prêts à l'emploi : supervisor, swarm, hierarchical teams, plan-and-execute, reflection.
• Streaming : stream des updates d'état, des messages LLM ou des events de nœud.
• Subgraphs : composition modulaire de graphes au sein de graphes.

LangGraph est devenu en 2026 le standard de facto pour les systèmes agentiques de production (Klarna, Replit, Elastic, Uber l'ont publiquement adopté). Une analyse des failles récentes est disponible dans LangChain LangGraph failles critiques 2026.

LangServe : déploiement REST API

LangServe est un wrapper FastAPI/Pydantic qui expose tout Runnable LangChain comme une REST API avec validation automatique :

• Endpoints standards : /invoke, /batch, /stream, /stream_log, /stream_events.
• Documentation OpenAPI auto-générée depuis les schémas d'input/output.
• Playground UI intégré à /playground pour tester en navigateur.
• Streaming SSE (Server-Sent Events) compatible navigateur et SDK LangChain.js.
• Authentification : middlewares FastAPI standards (OAuth2, JWT, API keys).

En 2026, LangServe est concurrencé par LangGraph Platform (PaaS managé pour LangGraph, lancé en 2025) qui inclut hébergement, scaling auto, persistence Postgres et observabilité LangSmith intégrée. Pour les projets LCEL simples, FastAPI direct + un middleware OTel reste une option valide.

LangChain.js : portage TypeScript/JavaScript

LangChain.js (package @langchain/core, @langchain/openai, etc.) est le portage TypeScript du framework, maintenu par la même équipe. Il supporte Node.js, Bun, Deno, Cloudflare Workers, Vercel Edge Runtime, navigateur (avec limitations).

• API quasi-identique à la version Python (Runnable, LCEL, agents, tools).
• Streaming SSE natif côté client via RemoteRunnable.
• Intégration native avec Vercel AI SDK, Next.js, SvelteKit.
• Support edge-runtimes : Cloudflare Workers AI, Deno Deploy, Bun.
• Subset de loaders/vectorstores plus limité qu'en Python (~60% de couverture).

LangGraph.js est également disponible mais moins mature que la version Python (pas encore tous les checkpointers, time-travel partiel). Pour une app full-stack JS, le combo @langchain/core + ai (Vercel) + @langchain/langgraph est l'écosystème de référence.

Sécurité : prompt injection, output validation, sandbox tools

LangChain, comme tout framework LLM, est exposé à des vecteurs d'attaque spécifiques. Les principaux risques :

• Prompt injection (direct) : utilisateur malveillant insère des instructions dans son input ("Ignore previous instructions and...") — défense : séparation stricte rôles (system/user), instructions dans system prompt, échappement.
• Prompt injection (indirect) : contenu malicieux dans un document RAG ou une page web chargée par un tool — défense : content sanitization, spotlighting, modèles alignés (Claude, GPT-4o avec system prompts robustes).
• SSRF via loaders : un URL contrôlé par l'attaquant peut atteindre des endpoints internes (cf. CVE-2023-46229) — défense : whitelist de domaines, blocage IP privées (RFC 1918), proxy filtré.
• RCE via tools dynamiques : PALChain, PythonREPL, BashTool exposent exec() — défense : sandbox (E2B, Bearly, Docker isolé), désactivation par défaut.
• Excessive agency : agent autonome avec accès écriture DB / envoi mail — défense : human-in-the-loop, permissions granulaires, dry-run preview.
• Vol de tokens : exfiltration de l'API key via tool log ou erreur — défense : redaction logs, secrets manager, rotation régulière.
• DoS / cost amplification : input forçant boucles infinies d'agent ou explosion de tokens — défense : max_iterations, budget tokens par requête, rate-limiting applicatif.

Le projet OWASP Top 10 for LLM Applications (v1.1, 2024) couvre ces risques en détail. LangChain v0.3+ inclut des dépréciations explicites (warn_deprecated) sur les chaînes les plus risquées comme PALChain et load_tools(["python_repl"]).

CVE LangChain : SSRF, RCE, code injection

Plusieurs vulnérabilités critiques ont été publiées sur LangChain. Les plus notables :

La majorité de ces CVE concernent des chaînes experimental qui exécutent du code généré par le LLM (PAL = Program-Aided Language Model). En 2026, ces chaînes sont soit supprimées, soit isolées dans langchain-experimental avec un avertissement explicite. Recommandation : maintenir langchain, langchain-core, langchain-community à jour (Dependabot ou Renovate), exécuter pip-audit ou safety en CI, et bannir langchain-experimental en production sauf justification documentée.

Conformité : SOC 2, GDPR, résidence données

La conformité dépend du composant utilisé :

• LangChain framework (open-source) : MIT License, aucune télémétrie par défaut (sauf LANGCHAIN_TRACING_V2=true qui envoie à LangSmith).
• LangSmith SaaS : SOC 2 Type II (depuis 2024), GDPR/RGPD avec DPA, résidence EU optionnelle (Frankfurt) sur plan Plus+, HIPAA BAA disponible Enterprise.
• LangSmith self-hosted : déploiement Kubernetes air-gapped, contrôle total des données, certifications du tenant (les vôtres).
• LangGraph Platform : SOC 2 Type II, hébergement AWS us-east-1 / eu-central-1.

Pour les secteurs régulés (santé, finance, défense), privilégier le self-hosting de LangSmith et n'utiliser que des LLM avec résidence données conforme (Anthropic Claude EU, OpenAI Azure EU, Mistral La Plateforme). Les data flows doivent être documentés dans le DPIA / RoPA pour respecter l'AI Act et le RGPD.

Comparatif : LangChain vs LlamaIndex vs Pydantic AI vs OpenAI Assistants vs Haystack

En pratique en 2026, beaucoup d'équipes combinent : LangChain pour l'orchestration et les tools, LangGraph pour le multi-agent stateful, LlamaIndex pour des indexes RAG sophistiqués, Pydantic AI pour les microservices critiques typés. La compatibilité Runnable de LangChain et l'OpenAI-compatible mode permettent de mixer les frameworks via des bridges.

FAQ : questions fréquentes sur LangChain

LangChain est-il encore pertinent en 2026 face à OpenAI Assistants ?

Oui. OpenAI Assistants reste verrouillé sur OpenAI, alors que LangChain abstrait plus de 60 fournisseurs LLM, gère self-hosting (Ollama, vLLM, TGI), et offre une observabilité décorrélée. Pour des architectures multi-modèles et multi-cloud, LangChain reste la solution de référence.

Quelle différence entre LangChain et LangGraph ?

LangChain orchestre des chaînes linéaires ou peu branchées (LCEL). LangGraph gère des graphes d'agents avec état persistant, branches conditionnelles, cycles, human-in-the-loop. Pour un chatbot RAG simple, LangChain LCEL suffit. Pour un agent multi-étapes avec mémoire long-terme et reprise après crash, LangGraph est obligatoire.

Faut-il utiliser langchain ou directement les SDK natifs (OpenAI, Anthropic) ?

Les SDK natifs sont plus légers et plus stables. Si votre app n'a qu'un seul provider, qu'elle ne fait pas de RAG complexe et qu'elle n'a pas besoin d'agents, le SDK natif est préférable. Dès que vous voulez switcher de provider, faire du RAG multi-vector-store ou des agents avec tools, LangChain devient un gain de productivité significatif.

Comment migrer de LangChain v0.0.x vers v0.4 / v0.5 ?

Trois étapes : (1) installer les packages partenaires explicites (langchain-openai, langchain-anthropic) au lieu de langchain monolithique ; (2) remplacer LLMChain, ConversationChain, SequentialChain par des compositions LCEL prompt | model | parser ; (3) remplacer AgentExecutor par create_tool_calling_agent ou LangGraph. Le guide officiel LCEL Migration couvre tous les patterns.

LangChain consomme-t-il beaucoup de tokens "inutiles" ?

Les anciennes chaînes ReAct (CoT verbeux) consommaient effectivement 30-50% de tokens d'overhead. Les agents tool-calling modernes basés sur les capacités natives des modèles (OpenAI Functions, Anthropic Tool Use) sont beaucoup plus efficients. Avec LCEL et with_structured_output, l'overhead est négligeable (<5%).

Peut-on utiliser LangChain sans envoyer de données à LangSmith ?

Oui. LANGCHAIN_TRACING_V2 est off par défaut. Aucune donnée ne quitte votre infrastructure tant que vous ne définissez pas LANGCHAIN_API_KEY + LANGCHAIN_TRACING_V2=true. Vous pouvez aussi auto-héberger LangSmith on-prem ou utiliser des alternatives open-source (Langfuse, Phoenix, Helicone).

LangChain est-il adapté à la production ?

Oui depuis la v0.1 (janvier 2024). Klarna, Elastic, Replit, Uber, Rakuten, Morningstar, BCG ont publiquement déployé LangChain/LangGraph en production. Recommandations : pinner les versions, exécuter une suite de tests regression avec LangSmith Evaluations, monitoring OTel, et budget tokens par requête.

Ressources et liens officiels

• Documentation officielle Python : python.langchain.com
• Code source GitHub : github.com/langchain-ai/langchain
• LangSmith (observabilité) : smith.langchain.com
• LangGraph documentation : langchain-ai.github.io/langgraph
• LangChain Academy (cours gratuits) : academy.langchain.com