2026年AI Agent框架选型指南：LangGraph vs Pydantic AI vs Claude Code

2026年7月，AI Agent开发已经从"能不能做"进入"怎么做才靠谱"的阶段。本文以实际代码为例，横向对比 LangGraph、Pydantic AI 和 Claude Code 三大主流方案，帮你找到最适合企业落地的技术路径。

前言：为什么2026年Agent框架选型比以往更重要？

2025年下半年，LangGraph 和 Pydantic AI 相继发布 1.0 正式版，标志着传统 Agent 框架从"实验阶段"正式迈入"生产就绪"。进入2026年，格局又发生了三个关键变化：

框架整合加速：LangChain 生态与各大模型厂商 SDK 深度绑定，Anthropic、OpenAI、Google 均推出了官方 Agent SDK
CLI Agent 取代 IDE 成为开发新范式：Claude Code、Continue.dev 等工具让开发者在终端直接与 AI 协作，Anthropic 数据显示使用 Agentic 编码工具的开发者单任务耗时虽略有减少，但代码产出量提升了 3-5 倍
多 Agent 互操作成为刚需：MCP（Model Context Protocol）等跨厂商互操作协议逐渐成为事实标准

在这三大变化下，技术团队面临一个核心问题：到底选哪个框架？

本文将从实战角度出发，用同一个业务场景——"智能客服工单处理 Agent"——分别用三个框架实现，给你最直观的对比。

三大框架定位速览

维度	LangGraph	Pydantic AI	Claude Code
核心定位	图结构工作流引擎	类型安全的 Agent SDK	CLI 原生编码 Agent
语言	Python / JS	Python	CLI（调用 Claude API）
适用场景	复杂多步骤流程、多Agent协作	API服务、数据管道、结构化输出	代码生成、重构、调试
学习曲线	中高（图状态机概念）	中低（Python原生）	低（自然语言交互）
多Agent支持	原生支持（Swarm/Supervisor）	支持（AgentGraph）	支持（子Agent/Background Agent）
记忆能力	检查点持久化	会话记忆 + 自定义存储	项目级上下文 + CLAUDE.md
Human-in-the-loop	原生 interrupt 机制	支持（通过工具验证）	Auto模式 / 手动确认模式
1.0发布时间	2025年初	2025年中	2025年初
许可证	MIT	MIT	Apache 2.0（SDK）

场景定义：智能客服工单处理 Agent

我们的对比场景是一个典型的企业级需求：

用户提交客服工单后，Agent 需要自动完成：意图识别 -> 情感分析 -> 分类路由 -> 生成回复建议 -> 人工审核（可选） -> 执行操作

这个场景涵盖了 Agent 开发的核心要素：多步骤决策、工具调用、人工干预、结构化输出。

实战一：LangGraph 实现

LangGraph 的核心思想是将 Agent 工作流建模为有向图，每个节点是一个处理函数，边定义流转逻辑。

安装依赖

pip install langgraph langchain-anthropic langchain-core

完整代码

import json
from typing import Annotated, TypedDict
from enum import Enum
from langgraph.graph import StateGraph, END, START
from langgraph.graph.message import add_messages
from langgraph.checkpoint.memory import MemorySaver
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, SystemMessage

# 定义状态
class TicketState(TypedDict):
    messages: Annotated[list, add_messages]
    intent: str
    sentiment: str
    category: str
    reply_draft: str
    needs_review: bool

class Intent(str, Enum):
    REFUND = "退款"
    TECH_SUPPORT = "技术支持"
    COMPLAINT = "投诉"
    INQUIRY = "咨询"

# 初始化模型
model = ChatAnthropic(model="claude-sonnet-4-20250514", temperature=0)

# 节点1：意图识别
def classify_intent(state: TicketState) -> dict:
    system_prompt = """你是一个客服意图分类器。分析用户消息，返回意图类型。
    可选意图：退款、技术支持、投诉、咨询。
    只返回意图名称，不要其他内容。"""
    
    response = model.invoke([
        SystemMessage(content=system_prompt),
        *state["messages"]
    ])
    return {"intent": response.content.strip()}

# 节点2：情感分析
def analyze_sentiment(state: TicketState) -> dict:
    system_prompt = """分析用户消息的情感倾向。
    返回：positive / neutral / negative。
    只返回情感标签。"""
    
    response = model.invoke([
        SystemMessage(content=system_prompt),
        *state["messages"]
    ])
    sentiment = response.content.strip()
    return {
        "sentiment": sentiment,
        "needs_review": sentiment == "negative"
    }

# 节点3：分类路由
def route_category(state: TicketState) -> dict:
    intent_category_map = {
        "退款": "财务",
        "技术支持": "技术",
        "投诉": "客诉",
        "咨询": "一般咨询"
    }
    category = intent_category_map.get(state["intent"], "其他")
    return {"category": category}

# 节点4：生成回复建议
def generate_reply(state: TicketState) -> dict:
    system_prompt = f"""你是一个专业的客服代表。
    用户意图：{state['intent']}
    情感倾向：{state['sentiment']}
    工单类别：{state['category']}
    
    请生成一条专业、有同理心的回复。回复要求：
    1. 确认用户的问题
    2. 提供解决方案或下一步操作指引
    3. 语气要{state['sentiment']}对应的风格（negative时需更诚恳）"""
    
    response = model.invoke([
        SystemMessage(content=system_prompt),
        *state["messages"]
    ])
    return {"reply_draft": response.content}

# 节点5：人工审核（条件节点）
def human_review(state: TicketState) -> dict:
    print(f"\n[需要人工审核] 情感: {state['sentiment']}")
    print(f"生成的回复：\n{state['reply_draft']}")
    print("\n请输入审核意见（输入 'approve' 批准，其他内容为修改意见）：")
    
    feedback = input("> ")
    if feedback.lower() == "approve":
        return {"needs_review": False}
    
    # 将修改意见加入消息历史重新生成
    return {
        "messages": [HumanMessage(content=f"人工审核反馈：{feedback}，请修改回复。")],
        "needs_review": False
    }

# 条件路由函数
def should_review(state: TicketState) -> str:
    return "review" if state.get("needs_review") else "finish"

# 构建图
def build_graph():
    graph = StateGraph(TicketState)
    
    # 添加节点
    graph.add_node("classify_intent", classify_intent)
    graph.add_node("analyze_sentiment", analyze_sentiment)
    graph.add_node("route_category", route_category)
    graph.add_node("generate_reply", generate_reply)
    graph.add_node("human_review", human_review)
    
    # 添加边
    graph.add_edge(START, "classify_intent")
    graph.add_edge("classify_intent", "analyze_sentiment")
    graph.add_edge("analyze_sentiment", "route_category")
    graph.add_edge("route_category", "generate_reply")
    graph.add_conditional_edges(
        "generate_reply",
        should_review,
        {
            "review": "human_review",
            "finish": END
        }
    )
    graph.add_edge("human_review", "generate_reply")
    
    # 使用内存检查点（支持状态持久化）
    memory = MemorySaver()
    return graph.compile(checkpointer=memory, interrupt_before=["human_review"])

# 运行
if __name__ == "__main__":
    app = build_graph()
    
    config = {"configurable": {"thread_id": "ticket-001"}}
    
    initial_state = {
        "messages": [HumanMessage(content="我买的耳机左边没有声音，已经用了不到一个月，非常生气！要求退款！")],
        "intent": "",
        "sentiment": "",
        "category": "",
        "reply_draft": "",
        "needs_review": False
    }
    
    # 运行到中断点（人工审核前）
    for event in app.stream(initial_state, config, stream_mode="values"):
        pass
    
    state = app.get_state(config)
    print(f"\n意图: {state.values.get('intent')}")
    print(f"情感: {state.values.get('sentiment')}")
    print(f"类别: {state.values.get('category')}")
    print(f"回复草稿: {state.values.get('reply_draft')}")
    
    # 恢复执行（批准）
    app.update_state(config, {"needs_review": False})
    for event in app.stream(None, config, stream_mode="values"):
        pass
    
    final_state = app.get_state(config)
    print(f"\n最终回复:\n{final_state.values.get('reply_draft')}")

LangGraph 核心优势

状态可恢复：检查点机制让长时间运行的 Agent 可以随时暂停/恢复
可视化调试：graph.get_graph().draw_mermaid() 可导出流程图
灵活的条件分支：add_conditional_edges 实现复杂的路由逻辑

实战二：Pydantic AI 实现

Pydantic AI 由 Pydantic 团队出品，核心优势是类型安全和极简的 API 设计，特别适合需要严格数据校验的场景。

安装依赖

pip install pydantic-ai anthropic

完整代码

from pydantic import BaseModel, Field
from pydantic_ai import Agent, RunContext
from pydantic_ai.models.anthropic import AnthropicModel
from enum import Enum
import asyncio

# 定义结构化输出模型
class Sentiment(str, Enum):
    POSITIVE = "positive"
    NEUTRAL = "neutral"
    NEGATIVE = "negative"

class Intent(str, Enum):
    REFUND = "退款"
    TECH_SUPPORT = "技术支持"
    COMPLAINT = "投诉"
    INQUIRY = "咨询"

class TicketAnalysis(BaseModel):
    """工单分析结果 - 强类型输出"""
    intent: Intent = Field(description="用户意图分类")
    sentiment: Sentiment = Field(description="用户情感倾向")
    category: str = Field(description="工单类别")
    confidence: float = Field(description="分析置信度 0-1")
    summary: str = Field(description="用户问题摘要")

class TicketReply(BaseModel):
    """回复建议 - 强类型输出"""
    reply_text: str = Field(description="回复内容")
    action_required: bool = Field(description="是否需要人工操作")
    escalation_level: int = Field(default=0, ge=0, le=3, description="升级级别 0-3")

# 定义依赖（可注入外部服务）
class TicketDeps(BaseModel):
    knowledge_base_url: str = "https://api.internal.com/kb"
    review_threshold: float = 0.7

# 创建分析Agent
analysis_agent = Agent(
    AnthropicModel(model_name="claude-sonnet-4-20250514"),
    deps_type=TicketDeps,
    result_type=TicketAnalysis,
    system_prompt="""你是一个专业的客服工单分析系统。
    分析用户的输入，提取意图、情感、类别等信息。
    置信度低于阈值时，建议需要人工审核。"""
)

# 创建回复Agent
reply_agent = Agent(
    AnthropicModel(model_name="claude-sonnet-4-20250514"),
    deps_type=TicketDeps,
    result_type=TicketReply,
    system_prompt="""你是一个专业客服代表。
    根据工单分析结果，生成专业、有同理心的回复。
    负面情感需要更诚恳的语气和更高的升级级别。
    技术问题需要提供具体的排查步骤。"""
)

# 注册工具
@analysis_agent.tool
async def search_knowledge_base(ctx: RunContext[TicketDeps], query: str) -> str:
    """搜索知识库获取相关信息"""
    # 实际项目中调用真实API
    print(f"[工具调用] 搜索知识库: {query}")
    return f"关于'{query}'的知识库结果：该问题已知，建议先重启设备..."

@reply_agent.tool
async def check_order_status(ctx: RunContext[TicketDeps], order_id: str) -> str:
    """查询订单状态"""
    print(f"[工具调用] 查询订单: {order_id}")
    return "订单状态：已签收，购买日期30天前，在退换货期内。"

# 多Agent协作流程
async def process_ticket(user_message: str):
    deps = TicketDeps()
    
    print("=" * 60)
    print("阶段1：工单分析")
    print("=" * 60)
    
    result = await analysis_agent.run(user_message, deps=deps)
    analysis = result.result
    
    print(f"\n[分析结果]")
    print(f"  意图: {analysis.intent.value}")
    print(f"  情感: {analysis.sentiment.value}")
    print(f"  类别: {analysis.category}")
    print(f"  置信度: {analysis.confidence:.2f}")
    print(f"  摘要: {analysis.summary}")
    
    # 构建回复Agent的上下文
    reply_context = f"""
    工单分析结果：
    - 意图：{analysis.intent.value}
    - 情感：{analysis.sentiment.value}
    - 类别：{analysis.category}
    - 置信度：{analysis.confidence}
    - 摘要：{analysis.summary}
    
    原始用户消息：{user_message}
    
    请生成回复建议。
    """
    
    print("\n" + "=" * 60)
    print("阶段2：生成回复")
    print("=" * 60)
    
    reply_result = await reply_agent.run(reply_context, deps=deps)
    reply = reply_result.result
    
    print(f"\n[回复建议]")
    print(f"  需要人工操作: {reply.action_required}")
    print(f"  升级级别: {reply.escalation_level}")
    print(f"  回复内容:\n{reply.reply_text}")
    
    # 输出完整消息日志
    print("\n" + "=" * 60)
    print("消息日志")
    print("=" * 60)
    for msg in result.all_messages():
        print(f"  [{msg.role}] {msg.content[:100] if msg.content else '(tool call)'}...")
    
    return analysis, reply

if __name__ == "__main__":
    user_message = "我买的耳机左边没有声音，已经用了不到一个月，非常生气！要求退款！"
    asyncio.run(process_ticket(user_message))

Pydantic AI 核心优势

类型安全保障：结构化输出通过 Pydantic 模型校验，运行前就能发现数据错误
依赖注入：deps_type 机制让 Agent 可以方便地接入外部服务
多模型支持：一套 API 支持 Anthropic、OpenAI、Google 等多个模型后端
极简 API：不需要理解图状态机，上手速度快

实战三：Claude Code 实现（CLI Agent 范式）

Claude Code 代表了2026年 Agent 开发的新方向：不需要写框架代码，直接用自然语言定义 Agent 行为。

基础用法

Claude Code 通过 claude CLI 命令直接使用，无需 Python 代码：

# 安装 Claude Code
npm install -g @anthropic-ai/claude-code

# 配置API密钥
export ANTHROPIC_API_KEY=your-api-key

# 直接描述任务
claude "分析这个客服工单文件 tickets/2026-07-11.json，为每个工单生成回复建议，并更新工单状态"

CLAUDE.md 项目配置

在项目根目录创建 CLAUDE.md，定义 Agent 的行为规范：

# 项目：智能客服工单处理系统

## 角色
你是一个企业级客服工单处理 Agent。

## 工作流程
1. 读取 `tickets/` 目录下的未处理工单（JSON格式）
2. 对每个工单执行以下分析：
   - 意图识别（退款/技术支持/投诉/咨询）
   - 情感分析（positive/neutral/negative）
   - 分类路由
3. 根据分析结果在 `templates/` 中查找回复模板
4. 生成个性化回复，保存到 `replies/` 目录
5. 更新工单状态为 "replied"
6. 对于 negative 情感的工单，标记为 "needs_review"

## 输出格式
- 分析结果保存为 `analysis/{ticket_id}.json`
- 回复保存为 `replies/{ticket_id}.md`
- 工单状态更新到原文件

## 约束
- 不要修改工单的原始内容
- 回复语气要专业且有同理心
- 技术问题需要提供具体排查步骤

Background Agent 模式

2026年 Claude Code 最重要的新特性是 Background Agent，支持并行处理多个任务：

# 启动后台Agent并行处理工单
claude --background "处理 tickets/batch-a/ 下的所有工单"
claude --background "处理 tickets/batch-b/ 下的所有工单"

# 查看后台Agent状态
claude --background list

# 查看特定Agent的输出
claude --background show <agent-id>

SDK 集成（Python）

对于需要编程式控制的场景，Claude Code SDK 提供了 Python 接口：

import asyncio
from claude_code import ClaudeCode

async def process_tickets():
    client = ClaudeCode()
    
    # Auto模式：减少人工确认步骤
    result = await client.run(
        "分析并处理 tickets/ 目录下所有未处理的工单",
        mode="auto",  # auto / manual
        cwd="/path/to/project",
        timeout=300
    )
    
    print(f"处理完成，共处理 {result.task_count} 个工单")
    print(f"工具调用次数: {result.tool_use_count}")
    print(f"总耗时: {result.duration}s")
    
    # 获取详细日志
    for step in result.steps:
        print(f"[{step.tool}] {step.input[:100]}")
        if step.output:
            print(f"  -> {step.output[:100]}")

asyncio.run(process_tickets())

Claude Code 核心优势

零代码启动：自然语言定义 Agent 行为，降低技术门槛
项目级上下文：自动理解项目结构、代码风格、依赖关系
Background Agent：并行处理能力，大幅提升批量任务效率
Auto 模式：减少人工确认，实现真正的 Autopilot 体验

框架选型决策树

基于以上实战对比，我总结了一个实用的选型决策树：

你的Agent需要什么？
│
├─ 编码/开发辅助？
│   └─ Claude Code（CLI Agent范式）
│
├─ 复杂多步骤流程 + 需要精细控制？
│   ├─ 需要可视化调试和状态恢复？
│   │   └─ LangGraph
│   └─ 需要类型安全和简洁API？
│       └─ Pydantic AI
│
├─ API服务 + 结构化数据输出？
│   └─ Pydantic AI
│
└─ 多Agent协作 + 跨系统集成？
    └─ LangGraph（图结构天然适合多Agent编排）

企业落地路径建议：从 Copilot 到 Autopilot

2026年企业 Agent 落地不是一步到位的，建议分三个阶段推进：

阶段一：Copilot 模式（1-2个月）

目标：让团队习惯 AI 辅助开发

开发者使用 Claude Code / Continue.dev 辅助日常编码
在 CLAUDE.md 中定义项目规范，让 AI 理解项目上下文
使用 Auto 模式处理重复性任务（批量重构、测试生成）
预期效果：个人开发效率提升 2-3 倍

# 阶段一典型用法
claude "为这个模块生成单元测试，覆盖率要达到90%"
claude "重构 src/auth/ 目录，将 callback 改为 async/await"

阶段二：Agent 模式（2-4个月）

目标：构建业务场景专属 Agent

选择框架（推荐 Pydantic AI 起步，LangGraph 做复杂场景）
实现 2-3 个核心业务 Agent（客服、运维、数据分析）
接入 MCP 协议，实现 Agent 与现有系统互通
建立 Human-in-the-loop 审核流程

# 阶段二典型架构
# MCP Server 暴露企业内部能力
# Agent 通过 MCP 调用内部API
# 关键操作需人工确认

阶段三：Autopilot 模式（4-6个月）

目标：多 Agent 协作，自动化闭环

部署 Background Agent 处理批量异步任务
多 Agent 协作处理跨部门工作流
建立 Agent 监控和审计体系
渐进式放宽人工确认，实现 Auto 模式

# 阶段三典型部署
claude --background "监控告警系统，自动处理P3级别工单"
claude --background "每日生成运营报表并发送到飞书"

常见问题 FAQ

Q1：LangGraph 和 Pydantic AI 能否一起使用？

可以。Pydantic AI 的结构化输出可以作为 LangGraph 节点的输入/输出类型，结合两者的优势：

from pydantic_ai import Agent as PydanticAgent
from langgraph.graph import StateGraph

# 用 Pydantic AI 做结构化分析
analyzer = PydanticAgent(model=..., result_type=TicketAnalysis)

# 用 LangGraph 编排流程
def analyze_node(state):
    result = analyzer.run_sync(state["message"])
    return {"analysis": result.result}

Q2：Claude Code 能否处理非编码任务？

完全可以。虽然名字里有 "Code"，但 Claude Code 本质是一个通用的 CLI Agent。它可以处理文件操作、数据分析、文档生成等各种终端任务。CLAUDE.md 中定义的角色和工作流决定了它的行为范围。

Q3：Background Agent 的计费如何计算？

Background Agent 按实际 Token 消耗计费，与普通调用相同。但需要注意的是，后台 Agent 会持续运行直到任务完成，复杂任务可能消耗较多 Token。建议先用 --dry-run 评估消耗。

Q4：生产环境应该选择哪个框架？

推荐组合策略：

场景	推荐方案
API 服务 / 数据管道	Pydantic AI
复杂工作流编排	LangGraph
开发者工具 / 内部自动化	Claude Code
企业级全栈方案	LangGraph + Claude Code + MCP

Q5：MCP 协议对框架选型有什么影响？

MCP（Model Context Protocol）是2026年最重要的互操作标准。三个框架对 MCP 的支持程度不同：

LangGraph：通过 LangChain 的 MCP 集成，支持最好
Pydantic AI：官方已宣布 MCP 支持，持续完善中
Claude Code：原生支持 MCP，是 Claude Code 生态的核心协议

如果你的架构依赖大量 MCP Server，LangGraph 目前是最稳妥的选择。

Q6：如何评估 Agent 的质量？

建议从以下维度建立评估体系：

任务完成率：Agent 是否正确完成了目标
工具调用效率：是否冗余调用，Token 消耗是否合理
延迟：端到端响应时间
安全边界：是否遵守预设的权限和约束
可观测性：决策过程是否可追溯

# 简单的质量评估示例
def evaluate_agent(run_log: dict) -> dict:
    return {
        "success": run_log["final_state"]["completed"],
        "tool_calls": len(run_log["tool_calls"]),
        "token_usage": run_log["total_tokens"],
        "latency_seconds": run_log["duration"],
        "human_interventions": len(run_log["interrupts"])
    }

总结

2026年7月，AI Agent 框架已经进入成熟期。三个框架各有明确的适用场景：

LangGraph 适合需要精细控制复杂工作流的场景，图结构天然适合多 Agent 编排
Pydantic AI 适合重视类型安全和开发效率的 API 服务场景
Claude Code 代表了 CLI Agent 新范式，适合开发自动化和快速原型

对于大多数企业，建议的落地路径是：先用 Claude Code（Copilot 模式）快速验证价值 -> 再用 Pydantic AI/LangGraph 构建生产级 Agent -> 最终通过多 Agent 协作和 Auto 模式实现 Autopilot。

技术选型没有银弹，关键是理解你的业务场景，选最合适的工具，而不是最热门的工具。

相关文章推荐：

Claude Code 批量重构实战：从 0 到 1 搭建自动化重构工作流
MCP 协议详解：构建跨厂商 AI Agent 互操作体系
2026年 AI 开发工具全景图：从 Copilot 到 Autopilot

本文发布于 1630.top，转载请注明出处。