LangChain overview for Node.js

LangChain.js is a framework for LLM applications in TypeScript and Node.js. It standardizes how you wire prompts, models, tools, document loaders, embeddings, and retrievers into reusable pipelines and agents.

LangChain, Deep Agents, LangGraph, and LangSmith

Use Deep Agents for complex multi-step tasks out of the box. Use LangChain's createAgent when you want a minimal harness you compose with middleware. Reach for LangGraph when you need custom stateful workflows, branching, or fine-grained control over the agent loop.

Packages

Install the core packages first (install guide):

npm i langchain @langchain/core @langchain/openai zod

Provider-specific integrations live in separate packages:

• 
  langchain - createAgent, tool, and high-level chain helpers


• 
  zod - tool input schemas when defining tools with tool()
  


• 
  @langchain/core - prompts, output parsers, Runnable interface, LCEL


• 
  @langchain/openai - ChatOpenAI, OpenAIEmbeddings
  


• 
  @langchain/textsplitters - document chunking (used in the RAG post)


• Standalone integration packages for other providers and tools (see the integrations page)

For raw API access, see the Chat Completions and OpenAI Responses API posts. For provider-agnostic text and agents, see the Vercel AI SDK and OpenAI Agents SDK posts.

When to use LangChain

Reach for LangChain when RAG or multi-step LLM pipelines grow beyond a few manual API calls.

Prerequisites

• OpenAI account


• Generated API key


• Enabled billing


• Node.js version 26


• 
  langchain, @langchain/core, @langchain/openai, and zod installed


• 
  OPENAI_API_KEY set in the environment

Core concepts

Document - a chunk of text with optional metadata. Loaders produce Document instances; splitters break long sources into retrieval-friendly pieces.

import { Document } from '@langchain/core/documents';



const doc = new Document({

  pageContent: 'LangChain helps compose LLM pipelines.',

  metadata: { source: 'intro' }

});

Runnable - any component with .invoke(), .stream(), or .batch(). Prompts, models, parsers, and composed chains are all Runnables.

LCEL (LangChain Expression Language) - chain Runnables with .pipe(). Data flows left to right: prompt → model → parser. The same .invoke(), .stream(), and .batch() interface applies to every Runnable in the chain.

import { ChatPromptTemplate } from '@langchain/core/prompts';

import { StringOutputParser } from '@langchain/core/output_parsers';

import { ChatOpenAI } from '@langchain/openai';



const prompt = ChatPromptTemplate.fromMessages([

  ['system', 'Answer in one sentence.'],

  ['human', '{question}']

]);



const model = new ChatOpenAI({ model: 'gpt-5.5' });

const chain = prompt.pipe(model).pipe(new StringOutputParser());



const answer = await chain.invoke({ question: 'What is LangChain?' });

console.log(answer);

Agents - LangChain's current high-level agent API is createAgent. Pass a model string or chat model, optional tools (with zod schemas), and an optional checkpointer for conversation memory (@langchain/langgraph):

import { createAgent } from 'langchain';



const agent = createAgent({

  model: 'gpt-5.5',

  tools: []

});



const result = await agent.invoke({

  messages: [{ role: 'user', content: 'What is LangChain?' }]

});

What LangChain can do

• 
  Load and split documents - PDF, HTML, CSV, directories; token- or character-based splitters


• 
  Embeddings and vector stores - OpenAI embeddings with pgvector, Pinecone, Chroma, and others


• 
  Retrievers and RAG chains - fetch relevant context, then call a model (see the RAG with pgvector post)


• 
  Conversation memory - short-term memory via @langchain/langgraph checkpointers and thread_id; long-term memory via stores
  


• 
  Tools and agents - createAgent with tools and middleware; for production agents you may also prefer the Vercel AI SDK agents post or OpenAI Agents SDK post
  


• 
  Observability - trace runs with LangSmith (LANGSMITH_TRACING=true); optional LangSmith Engine monitors traces and flags issues

Streaming and batch

The same LCEL chain supports streaming and batch invocation:

for await (const chunk of await chain.stream({ question: 'What is LCEL?' })) {

  process.stdout.write(chunk);

}



const answers = await chain.batch([

  { question: 'What is a Runnable?' },

  { question: 'What is a retriever?' }

]);

Demo

Runnable LCEL scripts for this post live in the langchain-overview-nodejs-demo folder. Get access via code demos.