LangChain.js

LangChain.js est la version TypeScript/JavaScript du framework LangChain, permettant de construire des agents IA et des applications LLM dans l’écosystème JavaScript : Node.js, Next.js, Deno, Bun, Cloudflare Workers, Supabase Edge Functions, et navigateurs.

Si vous êtes développeur JavaScript/TypeScript et que vous voulez construire un agent IA qui appelle des APIs, interroge une base de données vectorielle, ou orchestre des workflows complexes, LangChain.js est votre point d’entrée. Il porte les mêmes abstractions que la version Python (modèles, outils, agents, chaînes, RAG) dans un package npm natif, avec un typage TypeScript complet et un support multi-environnement unique dans l’écosystème IA.

Catégorie: Framework open source pour agents IA (TypeScript/JavaScript)
Mainteneur: LangChain Inc. (même équipe que LangChain Python)
Langage: TypeScript (compatible JavaScript)
Version actuelle: langchain 1.2.35 (mars 2026)
npm: 1 126+ projets dépendants sur le registre npm
Environnements: Node.js (18+), Next.js, Deno, Bun, Cloudflare Workers, Supabase Edge Functions, Browser
Licence: MIT
Écosystème: LangChain.js + LangGraph.js + LangSmith (tracing via SDK TypeScript)
Verdict: Le seul framework IA TypeScript complet pour la construction d’agents, avec un support multi-environnement inégalé
URL: js.langchain.com

Pourquoi LangChain.js existe

La version Python de LangChain domine l’écosystème IA avec 118 000+ GitHub stars. Mais une grande partie des applications web modernes sont construites en JavaScript/TypeScript : Next.js, React, Vue, APIs serverless, edge functions. LangChain.js permet à ces développeurs de construire des agents IA sans quitter leur stack technique habituelle.

Le projet a été lancé début 2023 par l’équipe LangChain pour porter les mêmes abstractions en TypeScript natif. Toutes les primitives de la version Python sont présentes : modèles de chat, outils, prompts, agents, chaînes, document loaders, embeddings, vector stores, et retrievers. L’interopérabilité entre les deux versions est un objectif de conception : les objets sérialisés (prompts, chaînes, agents) peuvent être partagés entre Python et JavaScript.

Le point fort distinctif de LangChain.js est son support multi-environnement. Contrairement à la version Python (limitée à des serveurs ou des notebooks), LangChain.js tourne partout où JavaScript tourne : serveurs Node.js classiques, fonctions serverless (Vercel, AWS Lambda), edge functions (Cloudflare Workers, Supabase Edge), runtimes alternatifs (Deno, Bun), et même directement dans le navigateur pour certains cas d’usage.

Architecture et composants

Organisation des packages

LangChain.js est organisé en packages modulaires pour garder la taille du bundle minimale :

langchain : le package principal. Il contient les abstractions de haut niveau (agents, chaînes, document loaders) et réexporte les fonctionnalités de @langchain/core.

@langchain/core : les primitives fondamentales (messages, prompts, output parsers, interfaces). C’est le cœur du framework, léger et indépendant.

@langchain/openai, @langchain/anthropic, @langchain/google-genai, etc. : packages d’intégration séparés pour chaque fournisseur. Vous n’installez que ce dont vous avez besoin, ce qui réduit la taille du bundle. Cette architecture modulaire est particulièrement importante pour les déploiements edge et browser où chaque Ko compte.

@langchain/langgraph : LangGraph.js, le framework d’orchestration d’agents avec graphes d’état, persistance, et human-in-the-loop. Depuis janvier 2026, LangGraph.js supporte StateSchema avec Standard JSON Schema, compatible Zod 4, Valibot, ArkType et d’autres bibliothèques de validation.

Taille du bundle Après compression et chunk splitting, LangChain.js occupe environ 37 Ko pour un cas d’usage RAG sur Vercel Edge Functions, soit moins de 4 % de la limite gratuite de 1 Mo. C’est suffisamment compact pour la plupart des déploiements serverless et edge.

Modèles de chat

L’interface unifiée de modèles permet de passer d’un fournisseur à un autre en changeant une seule ligne :

import { createAgent, tool } from « langchain »;
import * as z from « zod »;

const agent = createAgent({
  model: « claude-sonnet-4-6 »,  // ou « openai:gpt-5.4 », « google-genai:gemini-3.1-pro »
  tools: [getWeather],
});

Les fournisseurs supportés incluent OpenAI, Anthropic (Sonnet 4.6, Opus 4.6), Google (Gemini 3.1), Mistral, Cohere, Ollama (modèles locaux), et bien d’autres. Chaque fournisseur est dans son propre package npm, installé séparément.

Outils et function calling

LangChain.js utilise Zod pour définir les schémas d’outils avec typage complet :

import { tool } from « langchain »;
import * as z from « zod »;

const getWeather = tool(
  ({ city }) => `Il fait beau à ${city} !`,
  {
    name: « get_weather »,
    description: « Obtenir la météo d’une ville »,
    schema: z.object({ city: z.string() }),
  }
);

Le pattern function calling / tool use est natif. L’agent décide automatiquement quand utiliser un outil, l’appelle, observe le résultat, et continue son raisonnement (pattern ReAct). Les outils typés avec Zod garantissent la validation des entrées et des sorties à la compilation et à l’exécution.

Middleware

Le système de middleware de LangChain.js (aligné avec la version Python 1.0) permet d’empiler des comportements sur vos agents sans modifier leur logique centrale :

Summarization middleware : résume automatiquement l’historique de conversation quand les limites de tokens approchent. Tool call limiter : impose un nombre maximum d’appels d’outils par exécution. Tool emulation : émule des outils via un LLM au lieu de les exécuter réellement (utile pour les tests). Retry middleware : retry automatique des appels échoués avec backoff configurable. Structured output : stratégies native (provider) et via function calling pour obtenir des sorties structurées.

Les middleware sont composables : vous les empilez dans l’ordre qui convient à votre cas d’usage, et ils s’exécutent séquentiellement autour de chaque appel au modèle.

Environnements supportés

C’est l’avantage compétitif principal de LangChain.js par rapport à la version Python. Votre code d’agent IA peut tourner dans tous ces environnements :

Environnement	Cas d’usage	Notes
Node.js (18+)	Serveurs, scripts, APIs	ESM et CommonJS supportés
Next.js (Vercel)	Apps full-stack, API routes, edge	Template officiel disponible
Cloudflare Workers	Edge computing, APIs à faible latence	Bundle compact nécessaire
Supabase Edge Functions	Backend serverless, webhooks	Intégration native Supabase
Deno	Runtime sécurisé, scripts	Support natif des modules ESM
Bun	Runtime haute performance	Compatible npm packages
Browser	Apps client-side, prototypage	Certaines intégrations limitées (pas d’accès filesystem)

Chaque environnement est testé dans le CI de LangChain.js via des projets starter isolés dans des conteneurs Docker. Cela garantit que les mises à jour ne cassent pas la compatibilité avec un environnement spécifique.

Next.js + LangChain.js Le combo le plus populaire. LangChain fournit un template officiel langchain-nextjs-template avec chatbot, RAG, et agent de retrieval pré-configurés, déployable en un clic sur Vercel. C’est le point de départ recommandé pour une app full-stack IA avec interface React et backend edge.

LangGraph.js

LangGraph.js est le pendant JavaScript de LangGraph. Il fournit l’orchestration d’agents via des graphes d’état, avec persistance, checkpointing, human-in-the-loop, et exécution durable. C’est LangGraph.js qui fait tourner les agents LangChain.js dans des environnements de production.

Depuis janvier 2026, LangGraph.js supporte StateSchema, une manière propre et agnostique de définir l’état du graphe compatible avec n’importe quelle bibliothèque de validation implémentant Standard JSON Schema (Zod 4, Valibot, ArkType). Plus de lock-in sur une bibliothèque de validation spécifique.

LangGraph.js est utilisé en production par des entreprises comme LinkedIn, Uber, Klarna et GitLab pour des agents complexes nécessitant une gestion d’état robuste, une mémoire persistante, et des workflows avec intervention humaine.

Deep Agents en JavaScript

LangChain.js supporte les Deep Agents, des agents sophistiqués qui vont au-delà des boucles simples d’appels d’outils. Les Deep Agents combinent des outils de planification, la création de sous-agents, l’accès au système de fichiers, et des prompts détaillés pour gérer des tâches multi-étapes complexes. L’architecture est inspirée d’applications comme Claude Code et Deep Research.

Tests et qualité

LangChain.js v1.2.35 introduit des custom Vitest matchers pour simplifier les tests d’agents IA :

import { langchainMatchers } from « langchain/testing/matchers »;
expect.extend(langchainMatchers);

// Puis dans vos tests :
expect(message).toBeAIMessage();
expect(message).toHaveToolCalls();
expect(message).toContainToolCall({ name: « get_weather » });
expect(result).toHaveStructuredResponse();

Ces matchers couvrent les assertions sur les messages (Human, AI, System, Tool), les appels d’outils (nombre, contenu, présence), les interruptions, et les sorties structurées. Combinés avec LangSmith pour le tracing des tests, ils forment un pipeline de qualité robuste pour les agents en production.

Intégration LangSmith

LangSmith s’intègre nativement avec LangChain.js. Le SDK TypeScript de LangSmith est l’un des quatre SDKs officiels (avec Python, Go, et Java). Configurez une variable d’environnement LANGSMITH_API_KEY, et toutes vos exécutions sont automatiquement tracées. Vous pouvez ensuite :

Visualiser le parcours complet de chaque exécution d’agent (appels LLM, outils, décisions). Comparer des expériences côte à côte pour détecter les régressions. Transformer des traces de production en cas de test. Évaluer les performances avec des scorers automatisés et humains.

Pour les déploiements serverless et edge, veillez à configurer LANGCHAIN_CALLBACKS_BACKGROUND=false pour garantir que le tracing se termine avant la fin de la fonction (les edge functions ont un cycle de vie court).

LangChain Python vs. LangChain.js

Critère	LangChain Python	LangChain.js
Langage	Python	TypeScript/JavaScript
Version	1.0.3 (mars 2026)	1.2.35 (mars 2026)
GitHub Stars	118 000+ (repo principal)	Inclus dans le même écosystème (~13 000 sur langchainjs)
Environnements	Serveurs, notebooks, containers	Node.js, Next.js, Deno, Bun, Edge, Browser
Intégrations	1 000+ (plus complètes)	Légèrement moins de connecteurs natifs
ML/Data Science	Meilleur support (numpy, pandas, transformers)	Limité (pas d’écosystème ML natif en JS)
Frontend	Pas de support navigateur	Support navigateur et edge natif
Typage	Type hints (optionnels)	TypeScript (typage strict, inférence complète)
Validation	Pydantic	Zod (+ Standard Schema depuis LangGraph.js)

Les deux versions partagent les mêmes concepts et la même architecture, mais la version Python a généralement plus d’intégrations et une communauté ML plus large. La version JavaScript excelle sur le déploiement edge, le frontend, et l’intégration dans les stacks web modernes (Next.js, Vercel, Cloudflare). Pour les équipes full-stack JavaScript, LangChain.js élimine le besoin de maintenir un service Python séparé pour la partie IA.

Cas d’usage typiques

Chatbots augmentés avec Next.js : Le cas d’usage phare. Un chatbot React en frontend, une API route Next.js en backend, LangChain.js pour la logique d’agent (RAG, function calling, mémoire), déployé sur Vercel en mode edge. Le streaming de la réponse est natif et performant.

APIs d’agents serverless : Construire une API REST qui expose un agent IA capable de rechercher dans une base documentaire, résumer des contenus, et exécuter des actions. Déployable sur Vercel, AWS Lambda, ou Cloudflare Workers.

Automatisation edge : Agents IA tournant dans des Cloudflare Workers ou Supabase Edge Functions pour des cas nécessitant une latence minimale (triage de tickets, enrichissement de données en temps réel, classification de contenu).

Extensions navigateur : LangChain.js peut tourner dans le navigateur pour des extensions Chrome ou des applications client-side qui interagissent avec des LLMs sans backend dédié (les clés API restent côté client, donc uniquement pour le prototypage ou les outils internes).

Pipelines RAG full-stack : Ingestion de documents (PDF, HTML, CSV), vectorisation, stockage dans Supabase, Pinecone ou Chroma, et recherche augmentée, le tout en TypeScript de bout en bout.

Prise en main rapide

Installation :

npm install langchain @langchain/anthropic
# ou pour OpenAI : npm install langchain @langchain/openai

Agent minimal :

import { createAgent, tool } from « langchain »;
import * as z from « zod »;

const searchWeb = tool(
  async ({ query }) => { /* votre logique de recherche */ },
  {
    name: « search_web »,
    description: « Rechercher sur le web »,
    schema: z.object({ query: z.string() }),
  }
);

const agent = createAgent({
  model: « claude-sonnet-4-6 »,
  tools: [searchWeb],
  systemPrompt: « Vous êtes un assistant de recherche. »,
});

const result = await agent.invoke({
  messages: [{ role: « user », content: « Quelles sont les dernières nouvelles IA ? » }],
});

Template Next.js : Pour une application complète, utilisez le template officiel :

npx create-next-app@latest –example https://github.com/langchain-ai/langchain-nextjs-template

Ce template inclut un chatbot avec streaming, un pipeline RAG avec Supabase, et un agent de retrieval, le tout déployable sur Vercel en un clic.

Forces et faiblesses

Forces	Faiblesses
Support multi-environnement unique (Node, Edge, Browser, Deno, Bun)	Moins d’intégrations que la version Python
TypeScript natif avec typage complet et inférence	Pas d’écosystème ML natif (pas de numpy/pandas en JS)
Validation Zod + Standard Schema (pas de lock-in)	Communauté plus petite que la version Python
Bundle compact (37 Ko pour RAG sur Edge)	Certaines fonctionnalités arrivent après la version Python
Intégration native LangSmith et LangGraph.js	Documentation parfois en retard sur les releases
Template Next.js officiel prêt à déployer	Debugging des agents plus complexe en serverless (lifecycle court)
Custom Vitest matchers pour les tests d’agents	Certaines intégrations vector store moins matures qu’en Python

Verdict

LangChain.js est le framework IA le plus complet disponible pour l’écosystème JavaScript/TypeScript. Son support multi-environnement (Node.js, Next.js, Deno, Bun, Edge, Browser) est inégalé. Le typage TypeScript natif, la validation Zod, les custom Vitest matchers, et l’intégration LangSmith en font un outil de qualité production, pas juste un portage de convenance.

Pour les équipes full-stack JavaScript qui construisent des applications IA, LangChain.js élimine la nécessité d’un service Python séparé. Vous restez dans votre stack, avec votre outillage, vos outils de test, et vos pipelines de déploiement habituels.

Si votre cas d’usage est principalement data science ou ML (analyse de données, fine-tuning, traitement de datasets massifs), la version Python reste le meilleur choix grâce à l’écosystème numpy/pandas/transformers. Pour tout le reste, en particulier les applications web, les APIs, les chatbots, et les agents déployés en edge, LangChain.js est le choix naturel.

Questions fréquentes sur LangChain.js

Quelle est la différence entre LangChain.js et LangChain Python ?

Les deux partagent les mêmes abstractions et la même architecture (modèles, outils, agents, chaînes, RAG). LangChain Python a plus d’intégrations (1 000+ vs un peu moins en JS) et un meilleur support pour le ML/data science (numpy, pandas, transformers). LangChain.js excelle sur le déploiement multi-environnement (Node.js, Next.js, Edge, Browser, Deno, Bun), le typage TypeScript strict, et l’intégration dans les stacks web modernes. Les objets sérialisés sont interopérables entre les deux versions.

LangChain.js fonctionne-t-il dans le navigateur ?

Oui, LangChain.js supporte l’exécution dans le navigateur. Cependant, certaines intégrations ne fonctionnent pas côté client (accès filesystem, bases de données locales). L’usage principal en browser est le prototypage, les outils internes, ou les extensions. Pour la production, le pattern recommandé est de faire tourner LangChain.js côté serveur (API route Next.js, Edge function) et de streamer les résultats vers le client React.

LangChain.js est-il compatible avec Next.js ?

Oui, c’est l’un des cas d’usage les plus populaires. LangChain fournit un template officiel langchain-nextjs-template avec chatbot, RAG, et agent pré-configurés, déployable sur Vercel en un clic. LangChain.js fonctionne à la fois dans les API routes (server-side) et les edge functions (edge runtime). Le streaming des réponses LLM vers le client est natif et performant. Pour le tracing LangSmith en edge, configurez LANGCHAIN_CALLBACKS_BACKGROUND=false.

Peut-on utiliser LangChain.js avec Cloudflare Workers ?

Oui. LangChain.js est testé et compatible avec Cloudflare Workers. Le bundle compressé est suffisamment compact (environ 37 Ko pour un cas RAG) pour respecter les limites de taille des Workers. Utilisez les packages d’intégration séparés (@langchain/openai, @langchain/anthropic) pour minimiser la taille du bundle. Les limitations habituelles des Workers s’appliquent (pas de filesystem, durée d’exécution limitée).

Quel est le niveau de parité avec la version Python ?

La parité est élevée mais pas complète. Les abstractions fondamentales (modèles, outils, agents, chaînes, RAG, embeddings, vector stores) sont toutes présentes. Les middleware (summarization, retry, tool limiter, structured output) sont disponibles. Les Deep Agents sont supportés. Certaines intégrations spécifiques existent en Python mais pas encore en JavaScript, et inversement. Les nouvelles fonctionnalités arrivent parfois en Python d’abord, avec un délai de quelques semaines à quelques mois pour la version JavaScript. La version 1.2.x de LangChain.js est activement maintenue avec des releases quasi hebdomadaires.