AI Agent 框架横评：LangGraph vs AutoGen vs CrewAI vs LlamaIndex Agents

前言

💡 痛点：AI Agent 开发框架众多，LangGraph、AutoGen、CrewAI… 到底选哪个？各自适用场景是什么？

🎯 解决方案：本文从架构设计、能力边界、开发体验、生产就绪度四大维度，深度对比四大主流 Agent 框架，帮你做出最佳选择。

AI Agent是大模型落地的关键形态。本文将对比以下四大主流框架：

---

一、什么是 AI Agent？

1.1 Agent 的核心概念

Agent 核心三要素：

要素	说明	示例
🔍 Planning（规划）	将复杂任务分解为子任务	ToT、ReAct、Plan-and-Execute
🔧 Action（执行）	调用工具完成具体操作	搜索、计算、代码执行
👁️ Observation（感知）	获取结果并更新状态	工具返回、环境反馈

1.2 Agent 能力层级

---

二、LangGraph：状态机编排

2.1 核心思想

核心概念：

概念	说明	类比
StateGraph	状态机图	流程图
Node	处理节点	函数/类
Edge	流转边	箭头
State	共享状态	上下文
Checkpoint	状态快照	版本控制

2.2 核心优势

优势	说明	适用场景
✅ 结构化流程	基于状态机的清晰流程	复杂业务流程
✅ 细粒度控制	精确控制每一步	需要调试的场景
✅ 状态持久化	支持断点恢复	长任务处理
✅ LangChain 集成	复用 LangChain 生态	已有 LangChain 项目
✅ 可视化调试	流程图清晰展示	开发调试

2.3 快速入门

安装与导入

pip install langgraph

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

# 定义状态
class AgentState(TypedDict):
    messages: list
    next_action: str

基础示例：ReAct Agent

"""
LangGraph ReAct Agent 示例
"""
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from typing import TypedDict, Annotated
import operator

# 1. 定义状态
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]  # 消息列表（累加）
    agent_outcome: str | None  # Agent 输出

# 2. 定义工具
def search_tool(query: str) -> str:
    """搜索工具"""
    return f"搜索结果: {query} 相关内容..."

def calculator_tool(expr: str) -> str:
    """计算工具"""
    try:
        result = eval(expr)
        return f"计算结果: {result}"
    except:
        return "计算错误"

tools = {
    "search": search_tool,
    "calculator": calculator_tool
}

# 3. 定义 Agent 节点
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4")

def should_continue(state: AgentState):
    """判断是否继续或结束"""
    last_message = state["messages"][-1]
    if "FINAL" in last_message.content:
        return "end"
    return "continue"

def call_model(state: AgentState):
    """调用 LLM 生成回复"""
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个有帮助的助手。使用工具完成用户任务。"),
        ("human", "{messages}")
    ])
    
    response = llm.invoke(prompt.format(messages=state["messages"]))
    
    return {
        "messages": [response],
        "agent_outcome": response.content
    }

# 4. 构建图
graph = StateGraph(AgentState)

# 添加节点
graph.add_node("agent", call_model)
graph.add_node("action", ToolNode(tools))

# 添加边
graph.set_entry_point("agent")
graph.add_conditional_edges(
    "agent",
    should_continue,
    {
        "continue": "action",
        "end": END
    }
)
graph.add_edge("action", "agent")

# 编译
agent = graph.compile()

# 5. 运行
result = agent.invoke({
    "messages": [{"role": "user", "content": "计算 123 * 456 的结果"}],
    "agent_outcome": None
})

print(result["messages"][-1].content)

进阶示例：多步骤工作流

"""
LangGraph 多步骤工作流：文档处理管道
"""
from langgraph.graph import StateGraph, END
from typing import TypedDict, List
from pydantic import BaseModel

# 定义数据结构
class DocumentState(TypedDict):
    raw_text: str
    chunks: List[str]
    embeddings: List[List[float]]
    summary: str
    final_report: str

# 定义处理节点
def chunking_node(state: DocumentState) -> DocumentState:
    """文档分块"""
    text = state["raw_text"]
    chunks = [text[i:i+500] for i in range(0, len(text), 500)]
    return {"chunks": chunks}

def embedding_node(state: DocumentState) -> DocumentState:
    """向量化处理"""
    embeddings = [embed_text(chunk) for chunk in state["chunks"]]
    return {"embeddings": embeddings}

def summarize_node(state: DocumentState) -> DocumentState:
    """生成摘要"""
    summary_prompt = f"请总结以下文档：{state['raw_text'][:2000]}"
    summary = llm.invoke(summary_prompt)
    return {"summary": summary.content}

def report_node(state: DocumentState) -> DocumentState:
    """生成最终报告"""
    report_prompt = f"""基于以下信息生成报告：

摘要：{state['summary']}
分块数：{len(state['chunks'])}
向量维度：{len(state['embeddings'][0]) if state['embeddings'] else 0}

报告格式要求：简洁、专业
"""
    report = llm.invoke(report_prompt)
    return {"final_report": report.content}

# 构建工作流图
workflow = StateGraph(DocumentState)

# 添加节点
workflow.add_node("chunking", chunking_node)
workflow.add_node("embedding", embedding_node)
workflow.add_node("summarize", summarize_node)
workflow.add_node("report", report_node)

# 设置流程
workflow.set_entry_point("chunking")
workflow.add_edge("chunking", "embedding")
workflow.add_edge("embedding", "summarize")
workflow.add_edge("summarize", "report")
workflow.add_edge("report", END)

# 编译
pipeline = workflow.compile()

# 运行
result = pipeline.invoke({
    "raw_text": "这是一段很长的文档内容..." * 100,
    "chunks": [],
    "embeddings": [],
    "summary": "",
    "final_report": ""
})

print(result["final_report"])

2.4 状态检查点（Checkpointing）

"""
使用检查点实现断点恢复
"""
from langgraph.checkpoint.memory import MemorySaver

# 创建内存检查点
checkpointer = MemorySaver()

# 编译时添加检查点
graph = StateGraph(AgentState)
graph.add_node("agent", call_model)
graph.add_node("action", ToolNode(tools))
graph.set_entry_point("agent")
# ... 添加边 ...
agent = graph.compile(checkpointer=checkpointer)

# 配置线程（用于恢复）
config = {"configurable": {"thread_id": "user-123-session-1"}}

# 首次运行（保存状态）
result = agent.invoke(
    {"messages": [{"role": "user", "content": "复杂任务..."}]},
    config=config
)

# 恢复运行（从断点继续）
result = agent.invoke(
    {"messages": [{"role": "user", "content": "继续上次的任务"}]},
    config=config
)

---

三、AutoGen：多智能体协作

3.1 核心思想

核心概念：

概念	说明	特点
AssistantAgent	AI 助手	生成回复、调用工具
UserProxyAgent	用户代理	执行代码、交互
GroupChat	群聊	多 Agent 协作
Manager	管理器	协调任务分配

3.2 核心优势

优势	说明	适用场景
✅ 多智能体自动化	Agent 间自动协作	复杂任务分解
✅ 代码执行能力	内置代码执行环境	数据分析、科学计算
✅ 人类反馈机制	支持人类参与决策	需要人工审核的场景
✅ 灵活的消息协议	支持多种交互模式	定制化开发
✅ 微软生态	与 VS Code 等深度集成	企业级应用

3.3 快速入门

安装

pip install autogen

基础示例：双 Agent 对话

"""
AutoGen 基础示例：助手 + 用户代理
"""
from autogen import AssistantAgent, UserProxyAgent, config_list

# 配置模型
config_list = [
    {
        "model": "gpt-4",
        "api_key": "your-api-key"
    }
]

# 创建助手 Agent
assistant = AssistantAgent(
    name="assistant",
    llm_config={
        "config_list": config_list,
        "temperature": 0.7
    },
    system_message="你是一个专业的 Python 开发者，擅长编写高质量代码。"
)

# 创建用户代理（自动执行代码）
user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",  # 不需要人工输入
    max_consecutive_auto_reply=10,
    code_execution_config={
        "work_dir": "coding",
        "use_docker": False  # 不使用 Docker
    }
)

# 启动对话
user_proxy.initiate_chat(
    assistant,
    message="写一个快速排序算法，并运行测试。"
)

进阶示例：多智能体协作

"""
AutoGen 多智能体：代码审查流程
"""
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

config_list = [{"model": "gpt-4", "api_key": "your-api-key"}]

# 1. 创建各类 Agent
coder = AssistantAgent(
    name="coder",
    llm_config={"config_list": config_list},
    system_message="你是 Python 开发者，负责编写代码。"
)

reviewer = AssistantAgent(
    name="reviewer",
    llm_config={"config_list": config_list},
    system_message="""你是代码审查员，负责：
1. 检查代码逻辑
2. 发现潜在 bug
3. 提出优化建议
4. 输出审查报告"""
)

tester = AssistantAgent(
    name="tester",
    llm_config={"config_list": config_list},
    system_message="""你是测试工程师，负责：
1. 设计测试用例
2. 执行单元测试
3. 报告测试结果"""
)

# 2. 创建群聊
group_chat = GroupChat(
    agents=[coder, reviewer, tester],
    messages=[],
    max_round=10
)

# 3. 创建管理器
manager = GroupChatManager(
    groupchat=group_chat,
    llm_config={"config_list": config_list}
)

# 4. 启动群聊
user_proxy = UserProxyAgent(name="user", human_input_mode="NEVER")

user_proxy.initiate_chat(
    manager,
    message="""请完成以下任务：
1. 用 Python 实现一个 LRU 缓存类
2. 审查代码，找出潜在问题
3. 为代码编写单元测试"""
)

高级示例：人类反馈循环

"""
AutoGen 人类反馈示例
"""
from autogen import AssistantAgent, UserProxyAgent

config_list = [{"model": "gpt-4", "api_key": "your-api-key"}]

assistant = AssistantAgent(
    name="assistant",
    llm_config={"config_list": config_list}
)

# 人工参与模式
human_proxy = UserProxyAgent(
    name="human",
    human_input_mode="ALWAYS"  # 每次回复都需要人工确认
)

# 启动对话
human_proxy.initiate_chat(
    assistant,
    message="写一个发送邮件的函数"
)

# 在对话过程中，人类可以：
# 1. 提供反馈："代码风格需要更规范"
# 2. 批准继续："看起来不错，继续"
# 3. 修改要求："增加错误处理"

3.3 AutoGen 代码执行详解

"""
AutoGen 代码执行配置详解
"""
user_proxy = UserProxyAgent(
    name="executor",
    code_execution_config={
        # 执行环境
        "use_docker": True,  # True/False/"python"/"ubuntu"
        
        # 工作目录
        "work_dir": "coding_workspace",
        
        # 自动回复次数上限
        "max_consecutive_auto_reply": 5,
        
        # 是否终止对话
        "terminate_on_ctrl_c": True,
        
        # 失败时是否重试
        "auto_respond": True,
    }
)

---

四、CrewAI：角色扮演编排

4.1 核心思想

核心概念：

概念	说明	类比
Agent	角色执行者	员工
Task	具体任务	工作内容
Crew	任务团队	项目组
Process	编排流程	工作流程

4.2 核心优势

优势	说明	适用场景
✅ 角色清晰	基于角色的设计，易于理解	快速原型
✅ 流程可配置	支持 Sequential/Hierarchical	灵活编排
✅ 任务分解	内置任务依赖管理	复杂项目
✅ 学习曲线低	API 设计直观	团队协作
✅ 输出控制	明确的输出格式	产品化

4.3 快速入门

安装

pip install crewai

基础示例：研究 + 写作流程

"""
CrewAI 基础示例：研究 + 写作团队
"""
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4")

# 1. 定义 Agent
researcher = Agent(
    role="高级研究员",
    goal="收集并分析相关信息，提供准确的数据支持",
    backstory="""你是一位资深研究员，擅长从多个来源收集信息，
    并进行深度分析。你曾经为多家知名媒体提供研究报告。""",
    llm=llm,
    verbose=True
)

writer = Agent(
    role="专业写手",
    goal="将研究成果转化为高质量文章",
    backstory="""你是一位专业的内容创作者，擅长撰写技术博客和深度报道。
    你的文章逻辑清晰、可读性强，深受读者喜爱。""",
    llm=llm,
    verbose=True
)

# 2. 定义 Task
research_task = Task(
    description="""请对以下主题进行深入研究：
    主题：2026年AI大模型技术发展趋势
    
    研究要点：
    1. 主要技术突破
    2. 主流厂商动态
    3. 应用场景变化
    4. 未来预测
    
    请提供详细的研究报告。""",
    agent=researcher,
    expected_output="详细的研究报告，包含数据来源"
)

write_task = Task(
    description="""根据研究报告，撰写一篇技术博客文章。
    
    要求：
    1. 结构清晰，包含引言、主体、结论
    2. 语言通俗易懂，适合技术从业者
    3. 包含关键数据和案例
    4. 字数 2000-3000 字""",
    agent=writer,
    expected_output="完整的博客文章，Markdown 格式"
)

# 3. 创建 Crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,  # 顺序执行
    verbose=True
)

# 4. 启动
result = crew.kickoff()
print(result)

进阶示例：并行任务 + 层级管理

"""
CrewAI 并行 + 层级示例
"""
from crewai import Agent, Task, Crew, Process

llm = ChatOpenAI(model="gpt-4")

# 1. 定义多个并行 Agent
researcher1 = Agent(
    role="技术研究员",
    goal="分析技术发展趋势",
    backstory="技术专家，专注于 AI 技术分析",
    llm=llm
)

researcher2 = Agent(
    role="市场研究员",
    goal="分析市场动态",
    backstory="市场分析师，专注于行业研究",
    llm=llm
)

editor = Agent(
    role="主编",
    goal="整合研究报告，把控质量",
    backstory="资深编辑，擅长内容整合和质量管理",
    llm=llm
)

# 2. 定义并行任务
tech_research = Task(
    description="分析 AI 技术趋势",
    agent=researcher1
)

market_research = Task(
    description="分析 AI 市场动态",
    agent=researcher2
)

# 3. 依赖任务（需等待前两个完成）
integration = Task(
    description="整合两份研究报告，输出综合分析报告",
    agent=editor,
    context=[tech_research, market_research]  # 依赖前面任务
)

# 4. 创建 Crew（层级模式）
crew = Crew(
    agents=[researcher1, researcher2, editor],
    tasks=[tech_research, market_research, integration],
    process=Process.hierarchical,  # 层级管理
    manager_agent=editor  # 指定管理器
)

result = crew.kickoff()

4.4 自定义工具

"""
CrewAI 自定义工具
"""
from crewai import Agent, Task, Crew
from crewai.tools import BaseTool
from pydantic import Field

# 1. 定义自定义工具
class SearchTool(BaseTool):
    name: str = "search"
    description: str = "搜索互联网获取最新信息"
    
    def _run(self, query: str) -> str:
        """执行搜索"""
        # 实现搜索逻辑
        return f"搜索结果: {query} 相关内容..."

class CalculatorTool(BaseTool):
    name: str = "calculator"
    description: str = "执行数学计算"
    
    def _run(self, expression: str) -> str:
        """执行计算"""
        try:
            result = eval(expression)
            return f"结果: {result}"
        except Exception as e:
            return f"计算错误: {e}"

# 2. 创建带工具的 Agent
researcher = Agent(
    role="研究员",
    goal="高效完成研究任务",
    tools=[SearchTool(), CalculatorTool()],  # 绑定工具
    llm=llm
)

# 3. 使用
task = Task(
    description="搜索最新 AI 新闻并计算相关数据",
    agent=researcher
)

---

五、LlamaIndex Agents

5.1 核心思想

核心优势：

优势	说明	适用场景
✅ RAG 原生	与知识库深度集成	知识密集型任务
✅ 索引丰富	支持多种索引类型	复杂检索场景
✅ 查询引擎	强大的查询能力	数据分析
✅ 数据源广泛	支持多种数据源	企业知识库

5.2 快速入门

安装

pip install llama-index

基础示例：Query Engine Agent

"""
LlamaIndex Agent 示例：知识库问答
"""
from llama_index import VectorStoreIndex, SimpleDirectoryReader
from llama_index.agent import ReActAgent
from llama_index.llms import OpenAI

# 1. 加载文档
documents = SimpleDirectoryReader("./data").load_data()

# 2. 构建索引
index = VectorStoreIndex.from_documents(documents)

# 3. 创建 Agent
llm = OpenAI(model="gpt-4")

agent = ReActAgent.from_tools(
    tools=[],  # 可添加自定义工具
    index=index,
    llm=llm,
    verbose=True
)

# 4. 查询
response = agent.query("请总结文档的主要内容")
print(response)

进阶示例：多工具 Agent

"""
LlamaIndex 多工具 Agent
"""
from llama_index import VectorStoreIndex, SummaryIndex
from llama_index.agent import AgentRunner
from llama_index.tools import QueryEngineTool, ToolSpec

llm = OpenAI(model="gpt-4")

# 1. 创建多个索引
product_index = VectorStoreIndex.from_documents(product_docs)
review_index = VectorStoreIndex.from_documents(review_docs)
faq_index = SummaryIndex.from_documents(faq_docs)

# 2. 创建查询引擎
product_engine = product_index.as_query_engine()
review_engine = review_index.as_query_engine()
faq_engine = faq_index.as_query_engine()

# 3. 创建工具
product_tool = QueryEngineTool(
    query_engine=product_engine,
    name="product_search",
    description="搜索产品信息，包括规格、价格等"
)

review_tool = QueryEngineTool(
    query_engine=review_engine,
    name="review_search",
    description="搜索用户评论和评分"
)

faq_tool = QueryEngineTool(
    query_engine=faq_engine,
    name="faq_search",
    description="搜索常见问题和答案"
)

# 4. 创建 Agent
agent = AgentRunner(
    tools=[product_tool, review_tool, faq_tool],
    llm=llm
)

# 5. 查询
response = agent.query(
    "iPhone 15 的电池续航如何？用户评价怎么样？"
)

---

六、框架对比

6.1 核心功能对比

功能	LangGraph	AutoGen	CrewAI	LlamaIndex
多 Agent 支持	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐
状态管理	⭐⭐⭐⭐⭐	⭐⭐	⭐⭐⭐	⭐⭐
RAG 集成	⭐⭐⭐	⭐⭐	⭐⭐	⭐⭐⭐⭐⭐
代码执行	⭐⭐	⭐⭐⭐⭐⭐	⭐⭐	⭐⭐
流程控制	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐
人类反馈	⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐
可视化	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐

6.2 开发体验对比

维度	LangGraph	AutoGen	CrewAI	LlamaIndex
学习曲线	中等	较高	低	中等
文档质量	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
上手速度	⭐⭐⭐	⭐⭐	⭐⭐⭐⭐	⭐⭐⭐
灵活性	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐
调试友好	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐

6.3 生产就绪度对比

维度	LangGraph	AutoGen	CrewAI	LlamaIndex
稳定性	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐
社区活跃	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
企业支持	LangChain	微软	独立	独立
生产案例	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐
维护活跃	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐

6.4 性能对比

6.5 代码复杂度对比

实现相同功能的代码行数对比：

功能	LangGraph	AutoGen	CrewAI	LlamaIndex
简单 Agent	50 行	40 行	25 行	35 行
多 Agent 协作	80 行	100 行	60 行	70 行
RAG 问答	70 行	90 行	65 行	45 行

---

七、场景推荐

7.1 选型决策树

7.2 场景推荐表

场景	推荐框架	理由
🚀 快速原型开发	CrewAI	API 简洁，上手快
📊 复杂业务流程	LangGraph	状态机，细粒度控制
👥 多 Agent 协作	AutoGen	自动化协作强
📚 知识库问答	LlamaIndex	RAG 原生支持
💻 代码执行分析	AutoGen	内置代码执行
🔄 长任务处理	LangGraph	检查点 + 断点恢复
🎭 角色扮演场景	CrewAI	角色定义清晰
🏢 企业级应用	LangGraph/AutoGen	稳定性好

7.3 具体案例

案例 1：客服机器人（RAG 优先）

需求： 基于知识库的客服问答，支持多轮对话

推荐：LlamaIndex

"""
LlamaIndex 客服机器人
"""
from llama_index import VectorStoreIndex
from llama_index.agent import ReActAgent

# 知识库索引
index = VectorStoreIndex.from_documents(kb_documents)

# Agent
agent = ReActAgent.from_tools(
    tools=[],  # 可添加搜索、计算等工具
    index=index,
    verbose=True
)

# 对话
while True:
    query = input("请输入问题：")
    response = agent.query(query)
    print(response)

案例 2：数据分析流水线（流程控制优先）

需求： 从数据源获取 → 分析 → 生成报告

推荐：LangGraph

"""
LangGraph 数据分析流水线
"""
from langgraph.graph import StateGraph, END
from typing import TypedDict

class AnalysisState(TypedDict):
    raw_data: str
    cleaned_data: str
    features: list
    results: dict
    report: str

workflow = StateGraph(AnalysisState)

workflow.add_node("fetch", fetch_data_node)
workflow.add_node("clean", clean_data_node)
workflow.add_node("feature", feature_engineering_node)
workflow.add_node("train", train_model_node)
workflow.add_node("report", generate_report_node)

workflow.set_entry_point("fetch")
workflow.add_edge("fetch", "clean")
workflow.add_edge("clean", "feature")
workflow.add_edge("feature", "train")
workflow.add_edge("train", "report")
workflow.add_edge("report", END)

pipeline = workflow.compile()
result = pipeline.invoke({"raw_data": "..."})

案例 3：多角色协作写作（协作优先）

需求： 研究员 + 写手 + 编辑协作完成文章

推荐：CrewAI

"""
CrewAI 写作团队
"""
from crewai import Agent, Task, Crew, Process

researcher = Agent(role="研究员", goal="提供准确信息")
writer = Agent(role="写手", goal="产出高质量文章")
editor = Agent(role="编辑", goal="把控文章质量")

research = Task(description="研究主题", agent=researcher)
write = Task(description="撰写文章", agent=writer, context=[research])
edit = Task(description="编辑校对", agent=editor, context=[write])

crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research, write, edit],
    process=Process.hierarchical,
    manager_agent=editor
)

result = crew.kickoff()

---

八、混合使用与迁移

8.1 框架组合策略

示例：LangGraph + LlamaIndex（RAG + 流程控制）

"""
LangGraph + LlamaIndex 混合使用
"""
from langgraph.graph import StateGraph, END
from llama_index import VectorStoreIndex
from llama_index.tools import QueryEngineTool

# LlamaIndex 索引和工具
index = VectorStoreIndex.from_documents(documents)
tool = QueryEngineTool(
    query_engine=index.as_query_engine(),
    name="knowledge_base",
    description="知识库检索"
)

# LangGraph 整合工具
def search_node(state):
    result = tool.run("检索 " + state["query"])
    return {"context": result}

def answer_node(state):
    prompt = f"基于以下信息回答：{state['context']}"
    response = llm.invoke(prompt)
    return {"answer": response}

workflow = StateGraph(AgentState)
workflow.add_node("search", search_node)
workflow.add_node("answer", answer_node)
workflow.set_entry_point("search")
workflow.add_edge("search", "answer")
workflow.add_edge("answer", END)

agent = workflow.compile()

8.2 迁移指南

从 CrewAI 迁移到 LangGraph

"""
CrewAI → LangGraph 迁移示例
"""
# CrewAI 代码
from crewai import Agent, Task, Crew

agent = Agent(role="助手", goal="帮助用户")
task = Task(description="回答问题", agent=agent)
crew = Crew(agents=[agent], tasks=[task])

# 等价 LangGraph 代码
from langgraph.graph import StateGraph, END

def agent_node(state):
    prompt = f"Role: 助手\\nGoal: 帮助用户\\nTask: {state['task']}"
    response = llm.invoke(prompt)
    return {"response": response}

graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.set_entry_point("agent")
graph.add_edge("agent", END)

converted = graph.compile()

---

九、最佳实践

9.1 架构设计原则

9.2 开发 Checklist

✅ Agent 开发检查清单

📋 需求分析
  □ 明确 Agent 角色和职责
  □ 定义输入输出格式
  □ 识别需要的工具

🏗️ 架构设计
  □ 选择合适的框架
  □ 设计 Agent 间的协作流程
  □ 定义状态管理方案

🔧 实现
  □ 实现各 Agent 核心逻辑
  □ 配置工具和知识库
  □ 添加错误处理和重试

📊 测试
  □ 单元测试各 Agent
  □ 集成测试协作流程
  □ 端到端测试完整场景

🚀 部署
  □ 配置生产环境
  □ 监控日志和指标
  □ 设置告警机制

9.3 常见问题与解决

问题	原因	解决方案
🚨 循环调用	Agent 间无限循环	设置最大轮次
🚨 上下文过长	对话历史积累	实施摘要策略
🚨 工具调用失败	网络/权限问题	添加重试 + 降级
🚨 输出不稳定	LLM 随机性	降低 temperature
🚨 状态丢失	进程崩溃	使用检查点

---

十、总结

最终推荐

场景	首选	备选
快速原型	CrewAI	LangGraph
复杂业务流程	LangGraph	AutoGen
多 Agent 协作	AutoGen	CrewAI
RAG 应用	LlamaIndex	LangGraph + LlamaIndex
代码执行	AutoGen	-
企业级应用	LangGraph	LlamaIndex

资源链接

资源	链接
📚 LangGraph 文档	https://langchain-ai.github.io/langgraph/
🚀 AutoGen 文档	https://microsoft.github.io/autogen/
👥 CrewAI 文档	https://docs.crewai.com/
📖 LlamaIndex 文档	https://docs.llamaindex.ai/
🐙 GitHub 仓库	各框架 GitHub 首页

---

本文基于 2026-06 最新版本编写。各框架更新较快，建议读者查看官方文档获取最新信息。如有问题欢迎评论区讨论！