Quickstart

Build your first LangGraph application in under 5 minutes

Quickstart

This guide will get you up and running with LangGraph in under 5 minutes. You’ll create a simple stateful workflow that demonstrates the core concepts of graphs, nodes, edges, and state.

Prerequisites

Before you begin, make sure you have:

• Python 3.10 or higher installed
• Basic familiarity with Python and type hints

If you haven’t installed LangGraph yet, check out the Installation Guide.

Your First LangGraph Application

Let’s build a simple workflow that processes text through multiple nodes.

Complete Example

Here’s the full code in one place:

from langgraph.graph import START, StateGraph
from typing_extensions import TypedDict


class State(TypedDict):
    text: str


def node_a(state: State) -> dict:
    return {"text": state["text"] + "a"}


def node_b(state: State) -> dict:
    return {"text": state["text"] + "b"}


graph = StateGraph(State)
graph.add_node("node_a", node_a)
graph.add_node("node_b", node_b)
graph.add_edge(START, "node_a")
graph.add_edge("node_a", "node_b")

app = graph.compile()

print(app.invoke({"text": ""}))
# Output: {'text': 'ab'}

Expected Output

When you run this code, you’ll see:

{'text': 'ab'}

The workflow:

1. Starts with an empty string ""
2. node_a appends "a" → "a"
3. node_b appends "b" → "ab"

Understanding the Flow

Building a Conditional Workflow

Let’s extend the example with conditional routing:

from langgraph.graph import START, END, StateGraph
from typing_extensions import TypedDict


class State(TypedDict):
    text: str
    count: int


def increment(state: State) -> dict:
    return {"count": state["count"] + 1}


def should_continue(state: State) -> str:
    if state["count"] < 3:
        return "increment"
    return END


graph = StateGraph(State)
graph.add_node("increment", increment)
graph.add_edge(START, "increment")
graph.add_conditional_edges("increment", should_continue)

app = graph.compile()

result = app.invoke({"text": "hello", "count": 0})
print(result)
# Output: {'text': 'hello', 'count': 3}

This creates a loop that increments count until it reaches 3.

Next Steps

Now that you’ve built your first LangGraph application, explore more advanced features:

Core Concepts

Learn about state management, reducers, and graph patterns

Checkpointing

Add persistence and enable time-travel debugging

Human-in-the-Loop

Pause execution for human approval or input

Examples

Explore real-world LangGraph applications

Want to build AI agents quickly? Check out create_react_agent for a high-level API built on LangGraph.

Troubleshooting

Import Errors

If you see ModuleNotFoundError, ensure LangGraph is installed:

pip install langgraph

Type Errors

Make sure you’re using typing_extensions.TypedDict (not typing.TypedDict) for Python 3.10 compatibility:

from typing_extensions import TypedDict

State Not Updating

Remember that node functions should return dictionaries with the keys to update:

# Correct
def my_node(state: State) -> dict:
    return {"text": "new value"}

# Incorrect - returns the full state
def my_node(state: State) -> State:
    state["text"] = "new value"
    return state

Get Help

Need assistance? Here are some resources:

• LangChain Forum - Community Q&A
• GitHub Issues - Bug reports and feature requests
• LangChain Academy - Free structured course