LangChain+LangGraph架构拆解：基于复杂AI任务编排与状态管理的混元大模型应用开发21.4

​一、前言

基本上我们接触大模型应用开发，一开始都是从调用API入门的。简单测一测问答、文本生成，轻轻松松就能实现一个基础应用，上手门槛很低。但真正想落地到实际项目时，大家都会碰到同一个棘手问题：单纯的API调用太“单薄”，根本撑不起复杂业务。一旦需要实现联网检索、工具调用、多步推理、循环纠错、多智能体协作这类高阶功能，原生API的短板就会彻底暴露。如果纯手写代码实现，不仅逻辑杂乱、重复代码多，后期维护、迭代、调试都会非常困难，完全达不到生产环境的落地标准。

大模型的应用开发绕不开LangChain和LangGraph两大框架的使用，不管是实际应用还是学习了解，这两大框架都至关重要，今天我们结合实际由浅入深拆解两套框架的核心逻辑、架构差异和落地场景。从最简单的线性链式开发，逐步过渡到进阶图式编排，一起探讨LangChain的能力边界、LangGraph的核心价值。

二、框架核心定位

1. LangChain定位

LangChain是目前大模型应用开发最主流的基础开源框架，核心定位是简化大模型应用快速开发。它的本质是一套标准化的组件库与开发规范，解决了原生大模型API能力单一、开发重复度高的问题，让我们不用重复造轮子。具体价值与核心设计特点：

解决原生开发痛点：

• 在没有LangChain之前，我们想要实现提示词模板封装、对话记忆、工具调用、文档问答、链路串联等功能，需要手动编写大量冗余代码，适配不同模型、不同场景的逻辑，开发效率极低。
• 而LangChain将大模型开发过程中高频使用的能力，全部封装为标准化、可复用的组件，我们只需按需调用、自由组合，就能快速搭建各类大模型应用。

核心链式设计理念：

• LangChain的核心设计理念是链式执行，也就是线性流水线逻辑。
• 简单来说，就是任务按照固定顺序依次执行，A步骤执行完成后，输出结果作为B步骤的输入，层层递进，形成完整的任务链路。
• 这种设计的优势极其明显，就是上手简单、逻辑清晰、开发速度快，非常适合基础入门。

但它的短板也同样突出，也是LangGraph诞生的核心契机，核心局限集中在两方面：

流程逻辑固化：

• 线性链式结构无法支持复杂的业务逻辑，不适配任务分支判断、循环重试、多路径并行、动态流程调整等场景。

扩展性与可控性差：

• 一旦应用场景脱离简单的单轮问答、固定流程任务，LangChain的传统链式架构就会显得力不从心，代码扩展性和可控性会大幅下降，无法支撑生产级复杂AI应用开发。

2. LangGraph定位

LangGraph是LangChain的进阶编排框架与运行时，完美兼容LangChain所有组件，是对LangChain能力的底层升级。

2.1 核心业务定位

LangGraph的核心定位是复杂、有状态、可循环的AI智能体编排，专门解决LangChain线性流程无法实现的复杂任务场景，聚焦生产级智能体、多轮复杂任务、多智能体协作等高阶场景。

2.2 核心设计革新

它彻底摒弃了LangChain固定线性链式的执行逻辑，采用有向状态图的设计思想，把AI任务的每一个执行单元定义为节点，把任务流转规则定义为边，通过节点和边的自由组合，实现任意复杂的任务流程。

2.3 核心能力突破

相比于LangChain的线性执行，LangGraph最大的突破是引入了全局状态管理和动态流程控制。在LangGraph中，所有节点共享统一的全局状态，节点可以读取状态数据、处理逻辑、更新状态，同时支持根据状态结果动态判断下一步执行路径，轻松实现分支、循环、重试、并行、回滚等复杂逻辑。

两者并非替代关系，而是互补适配的技术组合，场景划分清晰，新手可直接对照选用：

LangChain适配场景：

• 适合快速开发简单、固定流程的大模型Demo与轻量化应用，主打快速落地、低门槛迭代。

LangGraph适配场景：

• 适合开发生产级、高可控、复杂逻辑的AI智能体、多轮任务系统、多智能体协作应用，主打复杂流程、自主决策、工程化落地。

2.3 核心关系总结

二者是基础与进阶、简单与复杂、快速迭代与工程落地的互补关系，可搭配使用搭建完整大模型应用架构。

三、LangChain架构

1. 核心基础组件

想要用好LangChain，首先要吃透它的核心组件。所有LangChain应用，都是基于以下五大基础组件组合搭建而成，每个组件各司其职、标准化解耦，极大降低了开发难度，五大核心组件详细说明如下：

1.1 大模型组件（LLM/ChatModel）

该组件是AI应用的核心算力支撑，具备极强的通用性与兼容性，核心能力分为三点：

• 1. 模型全覆盖，LangChain统一封装了市面上几乎所有主流大模型接口，无需开发者单独适配各类模型API格式。
• 2. 极简切换，只需简单修改模型参数，即可完成模型替换，适配不同业务需求。
• 3. 场景细分，区分了普通文本生成LLM和对话模型ChatModel，分别适配单轮文本生成、多轮连续对话两类核心场景。

1.2 提示词组件（Prompt）

该组件专门用于标准化提示词管理，解决原生开发的各类痛点，核心价值分为三点：

• 1. 解决传统弊端，规避手动编写提示词冗余、不可复用、难以统一维护的问题。
• 2. 支持动态生成，可预设固定业务模板，通过传入动态变量，快速生成定制化提示词。
• 3. 适配对话场景，支持自动拼接对话历史、设定AI角色、限定任务执行规则，让提示词管理更规范、落地更高效。

1.3 记忆组件（Memory）

大模型本身无状态，无法自主记忆对话历史，Memory组件专门解决上下文留存、连续对话问题，核心能力分为三点：

• 1. 多模式适配，提供简单对话缓存、窗口记忆、摘要记忆、向量记忆等多种模式。
• 2. 场景全覆盖，可适配短时日常对话、长时连续对话、海量上下文长文本交互等不同场景。
• 3. 简化开发，无需开发者手动拼接历史对话，自动完成上下文留存与更新，轻松实现连贯多轮对话。

1.4 工具组件（Tools）

该组件核心作用是拓展大模型能力边界，打破模型固有知识与能力局限，核心优势分为三点：

• 1. 拓展外部能力，支持联网搜索、代码执行、文件读取、数据库查询、计算器运算等各类外部操作。
• 2. 开箱即用，LangChain内置大量高频常用工具，无需重复开发。
• 3. 高度自定义，支持开发者将任意专属业务逻辑封装为自定义工具，供大模型自主识别、调用，适配个性化业务场景。

1.5 链路组件（Chain）

该组件是LangChain的核心执行载体，承担组件串联、任务执行的核心作用，核心功能分为三点：

• 1. 核心功能，可将模型、提示词、记忆、工具等所有零散组件串联，形成完整闭环的任务执行链路。
• 二是极简编码，依托LCEL语法，可极简编写链路逻辑，无需大量冗余代码。
• 三是自动化执行，实现“提示词输入-模型推理-结果解析输出”的全自动化流程，是新手开发最核心、最常用的组件。

2. 完整执行流程

基于LangChain开发轻量化大模型应用，拥有标准化、固定化的开发流程，整体分为四大步骤：

1. 环境初始化

• 安装LangChain核心依赖库，配置大模型密钥、接口地址、超时参数等基础配置，完成整体开发环境的适配与初始化。

2. 组件定义

• 根据具体业务需求，按需定义所需的提示词模板、对话记忆模式、工具集合、模型参数等核心组件，完成能力储备。

3. 链路组装

• 通过Chain核心组件，将所有定义好的基础组件按照线性业务顺序串联，搭建完整的任务执行流程。

4. 执行与解析

• 调用组装完成的链路，触发模型推理与任务执行，对输出结果进行解析、格式化处理，最终完成应用功能落地。

3. LangChain优缺点

LangChain线性开发模式的核心优势十分突出，非常适合新手入门和轻量化项目落地，核心优势：

• 低门槛、高效率：所有核心组件均已封装完毕，无需开发者重复造轮子，几行核心代码即可实现复杂基础AI功能，快速完成Demo搭建与原型验证。
• 标准化解耦设计：各组件独立可替换、互不耦合，修改提示词、切换大模型、新增工具能力，不会影响整体链路逻辑，迭代灵活度高。
• 生态成熟稳定：LangChain开源生态完善，官方文档详实，社区案例丰富，开发过程中遇到的各类问题均可快速检索解决，问题排查成本极低。

与此同时，LangChain的局限性也非常明显，在生产级复杂项目中会被无限放大，核心短板：

• 流程逻辑死板：固定线性执行逻辑，不支持分支判断，无法根据任务实时执行结果动态调整流程路径，仅适配固定流程场景。
• 无统一全局状态：多步骤任务中，上下文、中间数据依靠组件单独传递，数据零散混乱，容易出现上下文断层、数据不一致的问题，长流程维护难度极高。
• 复杂能力缺失：原生不支持循环重试、异常回滚、多任务并行等核心能力，完全无法适配AI智能体自主决策、迭代纠错等复杂场景，仅适合简单轻量化开发。

4. 链式应用示例解析

该示例演示LangChain LCEL链式开发核心模式：通过|操作符将提示词模板、大模型推理、输出解析器串联为固定处理链路，展示组件初始化→链式组装→逐步执行的完整流程，适合理解LangChain管道式架构。

import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 接入腾讯混元大模型（TokenHub平台）
api_key = os.environ.get('TENCENT_API_KEY')
model_name = "hy3-preview"

print("=" * 50)
print("  LangChain 链式开发 — 组件初始化")
print("=" * 50)

# 1. 初始化基础组件（LangChain核心能力）
print("\n[组件1] 初始化大模型...")
llm = ChatOpenAI(
    model=model_name,
    api_key=api_key,
    base_url="https://tokenhub.tencentmaas.com/v1",
)
print(f"  ✓ 模型: {model_name} | 端点: tokenhub.tencentmaas.com")

print("\n[组件2] 构建提示词模板...")
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是AI开发科普助手，回答简洁通俗，适合新手学习。"),
    ("human", "请简单讲解：{question}")
])
print(f"  ✓ 系统角色: AI开发科普助手")
print(f"  ✓ 用户模板: 请简单讲解：{{question}}")

print("\n[组件3] 初始化输出解析器...")
parser = StrOutputParser()
print(f"  ✓ 解析器: StrOutputParser (纯文本输出)")

# 2. 链式组装（LCEL线性链路）
# 固定顺序：提示词 => 模型推理 => 结果解析
print("\n" + "=" * 50)
print("  链式组装 (LCEL)")
print("=" * 50)
chain = prompt | llm | parser
print("  组装顺序: 提示词模板 → 大模型推理 → 结果解析")
print("  操作符: prompt | llm | parser")

# 3. 执行固定流程任务
if __name__ == "__main__":
    user_question = "LangChain的链式架构特点是什么"

    print("\n" + "=" * 50)
    print("  链式调用执行")
    print("=" * 50)
    print(f"\n  [步骤1] 填充提示词模板")
    print(f"    输入问题: {user_question}")
    prompt_value = prompt.invoke({"question": user_question})
    print(f"    实际发送给模型的提示词:")
    for msg in prompt_value.messages:
        print(f"      [{msg.type}] {msg.content[:80]}...")

    print(f"\n  [步骤2] 大模型推理中 (hy3-preview)...")
    llm_output = llm.invoke(prompt_value)
    print(f"    模型原始输出: {llm_output.content[:80]}...")

    print(f"\n  [步骤3] 解析器提取纯文本...")
    res = parser.invoke(llm_output)
    print(f"    解析结果长度: {len(res)} 字")

    print(f"\n{'='*50}")
    print(f"  最终输出")
    print(f"{'='*50}")
    print(f"\n{res}")

输出结果：

================================================== LangChain 链式开发 — 组件初始化 ================================================== [组件1] 初始化大模型... ✓ 模型: hy3-preview | 端点: tokenhub.tencentmaas.com [组件2] 构建提示词模板... ✓ 系统角色: AI开发科普助手 ✓ 用户模板: 请简单讲解：{question} [组件3] 初始化输出解析器... ✓ 解析器: StrOutputParser (纯文本输出) ================================================== 链式组装 (LCEL) ================================================== 组装顺序: 提示词模板 → 大模型推理 → 结果解析 操作符: prompt | llm | parser ================================================== 链式调用执行 ================================================== [步骤1] 填充提示词模板 输入问题: LangChain的链式架构特点是什么 实际发送给模型的提示词: [system] 你是AI开发科普助手，回答简洁通俗，适合新手学习。... [human] 请简单讲解：LangChain的链式架构特点是什么... [步骤2] 大模型推理中 (hy3-preview)... 模型原始输出: LangChain的链式架构核心是**把复杂任务拆成多个小步骤，像串珠子一样连起来自动执行**，新手可以记住3个关键特点： 1. **模块化拼接**：每个步骤是... [步骤3] 解析器提取纯文本... 解析结果长度: 363 字 ================================================== 最终输出 ================================================== LangChain的链式架构核心是把复杂任务拆成多个小步骤，像串珠子一样连起来自动执行，新手可以记住3个关键特点： 1. 模块化拼接：每个步骤是独立的小模块（比如调大模型、查数据库、处理文本），你可以按需选模块、自由组合，不用从零写整个流程。 2. 自动流转：前一个模块的输出会自动传给下一个模块当输入，不用你手动写代码传参，比如「先查知识库→再让大模型根据结果回答」能自动跑通。 3. 灵活可扩展：想加新功能（比如加个翻译步骤、加个结果校验步骤）直接往链里插新模块就行，不用改原有逻辑。 举个简单例子：你做一个「文档问答」功能，链可以这么串： `读取文档模块 → 拆分文本模块 → 向量存储模块 → 检索相关片段模块 → 大模型回答模块` 整个流程自动走完，你只需要配置每个模块的参数就行。

四、LangGraph架构

1. 核心基础概念

LangGraph完全兼容LangChain所有组件，仅在执行架构上做了升级。掌握LangGraph架构设计之前，必须了解四大核心基础概念，这是所有图式智能体开发的核心根基，理解后即可快速上手复杂任务编排：

1.1 状态（State）

State是LangGraph的核心灵魂，是整个任务流程的全局共享数据快照，彻底解决LangChain数据零散的痛点，核心特性：

• 1. 统一数据存储，将任务数据、对话历史、中间结果、异常信息等所有流程数据统一收纳管理。
• 2. 多格式适配，支持字典、TypedDict、Pydantic模型等多种定义格式，可灵活适配各类复杂业务场景。
• 3. 全流程互通，所有节点均可自由读取、修改、更新全局状态，实现全流程数据无缝互通、高效流转。

1.2 节点（Node）

节点是LangGraph的最小执行单元，是所有业务逻辑的承载载体，核心特性：

• 1. 单元属性，本质是可执行的Python函数或LangChain可运行组件，可独立完成单一任务逻辑。
• 2. 场景细分，可自定义为大模型推理节点、工具调用节点、结果审核节点、数据解析节点等各类业务单元。
• 3. 迭代执行，节点接收全局状态作为输入，完成对应业务逻辑后，返回更新后的状态，实现任务迭代推进。

1.3 边（Edge）

边是节点之间的任务流转规则，决定整个流程的执行路径，分为两类核心形态：

• 普通边：固定流转规则，执行完A节点后直接进入B节点，对应LangChain的线性执行逻辑，适配固定流程场景。
• 条件边：动态流转规则，根据当前全局状态的实时结果，通过自定义判断逻辑，动态筛选下一步执行节点，可实现分支、分流、循环重试、异常回滚等复杂逻辑。

1.4 图（Graph）

图是LangGraph最终的任务编排载体，是整合所有逻辑的核心容器，核心能力：

• 1. 流程整合，通过整合全部节点、流转边，构建出完整的有向状态图，承载整套业务流程。
• 2. 自定义配置，开发者可自由实例化StateGraph、新增节点、配置流转规则、设置流程入口与出口。
• 3. 适配长周期任务，编译完成后可持续迭代执行，完美适配多步骤、长周期、需要自主迭代的智能体任务。

2. LangGraph优势

相比于LangChain的线性架构，LangGraph的图式架构完美解决了传统链式开发的所有痛点，也是其成为生产级智能体开发标准的核心原因，四大核心优势：

2.1 灵活的动态流程编排

• 彻底打破LangChain线性执行的固化限制，依托条件边可实现任意复杂的任务逻辑。
• 支持工具调用失败自动重试、推理结果不达标回溯重生成、不同用户问题智能分流、多任务并行执行等能力；
• 完全贴合真实、复杂、动态的业务场景，摆脱固定流程束缚。

2.2 统一全局状态管理

• 全流程共享唯一全局状态，所有中间数据、上下文信息、执行日志集中存储、统一管控。
• 既解决了传统开发数据零散、上下文混乱、数据丢失的问题；
• 又支持状态快照保存、手动回滚、全流程追溯，极大降低了问题排查难度，大幅提升应用稳定性与可维护性。

2.3 天然支持循环与迭代

• AI智能体的核心逻辑就是“思考-行动-观察-再思考”的循环迭代，LangGraph原生内置循环执行能力，完美适配智能体自主决策、自主纠错的核心场景。
• 例如智能体识别当前信息不足时，可自动调用工具补充数据，再重新推理校验，直至任务达标完成，这是LangChain无法实现的核心能力。

2.4 高可控的生产级特性

• LangGraph专为企业生产环境设计，自带各类工程化高阶能力。
• 支持任务断点续跑、异常捕获与自动重试、执行日志可视化、多智能体协同分工、流程权限管控等能力。
• 同时官方版本稳定，完全适配长期迭代、高稳定性要求的商业级大模型应用开发。

3. 图编排开发示例解析

该示例演示LangGraph图编排核心模式：通过全局状态管理、独立推理与补充节点、条件边动态分流，实现有状态的Agent工作流——回答不足时自动触发补充链路，展现图式编排相较于线性链式的灵活决策能力。

import os
from typing import TypedDict
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langgraph.graph import StateGraph, START, END

# 接入腾讯混元大模型（TokenHub平台）
api_key = os.environ.get('TENCENT_API_KEY')
model_name = "hy3-preview"

# 1. 定义全局状态（LangGraph核心：全局有状态）
class AgentState(TypedDict):
    query: str    # 用户输入
    answer: str   # 模型回答
    need_more: bool # 动态判断标记

print("=" * 50)
print("  LangGraph 图编排 — 组件初始化")
print("=" * 50)

# 2. 复用LangChain基础组件
print("\n[模型] 初始化大模型...")
llm = ChatOpenAI(
    model=model_name,
    api_key=api_key,
    base_url="https://tokenhub.tencentmaas.com/v1",
)
print(f"  ✓ {model_name} | tokenhub.tencentmaas.com")

print("\n[状态] 定义全局状态 Schema...")
print(f"  ✓ AgentState: query(str) + answer(str) + need_more(bool)")

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是AI开发科普助手，回答简洁通俗。"),
    ("human", "{query}")
])

# 3. 定义独立节点（单一职责）
def inference_node(state: AgentState):
    """模型推理节点"""
    print(f"\n  ┌─ 【节点: inference】推理节点 ─┐")
    print(f"  │  输入: {state['query'][:50]}...")
    res = prompt | llm
    answer = res.invoke({"query": state["query"]}).content
    # 动态设置状态：回答过短则需要补充内容
    need_more = len(answer) < 80
    print(f"  │  输出: {answer[:60]}...")
    print(f"  │  回答长度: {len(answer)} 字 (阈值80字)")
    print(f"  │  状态更新: need_more = {need_more}")
    print(f"  └─ 【inference 完成】──┘")
    return {"answer": answer, "need_more": need_more}

def supplement_node(state: AgentState):
    """内容补充节点（分支逻辑）"""
    print(f"\n  ┌─ 【节点: supplement】补充节点 ─┐")
    print(f"  │  原回答过短({len(state['answer'])}字)，触发补充流程")
    supplement_prompt = ChatPromptTemplate.from_messages([
        ("system", "请补充细化回答，讲得更详细易懂。"),
        ("human", "原问题：{query} 原回答：{answer}")
    ])
    res = supplement_prompt | llm
    new_answer = res.invoke({"query": state["query"], "answer": state["answer"]}).content
    print(f"  │  补充后长度: {len(new_answer)} 字")
    print(f"  └─ 【supplement 完成】──┘")
    return {"answer": new_answer}

# 4. 定义分支流转规则
def judge_branch(state: AgentState):
    """动态分支判断：是否需要补充内容"""
    if state["need_more"]:
        print(f"\n  → 条件判断: need_more=True → 路由到 [supplement]")
        return "supplement"
    print(f"\n  → 条件判断: need_more=False → 路由到 [END]")
    return "end"

# 5. 构建状态图工作流
print("\n" + "=" * 50)
print("  构建状态图工作流")
print("=" * 50)

graph = StateGraph(AgentState)
# 添加节点
graph.add_node("inference", inference_node)
graph.add_node("supplement", supplement_node)
print("  [节点] inference, supplement 已注册")

# 固定边：起始=>推理
graph.add_edge(START, "inference")
print("  [边] START → inference")

# 条件边：动态分流，实现分支逻辑
graph.add_conditional_edges(
    "inference",
    judge_branch,
    {"supplement": "supplement", "end": END}
)
print("  [条件边] inference → judge_branch → supplement / END")

# 补充节点执行完成后结束
graph.add_edge("supplement", END)
print("  [边] supplement → END")

# 编译运行
if __name__ == "__main__":
    print("\n" + "=" * 50)
    print("  编译并执行图工作流")
    print("=" * 50)
    run_graph = graph.compile()
    print("  ✓ 图编译完成")

    print(f"\n  输入问题: LangGraph和LangChain有什么区别")
    print(f"  {'─' * 40}")
    result = run_graph.invoke({"query": "LangGraph和LangChain有什么区别"})
    print(f"  {'─' * 40}")

    print(f"\n{'='*50}")
    print(f"  最终输出")
    print(f"{'='*50}")
    print(f"\n{result['answer']}")

输出结果：

================================================== LangGraph 图编排 — 组件初始化 ================================================== [模型] 初始化大模型... ✓ hy3-preview | tokenhub.tencentmaas.com [状态] 定义全局状态 Schema... ✓ AgentState: query(str) + answer(str) + need_more(bool) ================================================== 构建状态图工作流 ================================================== [节点] inference, supplement 已注册 [边] START → inference [条件边] inference → judge_branch → supplement / END [边] supplement → END ================================================== 编译并执行图工作流 ================================================== ✓ 图编译完成 输入问题: LangGraph和LangChain有什么区别 ──────────────────────────────────────── ┌─ 【节点: inference】推理节点 ─┐ │ 输入: LangGraph和LangChain有什么区别... │ 输出: LangChain是**基础框架**，提供大模型调用、工具集成、记忆等通用组件，帮你快速搭AI应用；LangGraph是... │ 回答长度: 169 字 (阈值80字) │ 状态更新: need_more = False └─ 【inference 完成】──┘ → 条件判断: need_more=False → 路由到 [END] ──────────────────────────────────────── ================================================== 最终输出 ================================================== LangChain是**基础框架**，提供大模型调用、工具集成、记忆等通用组件，帮你快速搭AI应用；LangGraph是**基于LangChain的扩展**，专门解决**复杂流程编排**问题，支持循环、分支、多角色协作等灵活逻辑。 一句话总结：LangChain是“积木零件”，LangGraph是用这些零件拼“复杂动态流程图”的工具。

五、框架差异与选型

1. 架构深度对比

1.1 执行模式差异

• LangChain：采用静态线性链式执行，任务执行流程在开发阶段就已固定，运行过程中无法动态修改执行路径，只能严格按照预设顺序依次执行，流程灵活性极低。
• LangGraph：采用动态图式执行，仅预设流程节点与基础规则，运行时可根据实时全局状态动态决策流转路径，支持任意结构的任务执行，灵活性拉满。

1.2 状态管理差异

• LangChain：无统一全局状态设计，上下文、中间数据依靠各组件单独传递，多步骤任务数据分散，极易出现上下文断层、数据不一致的问题，长流程任务维护难度极大。
• LangGraph：全局统一状态设计，全流程数据集中管控，支持状态追溯、手动修改、持久化存储，对长周期、多步骤复杂任务适配性极强。

1.3 流程能力差异

• LangChain：仅支持简单线性流程，无分支、无循环、无并行能力，只能完成固定单路径任务，无法实现智能体自主决策、纠错重试等核心能力。
• LangGraph：全能力覆盖，支持分支、循环、并行、回滚、重试、多路径动态流转，可模拟人类思考迭代过程，完美支撑各类复杂智能体业务逻辑。

1.4 开发与维护差异

• LangChain：上手门槛极低，代码简洁、开发速度快，轻量化任务迭代效率极高。但复杂场景下代码冗余严重、逻辑耦合度高，后续迭代、维护、优化难度大幅提升。
• LangGraph：存在一定学习成本，需要理解图编排思想。但代码结构清晰、模块化程度高，复杂业务逻辑分层明确，长期项目的维护与迭代成本更低。

2. 场景选型方案

理清架构差异后，结合业务场景精准选型，可避免大材小用或能力不足的问题，我们结合实际推荐一些标准化选型方案：

2.1 优先选用LangChain的场景

• 轻量化演示Demo、快速原型验证，需要短时间内落地基础大模型功能，快速验证创意可行性；
• 固定流程的简单应用，包含单轮文档问答、固定模板文本生成、简单知识库检索问答等标准化场景；
• 低复杂度工具调用任务，无需分支判断、循环迭代、动态流程调整的基础业务；
• 入门学习、小型测试项目，追求极致开发效率，降低学习与落地成本。

2.2 优先选用LangGraph的场景

• 各类AI智能体开发，包含任务拆解、自主工具调用、迭代纠错、多轮自主决策等核心智能体场景；
• 复杂业务流程，需要分支判断、动态分流、循环重试、异常回滚的生产级商用应用；
• 长周期任务开发，涵盖长文本处理、多步骤数据分析、自动化办公流程等耗时、多阶段任务；
• 多智能体协作系统，需要多个AI角色分工、协同配合、互补完成复杂综合任务；
• 企业级生产项目，对应用稳定性、可维护性、可扩展性、可追溯性有高标准要求。

六、应用架构设计

1. 分层架构设计

实际项目开发中，不会零散堆砌组件和节点，而是采用标准化分层架构，实现代码解耦、结构清晰、便于长期迭代维护。基于LangChain+LangGraph的组合架构，行业通用标准化分层方案分为四层，可适配绝大多数大模型应用场景，各层级职责如下：

1. 1 基础能力层

• 基于LangChain搭建底层通用能力底座，是整个架构的能力支撑核心。
• 统一封装模型调用、提示词模板、对话记忆、工具集合、向量检索、文档解析等高频通用能力。
• 所有基础组件统一管理、全局复用，彻底避免重复开发，为上层业务编排提供稳定、标准化的能力支撑。

1.2 流程编排层

• 基于LangGraph实现核心业务流程编排，是架构的核心调度层。
• 自定义全局状态结构、按功能拆分独立业务节点、配置节点流转边与分支判断规则。
• 将复杂臃肿的整体业务逻辑，拆解为多个单一职责的细分节点，实现逻辑彻底解耦，同时通过条件边实现灵活的动态流程控制。

1.3 业务逻辑层

• 承接编排层的通用能力，聚焦专属业务场景的定制化逻辑开发。
• 主要包含任务优先级判断、模型输出结果校验、全局异常捕获与处理、数据格式化清洗、业务权限校验等能力。
• 严格区分通用技术逻辑与专属业务逻辑，兼顾架构通用性与业务灵活性。

1.4 接口服务层

• 架构最外层落地载体，负责应用对外服务与工程化加固。
• 将搭建完成的图式AI应用封装为标准化API接口，可快速对接前端页面、后端业务系统、第三方平台。
• 同时配套日志记录、参数校验、限流熔断、超时处理、异常告警等工程化能力，完全满足生产环境部署与稳定运行要求。

2. 开发规范参考

想要搭建稳定、可迭代、可商用的生产级大模型应用，除了标准化分层架构，还需遵循五大核心开发规范，规避常见架构缺陷，保障项目长期稳定迭代：

2.1 节点单一职责原则

• 每个LangGraph节点仅实现一个核心功能，杜绝单节点逻辑臃肿、功能堆砌。
• 拆分后的节点可独立调试、修改、替换，最大限度降低代码耦合度，便于后期维护迭代。

2.2 精细化状态设计

• 结合业务场景自定义状态字段，精准区分输入参数、输出结果、中间过程数据、执行日志、异常信息等，避免状态冗余缺失、数据混乱，保证全局状态干净可用。

2.3 完善异常重试机制

• 针对工具调用失败、模型推理超时、参数异常、网络波动等高频问题，配置节点重试、流程回滚、友好异常提示机制，大幅提升应用运行稳定性与容错性。

2.4 可视化流程调试

• 充分利用LangGraph自带的流程可视化能力，实时查看节点流转路径、全局状态变化、执行耗时，快速排查流程卡顿、逻辑错误、数据异常等问题。

2.5 基础组件统一封装

• 所有LangChain基础组件统一初始化配置、统一管理，避免多处重复定义代码，方便后续统一升级模型、替换工具、优化提示词，降低迭代成本。

3. LangChain+LangGraph应用

该示例演示LangChain+LangGraph组合开发模式：LangChain负责提示词模板与模型推理的链式组装，LangGraph负责全局状态管理与图节点编排，两者协作实现有状态的智能问答工作流。

import os
from typing import TypedDict, Annotated
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langgraph.graph import StateGraph, START, END

# 接入腾讯混元大模型（TokenHub平台）
api_key = os.environ.get('TENCENT_API_KEY')
model_name = "hy3-preview"

# 1. 定义全局状态（LangGraph核心特性）
class GraphState(TypedDict):
    user_query: str   # 用户问题
    answer: str       # 模型输出结果

print("=" * 50)
print("  LangChain + LangGraph 组合开发 — 初始化")
print("=" * 50)

# 2. 初始化LangChain基础组件（模型+提示词）
print("\n[LangChain] 初始化基础组件...")
llm = ChatOpenAI(
    model=model_name,
    api_key=api_key,
    base_url="https://tokenhub.tencentmaas.com/v1",
)
print(f"  ✓ 大模型: {model_name}")
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是专业的AI开发助手，回答简洁通俗、适合新手理解。"),
    ("human", "{user_query}")
])
print(f"  ✓ 提示词模板: system角色 + human输入")

print("\n[LangGraph] 状态Schema...")
print(f"  ✓ GraphState: user_query(str) + answer(str)")

# 3. 定义图节点（业务执行单元）
def llm_infer_node(state: GraphState):
    """大模型推理节点（LangChain链式调用 + LangGraph状态管理）"""
    print(f"\n  ┌─ 【节点: llm_infer】推理执行 ─┐")
    print(f"  │  LangChain 提示词填充: {state['user_query'][:40]}...")
    # 组装提示词 + 模型推理
    chain = prompt | llm
    res = chain.invoke({"user_query": state["user_query"]})
    print(f"  │  模型返回: {res.content[:60]}...")
    print(f"  │  更新全局状态: answer字段写入")
    print(f"  └─ 【llm_infer 完成】──┘")
    # 更新全局状态
    return {"answer": res.content}

# 4. 构建LangGraph工作流
print("\n" + "=" * 50)
print("  构建图工作流")
print("=" * 50)

# 初始化状态图
graph_builder = StateGraph(GraphState)
# 添加执行节点
graph_builder.add_node("llm_infer", llm_infer_node)
print("  [节点] llm_infer 已注册")
# 设置执行流程：起始 → 推理节点 → 结束
graph_builder.add_edge(START, "llm_infer")
graph_builder.add_edge("llm_infer", END)
print("  [边] START → llm_infer → END")
print("  [架构] LangChain(链式推理) + LangGraph(状态图编排)")

# 编译图并执行
print("\n" + "=" * 50)
print("  编译并执行")
print("=" * 50)
graph = graph_builder.compile()
print("  ✓ 图编译完成\n")

# 测试运行
if __name__ == "__main__":
    user_q = "简单说说LangChain和LangGraph的区别"
    print(f"  [输入] {user_q}")
    print(f"  {'─' * 40}")
    result = graph.invoke({"user_query": user_q})
    print(f"  {'─' * 40}")

    print(f"\n{'='*50}")
    print(f"  最终输出")
    print(f"{'='*50}")
    print(f"\n{result['answer']}")

重点说明：

• 复用LangChain能力：模型调用、提示词模板全部使用LangChain原生组件，体现两套框架的兼容性与组合性。
• 落地LangGraph核心架构：自定义全局状态、拆分独立节点、配置流程边，完整复刻图式编排核心逻辑。

输出结果：

================================================== LangChain + LangGraph 组合开发 — 初始化 ================================================== [LangChain] 初始化基础组件... ✓ 大模型: hy3-preview ✓ 提示词模板: system角色 + human输入 [LangGraph] 状态Schema... ✓ GraphState: user_query(str) + answer(str) ================================================== 构建图工作流 ================================================== [节点] llm_infer 已注册 [边] START → llm_infer → END [架构] LangChain(链式推理) + LangGraph(状态图编排) ================================================== 编译并执行 ================================================== ✓ 图编译完成 [输入] 简单说说LangChain和LangGraph的区别 ──────────────────────────────────────── ┌─ 【节点: llm_infer】推理执行 ─┐ │ LangChain 提示词填充: 简单说说LangChain和LangGraph的区别... │ 模型返回: LangChain 和 LangGraph 都是用于构建 AI 应用的框架，但定位不同，可以简单理解为： │ 更新全局状态: answer字段写入 └─ 【llm_infer 完成】──┘ ──────────────────────────────────────── ================================================== 最终输出 ================================================== LangChain 和 LangGraph 都是用于构建 AI 应用的框架，但定位不同，可以简单理解为：LangChain - 定位：通用的 LLM 应用开发框架 - 核心思想：把 LLM 调用、工具、提示词、记忆等**模块化**，像搭积木一样组合成应用 - 适合场景：问答系统、文档检索（RAG）、简单 Agent、工具调用 - 特点：上手快，生态成熟，适合大多数常规 AI 应用 LangGraph - 定位：专注于**复杂流程和多步推理**的编排框架（基于 LangChain 生态） - 核心思想：用**图（Graph）** 来建模任务流程，支持循环、条件分支、多节点协作 - 适合场景：复杂 Agent、多步骤决策、需要状态管理和回溯的任务 - 特点：更灵活、可控，适合流程复杂、需要精细控制的场景 一句话总结 - LangChain：快速搭建常见 AI 功能 - LangGraph：精细编排复杂、多步、有状态的 AI 流程 如果你刚开始做 AI 应用，通常先学 LangChain；当流程变复杂、需要“图状”控制时，再引入 LangGraph。

七、总结

总的来说，LangChain是大模型应用基础组件框架，主打线性链式快速开发、轻量化Demo落地、新手入门；LangGraph是进阶图编排框架，主打动态流程、状态管理、复杂智能体开发、生产级落地。

二者并非对立替代关系，而是互补的完整技术组合体系，也是目前行业主流开发方案。底层基础能力依托LangChain实现，复杂业务流程编排依托LangGraph实现。随着了解的深入，我们也慢慢会聚焦本质，跳出API堆砌，大模型应用开发的核心本质，不是堆砌框架API，而是理解任务编排、状态管理、逻辑解耦的工程化思想。