DoneHub
0%

The Evolution of Agent Architecture: LangChain vs LangGraph

Posted on Edited on In Valine:

LangChain and LangGraph are the two most widely used frameworks in LLM application development. Developers often get confused about where each one fits: when should you reach for LangChain, when is LangGraph the right call, and can you use them together? This article breaks down the comparison across three dimensions: technical fundamentals, design motivation, and real-world usage.

The Short Version

LangChain is a parts library. LangGraph is the assembly blueprint.

  • LangChain: Provides the building blocks — LLM connectors, tool definitions, memory systems, vector retrievers, and other foundational components for assembling an LLM application.
  • LangGraph: Defines how those components are wired together, including loops, branches, state passing, and termination conditions.

They complement each other. The LangChain team built LangGraph to fill gaps in LangChain’s native Agent capabilities.

Origins and Growth of LangChain

Harrison Chase previously worked at Robust Intelligence (an AI safety company) and McKinsey. He released LangChain as an open-source project on GitHub in October 2022. By early 2023, LangChain Inc. was formally established with venture capital funding, transitioning from a community project to a commercial operation.

LangChain’s rapid rise came down to timing and pain point. Before ChatGPT even launched, it addressed a real problem: the fragmentation of LLM application development. Every developer had to solve the same problems from scratch — model API integration (OpenAI, Anthropic, and Cohere all had different interfaces), conversation memory management, external tool integration, document splitting and retrieval. LangChain abstracted these into standardized, configurable components so developers could stop reinventing the wheel.

Date Event Impact
2022.10 LangChain open-sourced Thousands of GitHub stars within weeks
2022.12 ChatGPT launches, LLM app demand explodes LangChain becomes the go-to framework
2023.01 LangChain Inc. founded, VC funding secured Commercial operations begin
2023.03 LCEL (LangChain Expression Language) released Cleaner chain composition
2023.06 LangSmith released Observability platform
2023.10 LangServe released Fast API deployment
2024.01 LangGraph released Solves the Agent loop problem

LangChain’s component system covers every stage of LLM application development. Models connects to various LLM providers, Prompts manages prompt templates, Memory provides conversational memory, Tools wraps external tool calls, Chains sequences multiple steps into pipelines, Agents makes LLM-driven tool-calling decisions, Retrieval supports document search for RAG, Output Parser handles response formatting, and Document Loaders connects to various data sources.

The Capability Boundary of the Chain Model

LangChain’s core abstraction is the Chain — multiple steps executed in a linear pipeline:

1
2
3
4
5
6
7
8
9
# LangChain LCEL syntax (chain composition)
chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | output_parser
)

result = chain.invoke("What is an Agent?")

This design is straightforward and easy to learn, with a mature component ecosystem. It works well for RAG, simple Q&A, and fixed-pipeline scenarios. But it has a fundamental limitation: no support for loops. Agents need the ReAct cycle (think → act → observe → think again), and LangChain’s chains can only flow in one direction. On top of that, the inability to dynamically choose paths based on intermediate results and the disconnect between state management and execution flow make LangChain inadequate for complex Agent work.

What Problem LangGraph Solves

LangChain provided AgentExecutor to handle Agent scenarios, but real-world usage exposed three core problems.

The first is the inability to truly loop. LangChain’s chains are linear — from A to B to C and then done. What an Agent needs is the ReAct cycle: think → act → observe → think again → act again, until the task is complete. AgentExecutor could only fake this with max_iterations as a hard cap, which is simulation rather than native support. The second problem is no control over flow branching. After an Agent executes a step, it might need to take different paths based on the result: succeed and terminate, fail and retry, or gather more information if the data is insufficient. LangChain’s chains simply cannot do this. The third problem is messy state management. An Agent needs to track “what did I just do” and “where am I in the process”, but LangChain’s Memory component is independent and cannot be bound to the execution flow.

In Q1 2024, the LangChain team released LangGraph. The core idea was to replace linear chains with a state machine built on a graph structure. LangGraph’s central abstraction is StateGraph: nodes represent computation steps, edges define transitions between nodes, and conditional edges dynamically determine the next step based on current state.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from langgraph.graph import StateGraph, END

# Define state
class AgentState(TypedDict):
    messages: list
    next_step: str

# Build the graph
graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)      # Agent thinking node
graph.add_node("tool", tool_node)        # Tool execution node
graph.add_node("check", check_node)      # Result checking node

# Define edges (transitions)
graph.add_edge("agent", "tool")
graph.add_edge("tool", "check")

# Conditional branching: decide next step based on check results
graph.add_conditional_edges("check",
    lambda state: state["next_step"],
    {"continue": "agent", "end": END}  # Loop back or terminate
)

# Compile and run
app = graph.compile()

LangGraph provides native solutions for all three problems. For looping, graph edges can point back to earlier nodes, naturally supporting the ReAct cycle. For flow branching, add_conditional_edges selects different paths based on state values with precise control. For state management, State is passed automatically between nodes, deeply integrated with the execution flow.

Date Event Impact
2024.Q1 LangGraph released Solves the Agent loop problem
2024.06 LangGraph Studio released Visual debugging tool
2024.08 Multi-Agent collaboration support Essential for complex systems
2025.01 LangGraph 0.3 released Streaming output, multi-tenancy, improved debugging

Technical Differences

Dimension LangChain LangGraph
Core Abstraction Chain (linear pipeline) StateGraph (state graph)
Execution Model Linear, one-directional flow Loops + branching, can cycle back
State Management Standalone Memory component State auto-passed between nodes
Flow Control Fixed order, no going back Conditional branches, parallelism, loops
Best For RAG, Q&A, fixed pipelines Agents, multi-step decision-making

LangChain’s execution model is unidirectional chain flow: input → Prompt → LLM → Parser → output. Each step runs once with no way to go back. LangGraph’s execution model is graph-based: Start → Agent thinks → selects Tool A or Tool B → Check evaluates results → based on conditions, either loop back to Agent or terminate. State flows automatically through the entire graph, and every node can read and modify the current state.

Code-Level Comparison

Take the scenario “have an Agent search for information, and search again if the information is insufficient.” The difference between the two approaches is clear.

The LangChain approach uses AgentExecutor to simulate looping, but can only rely on max_iterations as a hard limit with no precise control over when to stop:

1
2
3
4
5
6
7
8
9
# Can only simulate loops, limited by max_iterations
from langchain.agents import AgentExecutor

agent_executor = AgentExecutor(
    agent=agent,
    tools=[search_tool],
    max_iterations=5,  # Hard limit on iterations
    verbose=True
)

The LangGraph approach uses conditional edges to precisely control loop conditions, deciding whether to continue searching or stop based on actual search results:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from langgraph.graph import StateGraph, END

def check_result(state):
    # Precise judgment: is the information sufficient?
    if state["info_complete"]:
        return "end"
    else:
        return "continue"

graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("search", search_node)
graph.add_node("check", check_node)

# Precise control: loop or end based on check results
graph.add_edge("agent", "search")
graph.add_edge("search", "check")
graph.add_conditional_edges("check", check_result,
    {"continue": "agent", "end": END})

app = graph.compile()

One is brute-force limiting, the other is precise control. This is the fundamental design philosophy difference between the two architectures.

Choosing the Right Tool

Scenario Recommendation Reason
RAG applications LangChain Retrieve → Generate, fixed pipeline, no loops needed
Q&A chatbot LangChain User asks → LLM answers, simple linear flow
Document processing LangChain Read → Extract → Output, fixed steps
Quick prototyping LangChain Fast to start, many components, good for validating ideas
Real Agents LangGraph Needs ReAct loop (think → act → observe → think again)
Multi-step decisions LangGraph Need to decide what to do after each step
Complex workflows LangGraph Has branches, parallelism, and loops
Multi-Agent collaboration LangGraph Multiple Agents working together
Production-grade complex systems Both together LangGraph orchestrates flow, LangChain provides components

The decision criterion is straightforward: if your execution flow is fixed and can be completed in a single pass, use LangChain; if you need loops, branches, or state tracking, use LangGraph. During rapid prototyping, start with LangChain to validate the logic, then migrate to LangGraph when the flow gets complex. The migration cost is low because LangGraph directly reuses LangChain’s components.

Using Them Together

In real projects, LangChain and LangGraph are typically used in combination. LangChain provides the LLM connectors (ChatOpenAI, ChatAnthropic), tool definitions (@tool decorator), vector retrievers, and document loaders. LangGraph handles the orchestration of these components, defining the Agent’s thinking loop, conditional branches, and state management.

1
2
3
4
5
6
7
8
9
10
11
12
13
from langchain_openai import ChatOpenAI          # LangChain component
from langchain_community.tools import Tool       # LangChain component
from langgraph.graph import StateGraph, END      # LangGraph orchestration

# Use LangChain to define the parts
llm = ChatOpenAI(model="gpt-4o")
search_tool = Tool(name="search", func=search, description="Search the web")

# Use LangGraph to define the flow
graph = StateGraph(AgentState)
graph.add_node("agent", lambda s: llm.invoke(s["messages"]))
graph.add_node("tool", lambda s: search_tool.invoke(s["tool_input"]))
...

The division of labor is clean: LangChain solves “which components to use”, LangGraph solves “how to assemble and orchestrate them.”

Ecosystem Comparison

Ecosystem Component LangChain LangGraph
Documentation python.langchain.com/docs langchain-ai.github.io/langgraph
Debugging Tools LangSmith LangGraph Studio
Deployment LangServe LangGraph Platform
Community GitHub 90k+ stars GitHub 50k+ stars
Tutorials Extensive official tutorials Official tutorials + LangGraph Mastery Course

LangGraph 1.0 Release and Current State

On February 18, 2026, the LangChain team officially announced LangGraph 1.0. This release came a full two years after LangGraph’s initial publication, marking its transition from an experimental project to a production-grade stable release. LangGraph 1.0 is not a rewrite — it is a systematic consolidation and hardening built on two years of accumulated usage.

The core changes in LangGraph 1.0 fall into three areas. First, the Node class introduced in 0.2 is officially deprecated. Developers found it added mental overhead without clear benefits in practice, so the team is returning to a cleaner functional API. Second, the langchain integration package is officially deprecated. LangGraph was designed from the start to work with any LLM or framework, and it no longer needs to depend on the langchain package. The team recommends migrating to model provider packages like langchain-openai or langchain-anthropic, or using LangGraph’s BaseLanguageChatModel interface directly. Third, ToolMessage in langgraph.prebuilt is deprecated in favor of the unified langchain_core.messages.ToolMessage.

On the platform side, LangGraph 1.0’s companion tools also received significant updates. LangGraph Platform removed all deprecated APIs from the 0.2 era. LangGraph Server’s API version moved from 2024-10-18 to 2025-03-19. LangGraph Studio (now renamed LangGraph Workbench) dropped support for LangGraph Server 0.2 and 0.3. LangGraph SDK removed all deprecated APIs and old 2024 API versions, while also fixing return type errors for astream_events and stream_events in the Python SDK.

Another change worth noting: the langchain-openai package got a major version update. Version 0.3.x is officially deprecated in favor of 0.4.x, which is a native Pydantic 2 release that no longer depends on the Pydantic 1.x compatibility layer and has removed the langchain_core dependency (users need to install it separately). These changes reflect the LangChain ecosystem gradually shedding its Pydantic 1.x legacy.

Community reaction to LangGraph 1.0 is polarized. Positive reviews focus on API stability and production reliability — after two years of iteration, LangGraph is finally a framework you can trust in production. Negative reviews center on migration cost and abstraction complexity. Some developers argue that frequent breaking changes have increased maintenance burden, and LangGraph’s learning curve is steep compared to lighter alternatives like PydanticAI or Smolagents. Others point out that the “state graph” abstraction is over-engineered for Agent scenarios of moderate complexity.

For teams on LangGraph 0.3, the migration path to 1.0 is clear. Migrating from the Node class means converting class methods to plain functions with unchanged signatures. Migrating from the langchain integration package means switching to model-provider-specific packages or using the BaseLanguageChatModel interface directly. ToolMessage migration is a simple class name replacement. These changes are not massively destructive, but they do require going through the codebase to find every reference point.

Date Version Key Changes
2024.01 LangGraph 0.1 released Introduced StateGraph, solved the Agent loop problem
2024.06 LangGraph Studio released Visual debugging tool
2024.08 Multi-Agent collaboration support Essential for complex systems
2025.01 LangGraph 0.3 released Streaming output, multi-tenancy, improved debugging
2026.02 LangGraph 1.0 released API stabilization, deprecated Node class and langchain integration package

The LangGraph 1.0 release means the LangChain team has made a clear choice for the Agent framework direction: state graphs as the core abstraction, Pydantic 2 as the data layer foundation, and model provider packages replacing the monolithic integration layer. This tech stack should remain stable for the next year or two, which is good news for teams already on LangGraph — no more worrying about frequent breaking changes. For teams that have been watching from the sidelines, now is a reasonable time to get started. The API has converged and the documentation is maturing.

References

扫描二维码分享