LangGraph

https://docs.langchain.com/oss/javascript/langgraph
Admin
LangGraph is a low-level orchestration framework and runtime for building, managing, and deploying...
Tokens:167,806
Snippets:1,093
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Example: using Postgres checkpointer

Source: https://docs.langchain.com/oss/javascript/langgraph/add-memory

Complete example of using PostgresSaver with a LangGraph agent. Install the package, then call checkpointer.setup() on first use. The example shows a simple agent that remembers the user's name across two turns.

```bash
npm install @langchain/langgraph-checkpoint-postgres
```

```typescript
import { ChatAnthropic } from "@langchain/anthropic";
import { StateGraph, StateSchema, MessagesValue, GraphNode, START } from "@langchain/langgraph";
import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";

const State = new StateSchema({
  messages: MessagesValue,
});

const model = new ChatAnthropic({ model: "claude-haiku-4-5-20251001" });

const DB_URI = "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
const checkpointer = PostgresSaver.fromConnString(DB_URI);
// await checkpointer.setup();

const callModel: GraphNode<typeof State> = async (state) => {
  const response = await model.invoke(state.messages);
  return { messages: [response] };
};

const builder = new StateGraph(State)
  .addNode("call_model", callModel)
  .addEdge(START, "call_model");

const graph = builder.compile({ checkpointer });

const config = {
  configurable: {
    thread_id: "1"
  }
};

const stream1 = await graph.streamEvents(
  { messages: [{ role: "user", content: "hi! I'm bob" }] },
  { ...config, version: "v3" }
);
for await (const snapshot of stream1.values) {
  console.log(snapshot);
}

const stream2 = await graph.streamEvents(
  { messages: [{ role: "user", content: "what's my name?" }] },
  { ...config, version: "v3" }
);
for await (const snapshot of stream2.values) {
  console.log(snapshot);
}
```

--------------------------------

### Install packages with bun

Source: https://docs.langchain.com/oss/javascript/langgraph/agentic-rag

Install the required packages for the tutorial using bun.

```bash
bun add @langchain/langgraph @langchain/openai @langchain/textsplitters cheerio

```

--------------------------------

### Install packages with yarn

Source: https://docs.langchain.com/oss/javascript/langgraph/agentic-rag

Install the required packages for the tutorial using yarn.

```bash
yarn add @langchain/langgraph @langchain/openai @langchain/textsplitters cheerio

```

--------------------------------

### Install packages with npm

Source: https://docs.langchain.com/oss/javascript/langgraph/agentic-rag

Install the required packages for the tutorial using npm.

```bash
npm install @langchain/langgraph @langchain/openai @langchain/textsplitters cheerio

```

--------------------------------

### Install LangChain with bun

Source: https://docs.langchain.com/oss/javascript/langgraph/install

Use bun to install the LangChain package.

```bash
bun add langchain

```

--------------------------------

### Install packages with pnpm

Source: https://docs.langchain.com/oss/javascript/langgraph/agentic-rag

Install the required packages for the tutorial using pnpm.

```bash
pnpm install @langchain/langgraph @langchain/openai @langchain/textsplitters cheerio

```

--------------------------------

### Install MongoDB checkpoint package

Source: https://docs.langchain.com/oss/javascript/langgraph/add-memory

Install the MongoDB checkpoint package required for the MongoDB store example.

```bash
npm install @langchain/langgraph-checkpoint-mongodb
```

--------------------------------

### Install LangChain with yarn

Source: https://docs.langchain.com/oss/javascript/langgraph/install

Use yarn to install the LangChain package.

```bash
yarn add langchain

```

--------------------------------

### Install LangGraph and Core with bun

Source: https://docs.langchain.com/oss/javascript/langgraph/install

Use bun to install the base LangGraph package and @langchain/core.

```bash
bun add @langchain/langgraph @langchain/core

```

--------------------------------

### Install Postgres store package

Source: https://docs.langchain.com/oss/javascript/langgraph/add-memory

Install the @langchain/langgraph-checkpoint-postgres package to use PostgresStore in production.

```bash
npm install @langchain/langgraph-checkpoint-postgres
```

--------------------------------

### Install LangChain with pnpm

Source: https://docs.langchain.com/oss/javascript/langgraph/install

Use pnpm to install the LangChain package.

```bash
pnpm add langchain

```

--------------------------------

### Install langgraph

Source: https://docs.langchain.com/oss/javascript/langgraph/use-graph-api

Install the langgraph package using npm.

```bash
npm install @langchain/langgraph

```

--------------------------------

### Install LangGraph JS SDK

Source: https://docs.langchain.com/oss/javascript/langgraph/local-server

Install the LangGraph JS SDK before using the JavaScript client.

```bash
npm install @langchain/langgraph-sdk

```

--------------------------------

### Output of entrypoint nodes and channels

Source: https://docs.langchain.com/oss/javascript/langgraph/pregel

Example output from the entrypoint example showing the nodes and channels of the Pregel instance. Nodes contain the writeEssay PregelNode; channels include __start__, __end__, and __previous__.

```typescript
Nodes:
{ writeEssay: PregelNode { ... } }
Channels:
{
  __start__: EphemeralValue { ... },
  __end__: LastValue { ... },
  __previous__: LastValue { ... }
}

```

--------------------------------

### Example langgraph.json configuration

Source: https://docs.langchain.com/oss/javascript/langgraph/application-structure

Example configuration file that specifies dependencies, a single graph loaded from ./your_package/your_file.js with the function agent, and an inline environment variable OPENAI_API_KEY.

```json
{
  "dependencies": ["."],
  "graphs": {
    "my_agent": "./your_package/your_file.js:agent"
  },
  "env": {
    "OPENAI_API_KEY": "secret-key"
  }
}

```

--------------------------------

### Install @langchain/langgraph and @langchain/core

Source: https://docs.langchain.com/oss/javascript/langgraph/overview

Install the LangGraph and LangChain core packages using your preferred package manager. These commands are equivalent alternatives; choose one based on your environment.

```bash
npm install @langchain/langgraph @langchain/core

```

```bash
pnpm add @langchain/langgraph @langchain/core

```

```bash
yarn add @langchain/langgraph @langchain/core

```

```bash
bun add @langchain/langgraph @langchain/core

```

--------------------------------

### Install LangGraph and Core with npm

Source: https://docs.langchain.com/oss/javascript/langgraph/install

Use npm to install the base LangGraph package and @langchain/core.

```bash
npm install @langchain/langgraph @langchain/core

```

--------------------------------

### Install LangGraph and Core with yarn

Source: https://docs.langchain.com/oss/javascript/langgraph/install

Use yarn to install the base LangGraph package and @langchain/core.

```bash
yarn add @langchain/langgraph @langchain/core

```

--------------------------------

### Hello world StateGraph example

Source: https://docs.langchain.com/oss/javascript/langgraph/overview

Create a minimal LangGraph state graph with a single mock LLM node that returns a fixed message. Invoke it with a user message to see the 'hello world' response. This example demonstrates the core StateGraph API: defining state, adding nodes and edges, compiling, and invoking.

```typescript
import { StateSchema, MessagesValue, type GraphNode, StateGraph, START, END } from "@langchain/langgraph";

const State = new StateSchema({
  messages: MessagesValue,
});

const mockLlm: GraphNode<typeof State> = (state) => {
  return { messages: [{ role: "ai", content: "hello world" }] };
};

const graph = new StateGraph(State)
  .addNode("mock_llm", mockLlm)
  .addEdge(START, "mock_llm")
  .addEdge("mock_llm", END)
  .compile();

await graph.invoke({ messages: [{ role: "user", content: "hi!" }] });

```

--------------------------------

### Install LangGraph and Core with pnpm

Source: https://docs.langchain.com/oss/javascript/langgraph/install

Use pnpm to install the base LangGraph package and @langchain/core.

```bash
pnpm add @langchain/langgraph @langchain/core

```

--------------------------------

### Install LangGraph SDK

Source: https://docs.langchain.com/oss/javascript/langgraph/deploy

Install the LangGraph SDK for TypeScript before sending messages to your deployed agent.

```bash
npm install @langchain/langgraph-sdk
```

--------------------------------

### Example: using MongoDB checkpointer

Source: https://docs.langchain.com/oss/javascript/langgraph/add-memory

Complete example of using MongoDBSaver with a LangGraph agent. Requires a MongoDB cluster and the @langchain/langgraph-checkpoint-mongodb package. The example shows a simple agent that remembers the user's name across two turns.

```bash
npm install @langchain/langgraph-checkpoint-mongodb
```

```typescript
import { ChatAnthropic } from "@langchain/anthropic";
import { StateGraph, StateSchema, MessagesValue, GraphNode, START } from "@langchain/langgraph";
import { MongoDBSaver } from "@langchain/langgraph-checkpoint-mongodb";
import { MongoClient } from "mongodb";

const State = new StateSchema({
  messages: MessagesValue,
});

const model = new ChatAnthropic({ model: "claude-haiku-4-5-20251001" });

const client = new MongoClient("mongodb://user:password@localhost:27017");
const checkpointer = new MongoDBSaver({ client, dbName: "langgraph" });

const callModel: GraphNode<typeof State> = async (state) => {
  const response = await model.invoke(state.messages);
  return { messages: [response] };
};

const builder = new StateGraph(State)
  .addNode("call_model", callModel)
  .addEdge(START, "call_model");

const graph = builder.compile({ checkpointer });

const config = { configurable: { thread_id: "1" } };

const stream1 = await graph.streamEvents(
  { messages: [{ role: "user", content: "hi! I'm bob" }] },
  { ...config, version: "v3" }
);
for await (const snapshot of stream1.values) {
  console.log(snapshot);
}

const stream2 = await graph.streamEvents(
  { messages: [{ role: "user", content: "what's my name?" }] },
  { ...config, version: "v3" }
);
for await (const snapshot of stream2.values) {
  console.log(snapshot);
}
```

--------------------------------

### Install Vitest dependency

Source: https://docs.langchain.com/oss/javascript/langgraph/test

Installs Vitest as a development dependency for running unit tests.

```bash
$ npm install -D vitest

```

--------------------------------

### Specify model and system message at runtime

Source: https://docs.langchain.com/oss/javascript/langgraph/use-graph-api

Extends the runtime configuration example to set both the model provider and a system message via configurable keys. When systemMessage is provided, a SystemMessage is prepended to the conversation. The example invokes with OpenAI and "Respond in Italian." and prints each message type and content.

```typescript
import { ChatOpenAI } from "@langchain/openai";
import { ChatAnthropic } from "@langchain/anthropic";
import { SystemMessage } from "@langchain/core/messages";
import { StateGraph, StateSchema, MessagesValue, GraphNode, START, END } from "@langchain/langgraph";
import * as z from "zod";

const ConfigSchema = z.object({
  modelProvider: z.string().default("anthropic"),
  systemMessage: z.string().optional(),
});

const State = new StateSchema({
  messages: MessagesValue,
});

const MODELS = {
  anthropic: new ChatAnthropic({ model: "claude-haiku-4-5-20251001" }),
  openai: new ChatOpenAI({ model: "gpt-5.4-mini" }),
};

const callModel: GraphNode<typeof State> = async (state, config) => {
  const modelProvider = config?.configurable?.modelProvider || "anthropic";
  const systemMessage = config?.configurable?.systemMessage;

  const model = MODELS[modelProvider as keyof typeof MODELS];
  let messages = state.messages;

  if (systemMessage) {
    messages = [new SystemMessage(systemMessage), ...messages];
  }

  const response = await model.invoke(messages);
  return { messages: [response] };
};

const graph = new StateGraph(State, ConfigSchema)
  .addNode("model", callModel)
  .addEdge(START, "model")
  .addEdge("model", END)
  .compile();

// Usage
const inputMessage = { role: "user", content: "hi" };
const response = await graph.invoke(
  { messages: [inputMessage] },
  {
    configurable: {
      modelProvider: "openai",
      systemMessage: "Respond in Italian."
    }
  }
);

for (const message of response.messages) {
  console.log(`${message.getType()}: ${message.content}`);
}
```

--------------------------------

### Extended example: simple workflow with tasks

Source: https://docs.langchain.com/oss/javascript/langgraph/use-functional-api

Extended example showing a workflow with two `task` functions (`isEven` and `formatMessage`) and an `entrypoint`. Uses a `MemorySaver` checkpointer and a unique `thread_id` for persistence. Invokes the workflow with `{ number: 7 }` and logs the result.

```typescript
import { v7 as uuid7 } from "uuid";
import { entrypoint, task, MemorySaver } from "@langchain/langgraph";

// Task that checks if a number is even
const isEven = task("isEven", async (number: number) => {
  return number % 2 === 0;
});

// Task that formats a message
const formatMessage = task("formatMessage", async (isEven: boolean) => {
  return isEven ? "The number is even." : "The number is odd.";
});

// Create a checkpointer for persistence
const checkpointer = new MemorySaver();

const workflow = entrypoint(
  { checkpointer, name: "workflow" },
  async (inputs: { number: number }) => {
    // Simple workflow to classify a number
    const even = await isEven(inputs.number);
    return await formatMessage(even);
  }
);

// Run the workflow with a unique thread ID
const config = { configurable: { thread_id: uuid7() } };
const result = await workflow.invoke({ number: 7 }, config);
console.log(result);
```

--------------------------------

### Set the entry point with addEdge from START

Source: https://docs.langchain.com/oss/javascript/langgraph/graph-api

Sets the entry point of the graph by adding an edge from the virtual START node to the first node to execute.

```typescript
import { START } from "@langchain/langgraph";

graph.addEdge(START, "nodeA");
```

--------------------------------

### Example langgraph.json output

Source: https://docs.langchain.com/oss/javascript/langgraph/local-server

Example output from the 'npm create langgraph config' command. It shows a configuration with node version, graphs mapping to agent files, and an env file. Only exported agents are included; warnings are issued for non-exported agents.

```json
{
  "node_version": "24",
  "graphs": {
    "agent": "./src/agent.ts:agent",
    "searchAgent": "./src/search.ts:searchAgent"
  },
  "env": ".env"
}

```

--------------------------------

### Full example with MessagesValue and OpenAI format input

Source: https://docs.langchain.com/oss/javascript/langgraph/use-graph-api

A complete example using MessagesValue to handle message updates, including accepting OpenAI format input. The output shows the message types and content.

```typescript
import { StateSchema, StateGraph, MessagesValue, GraphNode, START } from "@langchain/langgraph";
import * as z from "zod";

const State = new StateSchema({
  messages: MessagesValue,
  extraField: z.number(),
});

const node: GraphNode<typeof State> = (state) => {
  const newMessage = new AIMessage("Hello!");
  return { messages: [newMessage], extraField: 10 };
};

const graph = new StateGraph(State)
  .addNode("node", node)
  .addEdge(START, "node")
  .compile();

```

```typescript
const inputMessage = { role: "user", content: "Hi" };

const result = await graph.invoke({ messages: [inputMessage] });

for (const message of result.messages) {
  console.log(`${message.getType()}: ${message.content}`);
}

```

```text
human: Hi
ai: Hello!

```

--------------------------------

### Studio URL with custom baseUrl

Source: https://docs.langchain.com/oss/javascript/langgraph/local-server

Example Studio URL with a custom baseUrl for an Agent Server running on http://myhost:3000.

```plaintext
https://smith.langchain.com/studio/?baseUrl=http://myhost:3000
```

--------------------------------

### Output of graph.channels inspection

Source: https://docs.langchain.com/oss/javascript/langgraph/pregel

Example output from console.log(graph.channels) showing LastValue channels for state fields and EphemeralValue channels for internal branch and start nodes.

```typescript
{
  topic: LastValue { ... },
  content: LastValue { ... },
  score: LastValue { ... },
  __start__: EphemeralValue { ... },
  writeEssay: EphemeralValue { ... },
  scoreEssay: EphemeralValue { ... },
  'branch:__start__:__self__:writeEssay': EphemeralValue { ... },
  'branch:__start__:__self__:scoreEssay': EphemeralValue { ... },
  'branch:writeEssay:__self__:writeEssay': EphemeralValue { ... },
  'branch:writeEssay:__self__:scoreEssay': EphemeralValue { ... },
  'branch:scoreEssay:__self__:writeEssay': EphemeralValue { ... },
  'branch:scoreEssay:__self__:scoreEssay': EphemeralValue { ... },
  'start:writeEssay': EphemeralValue { ... }
}

```

--------------------------------

### Build a sequential graph with addNode and addEdge

Source: https://docs.langchain.com/oss/javascript/langgraph/use-graph-api

Builds a sequential graph with three nodes using addNode and addEdge, connecting START to step1 and chaining step1 to step2 to step3. This is the initial builder example before compilation.

```typescript
import { START, StateGraph } from "@langchain/langgraph";

const builder = new StateGraph(State)
  .addNode("step1", step1)
  .addNode("step2", step2)
  .addNode("step3", step3)
  .addEdge(START, "step1")
  .addEdge("step1", "step2")
  .addEdge("step2", "step3");

```

--------------------------------

### entrypoint with checkpointer

Source: https://docs.langchain.com/oss/javascript/langgraph/functional-api

Demonstrates how to define an entrypoint with a checkpointer and use getPreviousState to access state from previous invocations.

```APIDOC
## [entrypoint] [entrypoint with checkpointer]

### Description
Defines a workflow that stores state between invocations on the same thread ID using a checkpointer. The `getPreviousState` function retrieves the state from the previous invocation.

### Method
entrypoint

### Endpoint
entrypoint

### Parameters
#### Configuration
- **checkpointer** (object) - Required - The checkpointer instance used to persist state.
- **name** (string) - Required - The name of the workflow.

#### Input
- **number** (number) - Required - The input value to the workflow.

### Request Example
```typescript
const config = {
  configurable: {
    thread_id: "some_thread_id",
  },
};

await myWorkflow.invoke(1, config);
```

### Response
#### Success Response
- Returns the sum of the input number and the previous state (default 0).

#### Response Example
```typescript
// First invocation: 1 (previous was undefined)
// Second invocation: 3 (previous was 1)
```
```

--------------------------------

### Use PostgresStore in production

Source: https://docs.langchain.com/oss/javascript/langgraph/add-memory

In production, use a database-backed store. This example shows how to create a PostgresStore from a connection string and compile a graph with it.

```typescript
import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";

const DB_URI = "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
const store = PostgresStore.fromConnString(DB_URI);

const builder = new StateGraph(...);
const graph = builder.compile({ store });
```

--------------------------------

### Add edge from START node

Source: https://docs.langchain.com/oss/javascript/langgraph/graph-api

Shows how to reference the START node to define the first node(s) to execute in a graph. The START node represents the entry point that sends user input to the graph.

```typescript
import { START } from "@langchain/langgraph";

graph.addEdge(START, "nodeA");

```

--------------------------------

### Example conversation

Source: https://docs.langchain.com/oss/javascript/langgraph/use-graph-api

Example conversation showing a human greeting and an AI response in Italian.

```text
human: hi
ai: Ciao! Come posso aiutarti oggi?

```

--------------------------------

### Use MongoDBStore in production

Source: https://docs.langchain.com/oss/javascript/langgraph/add-memory

In production, use a database-backed store. This example shows how to create a MongoDBStore from a connection string and compile a graph with it.

```typescript
import { MongoDBStore } from "@langchain/langgraph-checkpoint-mongodb";

const MONGODB_URI = "mongodb://user:password@localhost:27017";
const store = await MongoDBStore.fromConnString(MONGODB_URI, {
  dbName: "langgraph",
  collectionName: "store",
});

const builder = new StateGraph(...);
const graph = builder.compile({ store });
```

--------------------------------

### Set a conditional entry point with addConditionalEdges from START

Source: https://docs.langchain.com/oss/javascript/langgraph/graph-api

Sets a conditional entry point by adding a conditional edge from the virtual START node, allowing the graph to start at different nodes based on the routingFunction's return value.

```typescript
import { START } from "@langchain/langgraph";

graph.addConditionalEdges(START, routingFunction);
```

--------------------------------

### Create a Pregel application with entrypoint

Source: https://docs.langchain.com/oss/javascript/langgraph/pregel

Creates a Pregel application using the Functional API with the entrypoint decorator. Uses a MemorySaver checkpointer and defines an async function that returns content. Then prints the nodes and channels of the resulting Pregel instance.

```typescript
import { MemorySaver } from "@langchain/langgraph";
import { entrypoint } from "@langchain/langgraph/func";

interface Essay {
  topic: string;
  content?: string;
  score?: number;
}

const checkpointer = new MemorySaver();

const writeEssay = entrypoint(
  { checkpointer, name: "writeEssay" },
  async (essay: Essay) => {
    return {
      content: `Essay about ${essay.topic}`,
    };
  }
);

console.log("Nodes: ");
console.log(writeEssay.nodes);
console.log("Channels: ");
console.log(writeEssay.channels);

```

--------------------------------

### Install LangChain with npm

Source: https://docs.langchain.com/oss/javascript/langgraph/install

Use npm to install the LangChain package, which is commonly used with LangGraph for LLM and tool access.

```bash
npm install langchain

```

--------------------------------

### Step 6: Build, compile, and run complete agent

Source: https://docs.langchain.com/oss/javascript/langgraph/quickstart

Creates the complete StateGraph, compiles it into an executable agent, and invokes it with a HumanMessage query.

```javascript
// Step 6: Build and compile the agent
import { HumanMessage } from "@langchain/core/messages";
import { StateGraph, START, END } from "@langchain/langgraph";

const agent = new StateGraph(MessagesState)
  .addNode("llmCall", llmCall)
  .addNode("toolNode", toolNode)
  .addEdge(START, "llmCall")
  .addConditionalEdges("llmCall", shouldContinue, ["toolNode", END])
  .addEdge("toolNode", "llmCall")
  .compile();

// Invoke
const result = await agent.invoke({
  messages: [new HumanMessage("Add 3 and 4.")],
});

for (const message of result.messages) {
  console.log(`[${message.type}]: ${message.text}`);
}
```

--------------------------------

### Install LangGraph CLI

Source: https://docs.langchain.com/oss/javascript/langgraph/local-server

Install the LangGraph CLI as a dev dependency using npm. This is required to run and manage LangGraph applications locally.

```bash
npm install --save-dev @langchain/langgraph-cli

```

--------------------------------

### Install dependencies in edit mode

Source: https://docs.langchain.com/oss/javascript/langgraph/local-server

Navigate to the root of your new LangGraph app and install dependencies in edit mode so your local changes are used by the server.

```bash
cd path/to/your/app
npm install

```

--------------------------------

### Create a simple workflow with entrypoint

Source: https://docs.langchain.com/oss/javascript/langgraph/use-functional-api

Defines a simple workflow using the `entrypoint` function with a `MemorySaver` checkpointer. Input is restricted to the first argument, so multiple inputs are passed as a dictionary. Invokes the workflow with `{ value: 1, anotherValue: 2 }`.

```typescript
const checkpointer = new MemorySaver();

const myWorkflow = entrypoint(
  { checkpointer, name: "myWorkflow" },
  async (inputs: { value: number; anotherValue: number }) => {
    const value = inputs.value;
    const anotherValue = inputs.anotherValue;
    // ...
  }
);

await myWorkflow.invoke({ value: 1, anotherValue: 2 });
```
Tokens:
Raw