LangGraph vs LangChain: what's the difference

LangGraph vs LangChain is a comparison every engineer building LLM workflows eventually faces. LangChain gives you composable chains, agents, and retrievers; LangGraph adds a stateful graph runtime that treats loops, branching, and human checkpoints as first-class constructs. The distinction stops being academic the moment your linear prompt sequence turns into a multi-step system that needs to remember state and recover from failure.

Capabilities

LangChain

LangChain abstracts the LLM call lifecycle: prompts, models, output parsers, memory, and agents. You wire these into sequences (SequentialChain), branches (RouterChain), or autonomous agents that pick tools. It excels at one-shot or few-shot pipelines where the control flow is mostly linear.

from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

llm = ChatOpenAI(model="gpt-4o-mini")
prompt = PromptTemplate.from_template("Classify sentiment: {text}")
chain = LLMChain(llm=llm, prompt=prompt)
print(chain.run("This graph runtime is fast"))

The agent abstraction can call tools, but the loop is hidden inside the agent executor. You get little visibility into intermediate state and no native support for arbitrary cyclic graphs.

LangGraph

LangGraph builds on LangChain primitives but models the workflow as a directed graph with typed state. Nodes are functions; edges can be conditional; cycles are explicit. It ships with persistence (checkpointers), allowing pause/resume and human-in-the-loop.

from langgraph.graph import StateGraph, END
from typing import TypedDict

class State(TypedDict):
    query: str
    attempts: int
    result: str

def call_model(state: State):
    # use any LangChain/ChatOpenAI here
    return {"result": "ok", "attempts": state["attempts"] + 1}

def should_retry(state: State) -> str:
    return "end" if state["attempts"] >= 3 else "retry"

g = StateGraph(State)
g.add_node("model", call_model)
g.add_conditional_edges("model", should_retry, {"retry": "model", "end": END})
app = g.compile()

The graph compiles to an executable that can be persisted to Postgres or Redis. That changes the class of problems you can ship: long-running research agents, multi-agent negotiation, and workflows that survive process restarts.

Price and cost model

Neither library charges a license fee; both are Apache 2.0. Your only direct cost is token usage at the model provider. LangGraph may require a backing store for checkpointers, but SQLite is sufficient for development and self-hosted Redis/Postgres for production—no imposed per-step fee.

The indirect cost difference is engineering time. LangChain’s higher-level helpers get you to a demo faster; LangGraph demands you define state schemas and node boundaries upfront, which pays off when the workflow grows.

Latency and throughput

Both frameworks add minimal CPU overhead relative to the network latency of the model call. LangChain’s AgentExecutor runs steps serially and blocks on each LLM response. LangGraph supports async node execution and can fan out to parallel branches when the graph topology allows.

Because both ultimately emit standard OpenAI-compatible HTTP requests, you can route them through an inference gateway. Point them at n4n.ai—one OpenAI-compatible endpoint covering 240+ models with automatic fallback on provider degradation—by setting openai_api_base, and the orchestration code stays identical while gaining per-token metering and cache-control forwarding.

For high-throughput batch jobs, LangGraph’s compiled graph with async I/O will saturate your rate limits better than a hand-rolled LangChain foreach loop, simply because the concurrency model is explicit rather than buried in callback handlers.

Ergonomics

LangChain favors magic: a single load_chain can reconstruct a pipeline from a hub repo. That magic breaks when you need custom control flow. Debugging a misbehaving ConversationChain often means reading library source.

LangGraph is verbose but transparent. Every transition is a function you can unit test. The trade-off is real: a three-step LangChain pipeline is five lines; the equivalent LangGraph is thirty. But the LangGraph version tells you exactly what state exists, what mutates it, and where it can loop.

# LangChain: implicit memory
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory()
chain = LLMChain(llm=llm, prompt=prompt, memory=memory)

# LangGraph: explicit state field
class ChatState(TypedDict):
    history: list[str]
    next: str

If your team is small and the problem is stable, LangChain’s brevity wins. If the workflow evolves weekly, LangGraph’s explicitness prevents regression hell.

Ecosystem

LangChain has the larger integration surface: hundreds of document loaders, vector stores, and tool wrappers. Most LangGraph examples reuse those same LangChain connectors, so you rarely lose access to a Slack loader or a Pinecone client.

LangGraph adds LangSmith tracing and LangServe deployment as first-class. Its smaller community means fewer StackOverflow answers, but the GitHub discussions are high-signal because the user base is building serious agent systems, not tutorials.

Limits

LangChain’s agent loop cannot natively express “wait 24 hours, then resume.” You hack that with external schedulers. Its memory abstractions leak when you need per-user isolation at scale.

LangGraph’s limits are different: it assumes you can model the problem as a state machine. If your workflow is genuinely amorphous—say, an open-ended creative brainstorm—forcing it into nodes and edges creates friction. The learning curve is also steeper; new hires need to understand reducers and checkpointer semantics before they can ship a fix.

Head-to-head summary

Which to choose

Prototype a RAG Q&A bot in an afternoon. Use LangChain. The RetrievalQA chain plus a vector store gets you a demo without defining a state schema.

Build a customer support agent that escalates to humans and resumes later. Use LangGraph. The checkpointer lets you persist the conversation across the overnight gap; conditional edges model the escalation policy.

Orchestrate three specialized models that critique each other’s output. LangGraph. The cyclic graph is the natural representation; LangChain would require a custom agent with fragile prompt engineering.

Wrap a single LLM call with a prompt template and ship it behind a REST API. LangChain alone is enough. Adding LangGraph here is bureaucracy.

Need fault-tolerant multi-agent research that survives pod restarts? LangGraph with a Postgres checkpointer. LangChain has no native answer.

Team of one, problem well-scoped. LangChain. Team of five maintaining evolving agent logic. LangGraph.

Pick the layer that matches the control flow complexity you actually have, not the one with the louder launch post.