四种框架深度对比分析

LangChain：全能型的应用开发框架	LlamaIndex：私有数据接入的专家	AutoGen：多智能体协作大师	LangGraph：复杂控制流的工作流引擎
提供大量组件（Tools, Chains, Agents），灵活组装，覆盖广泛场景。	专精于数据连接与检索（RAG），追求在此领域极致的性能和效果	智能体（Agent）为中心，通过对话和协作解决复杂任务	图（Graph）与状态机（State Machine） 为中心，显式定义和控制工作流
Chains, Agents, Tools	Data Connectors, Query Engines, Retriever	ConversableAgent, GroupChat	StateGraph, Nodes, Edges
快速原型验证：需要快速搭建一个具备搜索、工具调用等功能的AI应用Demo。构建标准Agent：需要构建一个能使用多种工具（如计算器、API、数据库）的智能助手。集成多模态能力：需要将LLM与图像生成、语音处理等模块连接起来。
高性能企业知识库QA系统：企业有海量的内部文档（PDF、Word、Confluence、Notion等），需要构建一个精准、高效的问答机器人。结构化/非结构化数据查询：需要让LLM能够查询数据库、数据仓库（SQL）或Excel表格。高级RAG优化：需要实现复杂的检索策略，如分层检索、混合检索、重新排序（Re-ranking）等以提升答案质量。	复杂任务自动化：需要一个由多个角色（如产品经理、工程师、测试员）组成的团队来自动完成需求分析、编码、测试等流程。模拟与仿真：模拟用户对话、市场反应、辩论场景等。多角色辅助系统：构建一个包含“编程专家”、“数据分析专家”、“文案专家”等多个专家的辅助系统，用户提出需求，专家们协作给出最佳方案。	有状态的多步骤业务流程：例如，客户服务工单处理流程（接收->分类->查询知识库->生成回复->人工审核->发送）。LLM应用中的循环与审批：例如，一个代码生成任务，需要“生成->单元测试->如果测试失败则重新生成”的循环。精确复现的复杂链：需要将一个业务流以图的形式明确定义出来，保证每次执行的可重复性和可调试性。
优点：庞大的社区和生态系统，遇到问题容易找到解决方案。提供了从简单到复杂的各种构建块，非常适合探索性项目。	优点：在数据加载、索引构建、查询优化方面提供了极致的专业性和灵活性。性能通常优于使用LangChain原生组件的RAG实现。与各种向量数据库（Pinecone, Weaviate, Milvus）深度集成。	优点：能够解决单一Agent无法处理的超复杂任务。通过智能体间的对话和协作，容错性和创造力更强。提供了多种对话模式（如双人对话、群聊、经理-员工模式）。	优点：将工作流显式定义，控制流非常清晰，易于理解、维护、调试和监控。完美支持状态管理和循环，这是其他框架的弱项。它与LangChain生态无缝集成。
缺点：在构建高性能、生产级的RAG系统时，可能需要做很多底层优化工作，其开箱即用的检索能力可能不如LlamaIndex专业。复杂的Chain可能变得难以维护和调试。	缺点：其能力范围聚焦在“数据索引和查询”。如果你需要构建一个不仅能问答，还能执行动作（如发邮件、操作软件）的Agent，通常需要与LangChain或AutoGen结合使用。	缺点：工作流是动态生成的，难以预测和精确控制。消耗的Token较多（因为包含大量内部对话），成本和延迟较高。调试多智能体交互过程较为复杂。	缺点：相对较新，生态和社区还在快速发展中。需要开发者以“图”的思维来建模业务，有一定前期学习成本。

企业选型

核心业务场景是什么？

• 主要是问答（Q&A）和文档分析？ -> 首选 LlamaIndex。它在RAG上的专业性能可以让你省去大量底层优化工作。
• 需要调用工具、连接外部API？ -> LangChain 是安全且成熟的选择，它的Tool和Agent抽象非常完善。
• 是涉及多个角色、多轮对话的复杂任务？ -> 认真考虑 AutoGen。
• 是有明确步骤、状态和循环的业务流程？ -> LangGraph 是最佳利器。

需要快速原型还是生产级部署？

• 原型阶段/概念验证（POC）：LangChain 是绝佳的起点，它能让你快速看到效果。
• 生产部署：往往需要组合使用。例如：
  LlamaIndex (用于核心RAG) + LangChain (用于工具调用和总体编排)。
  LangGraph (用于定义整体工作流状态) + LlamaIndex (作为工作流中的一个检索节点)。
  用 LangChain 或 LangGraph 构建主框架，在需要多智能体协作的子模块中引入 AutoGen。

可控性和可调试性有多重要？

• 金融、医疗等对流程要求严格的企业应用：LangGraph 的显式工作流提供了最高的可控性和可审计性。
• 营销、创意等追求结果的场景：AutoGen 的自主协作可能产生意想不到的好结果，但过程更难追踪。

团队的技术背景如何？

• 团队刚开始接触LLM应用：从 LangChain 开始，学习资料最丰富。
• 团队有很强的工程背景，熟悉状态机、工作流引擎：LangGraph 会非常顺手。
• 团队专注于搜索和数据库领域：LlamaIndex 的概念会更容易理解。

常见的混合使用

LangChain + LlamaIndex：经典组合。用LangChain作为高级编排框架，管理Agent、工具和记忆，而用LlamaIndex作为其内部一个高性能的、专门的检索工具。这是目前生产级RAG系统的常见架构。

LangGraph + LlamaIndex/AutoGen：用LangGraph定义整个应用的顶层状态和流程，图中的每个节点（Node）可以是一个LangChain Chain、一个LlamaIndex查询引擎、或者一个AutoGen智能体小组。这种架构兼具了可控性和能力专业性。

LlamaIndex：实现核心RAG功能（数据索引与查询）

知识库检索

# 步骤 1: 安装并导入库
# pip install llama-index llama-index-llms-openai llama-index-embeddings-openai
import openai 
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.embeddings.openai import OpenAIEmbedding #配置全局Embedding模型
from llama_index.llms.openai import OpenAI # 配置全局LLM

# 步骤 2: 配置LLM和Embedding模型
openai.api_key = "YOUR_OPENAI_API_KEY"
Settings.llm = OpenAI(model="gpt-4") # 配置全局LLM
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") # 配置全局Embedding模型

# 步骤 3: 加载企业文档数据（例如 './data' 目录下的PDF、TXT等）
documents = SimpleDirectoryReader('./data').load_data()

# 步骤 4: 构建向量索引（可持久化到磁盘或向量数据库如Chroma、Pinecone）
index = VectorStoreIndex.from_documents(documents)
# index.storage_context.persist(persist_dir="./storage") # 持久化

# 步骤 5: 创建查询引擎（可配置高级参数如相似度top_k、重排序等）
query_engine = index.as_query_engine(similarity_top_k=3)

# 步骤 6: 定义核心查询函数（这将作为其他框架的“工具”被调用）
def query_knowledge_base(user_query: str) -> str:
    """查询企业知识库的核心函数"""
    response = query_engine.query(user_query)
    return str(response)

高性能企业知识库问答系统

将企业内部的大量文档（如产品手册、政策文件、项目报告）构建成知识库，提供精准、快速的问答服务。

from llama_index import VectorStoreIndex, SimpleDirectoryReader, ServiceContext
from llama_index.llms import OpenAI
from llama_index.node_parser import SimpleNodeParser
from llama_index.text_splitter import TokenTextSplitter
import os

# 0. 假设已有一份企业文档 "data/policy.pdf"

# 1. 高级文本分割与节点解析（企业级优化关键步骤）
text_splitter = TokenTextSplitter(separator=" ", chunk_size=512, chunk_overlap=128)
node_parser = SimpleNodeParser.from_defaults(text_splitter=text_splitter)

# 2. 创建具有特定配置的ServiceContext（控制LLM、嵌入模型、解析方式等）
service_context = ServiceContext.from_defaults(
    llm=OpenAI(model="gpt-3.5-turbo"),
    node_parser=node_parser, # 使用自定义解析器优化块大小和重叠
    embed_model="local:BAAI/bge-small-en-v1.5" # 使用本地或私有化部署的嵌入模型以保护数据隐私
)

# 3. 加载企业文档数据（支持PDF、PPT、Word、Notion、Confluence等）
documents = SimpleDirectoryReader("data").load_data()

# 4. 构建索引（核心步骤，可持久化到磁盘或向量数据库）
index = VectorStoreIndex.from_documents(
    documents, 
    service_context=service_context,
    show_progress=True # 企业级大数据处理时显示进度
)
# index.storage_context.persist(persist_dir="./storage")  # 持久化索引

# 5. 创建查询引擎（可配置高级检索策略）
query_engine = index.as_query_engine(
    similarity_top_k=5,          # 检索5个最相关的文本块
    response_mode="tree_summarize" # 使用"树总结"模式生成更精准的答案
)

# 6. 进行查询
query = "我们公司的差旅报销政策中，对于国际航班的舱位等级有什么规定？"
response = query_engine.query(query)
print(response)

# 获取检索到的参考源，用于审计和验证（企业级关键需求）
print("\n参考来源:")
for node in response.source_nodes:
    print(f"- {node.text[:200]}... (相似度分数: {node.score:.2f})")

LangChain：实现工具调用与基础Agent编排

利用其丰富的Tool和Agent生态，处理知识库之外的请求

# 步骤 1: 安装并导入库
# pip install langchain langchain-openai
from langchain.agents import AgentType, initialize_agent, Tool
from langchain.schema import SystemMessage
from langchain_openai import ChatOpenAI
from some_module import query_knowledge_base  # 导入上面用LlamaIndex实现的函数

# 步骤 2: 定义外部工具（例如查询订单的API）
def query_order_api(order_id: str) -> str:
    """模拟查询订单状态的API调用"""
    # 这里应该是真实的API调用代码，如 requests.get(...)
    return f"Order {order_id} status is: Shipped."

# 步骤 3: 将功能封装为LangChain的Tool对象
tools = [
    Tool(
        name="KnowledgeBase",
        func=query_knowledge_base, # 核心！集成LlamaIndex
        description="Useful for answering general questions about company products, policies, and manuals."
    ),
    Tool(
        name="OrderQuery",
        func=query_order_api,
        description="Useful for querying the status of a customer's order. Input should be a valid order ID."
    )
]

# 步骤 4: 初始化LLM和Agent
llm = ChatOpenAI(model="gpt-4", temperature=0)
system_message = SystemMessage(content="You are a helpful customer service assistant. Be polite and professional.")
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.OPENAI_FUNCTIONS, # 使用适合工具调用的Agent类型
    verbose=True, # 打印详细执行日志，便于调试
    agent_kwargs={"system_message": system_message}
)

# 步骤 5: 定义处理用户请求的入口函数
def langchain_agent_handle_query(user_input: str) -> str:
    """LangChain Agent的处理入口"""
    result = agent.run(user_input)
    return result

企业级客服工单自动分类与处理 Agent

接收来自前端的用户工单描述，自动将其分类（如 “Billing”, “Technical”, “General”），并根据类别调用不同的处理工具（如查询知识库、调用API）

from langchain.agents import AgentType,initialize_agent,Tool
from langchain.chains import LLMChain
from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.schema import SystemMessage

# 1. 定义工具函数 (模拟企业内部的API调用)
def query_billing_knowledge_base(query: str) -> str:
    """模拟查询计费相关知识库"""
    return "根据策略A，您的账单问题可以通过自助页面退款。"

def create_technical_ticket(description: str) -> str:
    """模拟在JIRA等系统中创建技术工单"""
    return f"技术工单已创建 (ID: JIRA-123)，工程师将尽快处理：{description}"

def escalate_to_human_agent(description: str) -> str:
    """模拟将工单升级给人工客服"""
    return "工单已升级至高级客服团队，稍后将与您联系。"

# 2. 创建工具列表
tools = [
	Tool(
		name="BillingQA",
		func=query_billing_knowledge_base,
		description="在用户询问账单、付款、退款问题时使用。输入应为具体问题。"
	),
	Tool(
		name="CreateTechnicalTicket",
        func=create_technical_ticket,
        description="在用户报告技术故障、Bug、系统无法使用时，用于创建技术工单。输入应为问题描述。"
	),
	Tool(
        name="EscalateToHuman",
        func=escalate_to_human_agent,
        description="当用户问题复杂、情绪激动或不属于已知类别时，转接给人工客服。输入应为问题描述。"
    ),
]

# 3. 设置具有特定系统提示的LLM，确保其行为符合企业规范
agent_kwargs = {
    "system_message": SystemMessage(content="""你是一名专业的企业客服助手。请首先对用户工单进行精确分类。
    分类选项: [Billing, Technical, General]。
    请严格根据分类结果选择工具：
    - Billing: 使用 `BillingQA`
    - Technical: 使用 `CreateTechnicalTicket`
    - General 或其他: 使用 `EscalateToHuman`
    你的回复应专业、简洁、富有同理心。""")
}

# 4. 初始化LLM和Agent
llm = ChatOpenAI(model="gpt-4", temperature=0)
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.OPENAI_FUNCTIONS, # 适合使用工具调用
    agent_kwargs=agent_kwargs,
    verbose=True # 企业调试时建议开启，生产环境可关闭
)

# 5. 模拟处理用户工单
user_query = "我的付款成功了，但服务还没有激活，这已经是第二次了，非常令人失望！"
result = agent.run(user_query)
print(result)

AutoGen：实现多智能体复杂协作

处理需要多个专家角色协同解决的复杂客诉问题

# 步骤 1: 安装并导入库
# pip install pyautogen
import autogen
from autogen import AssistantAgent, UserProxyAgent

# 步骤 2: 配置LLM
config_list = [{"model": "gpt-4", "api_key": "YOUR_OPENAI_API_KEY"}]

# 步骤 3: 创建多个具有不同角色的智能体
# 用户代理（代表用户，可以执行代码/工具）
user_proxy = UserProxyAgent(
    name="User_Proxy",
    system_message="A human admin who can execute tools and answer questions for the other agents.",
    human_input_mode="NEVER", # 企业级应用通常设置为自动，无需人工干预
    code_execution_config={"use_docker": False}, # 如果不需要执行代码，可关闭
)

# 客服专家（主导对话，解决一般性问题）
customer_service_assistant = AssistantAgent(
    name="Customer_Service_Expert",
    system_message="You are a customer service expert. You are polite and solve general product and policy questions. You can ask the Specialist for help.",
    llm_config={"config_list": config_list},
)

# 技术专家（被咨询解决技术难题）
technical_specialist = AssistantAgent(
    name="Technical_Specialist",
    system_message="You are a technical support specialist. You provide detailed, technical solutions to complex product issues.",
    llm_config={"config_list": config_list},
)

# 步骤 4: 注册函数（AutoGen支持函数调用）
@user_proxy.register_for_execution()
@customer_service_assistant.register_for_llm(description="Query the company knowledge base.")
def query_kb(query: str) -> str:
    return query_knowledge_base(query) # 再次集成LlamaIndex

# 步骤 5: 初始化群聊，定义协作规则
groupchat = autogen.GroupChat(
    agents=[user_proxy, customer_service_assistant, technical_specialist],
    messages=[],
    max_round=10, # 限制对话轮次，控制成本
    speaker_selection_method="round_robin", # 或 "auto"
)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config={"config_list": config_list})

# 步骤 6: 定义处理复杂请求的入口
def autogen_handle_complex_query(user_input: str) -> str:
    """AutoGen多智能体处理复杂查询的入口"""
    user_proxy.initiate_chat(
        manager,
        message=user_input,
    )
    # 从聊天历史中获取最终回复
    return manager.last_message()["content"]

多智能体协作进行市场报告撰写与分析

一个由多个AI智能体协作完成一份竞品分析报告。Researcher负责搜索信息，Analyst负责分析，Writer负责整合成文

• 每个智能体可以定制不同的系统提示和底层模型（如用GPT-4做分析，用GPT-3.5做搜索）
• 将需要多专家协作的任务自动化。
• 轻松添加新的专家角色

from autogen import AssistantAgent, UserProxyAgent, config_list_from_json

# 1. 加载LLM配置（可从文件读取，方便管理不同模型的API Key）
config_list = config_list_from_json("OAI_CONFIG_LIST")
# 也可以直接配置
# config_list = [{"model": "gpt-4", "api_key": os.getenv("OPENAI_API_KEY")}]

# 2. 创建参与协作的智能体

# 研究员智能体：负责获取信息
researcher = AssistantAgent(
    name="Researcher",
    system_message="""你是一名市场研究员。你的职责是根据任务执行精确的网络搜索（如果用户启用）或利用自身知识，
    提供关于公司、产品和市场趋势的详细、事实性数据。请提供清晰、有条理的发现。""",
    llm_config={"config_list": config_list},
)

# 分析师智能体：负责深度分析
analyst = AssistantAgent(
    name="Analyst",
    system_message="""你是一名资深市场分析师。基于研究员提供的数据，你的职责是进行SWOT分析、对比分析、
    解读数据背后的意义并指出潜在机会和风险。你的分析应深入且有洞察力。""",
    llm_config={"config_list": config_list},
)

# 写手智能体：负责撰写最终报告
writer = AssistantAgent(
    name="Writer",
    system_message="""你是一名专业的技术写手。你将研究员的数据和分析师的见解整合成一份结构清晰、语言精练、
    适合高管阅读的市场分析报告。报告应包括执行摘要、主要发现、分析和建议。""",
    llm_config={"config_list": config_list},
)

# 3. 创建用户代理，它代表人类用户，可以执行代码或工具（如搜索）
user_proxy = UserProxyAgent(
    name="User_Proxy",
    human_input_mode="NEVER", # 企业自动化流程中通常设置为不需要人工干预
    code_execution_config={"work_dir": "research", "use_docker": False}, # 允许执行代码（例如运行Python进行数据分析）
    max_consecutive_auto_reply=10, # 限制对话轮次，防止无限循环
    is_termination_msg=lambda x: x.get("content", "").find("TERMINATE") >= 0,
)

# 4. 初始化群聊，并指定发言顺序
groupchat = GroupChat(
    agents=[user_proxy, researcher, analyst, writer], 
    messages=[], 
    max_round=20,
    speaker_selection_method="round_robin", # 也可用 "auto" 或自定义函数
    allow_repeat_speaker=False
)

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

# 6. 发起任务
task = """
请协作生成一份关于电动汽车品牌 Tesla 和 BYD 在2023年欧洲市场表现的竞争分析报告。
报告最终应由Writer生成，并以“TERMINATE”一词结束。
"""
user_proxy.initiate_chat(manager, message=task)

LangGraph：实现整体可控的工作流与状态管理

作为应用的大脑，编排整个业务流程，管理状态，实现循环和判断。

# 步骤 1: 安装并导入库
# pip install langgraph
from typing import TypedDict, Annotated, Sequence
from langgraph.graph import StateGraph, END
from langchain_core.messages import BaseMessage, HumanMessage
from langchain_openai import ChatOpenAI
from some_module import query_knowledge_base, query_order_api # 导入之前的工具

# 步骤 2: 定义状态（State），这是LangGraph的核心，代表工作流在每个节点的输入/输出
class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], "add"] # 消息历史
    user_query: str # 原始用户问题
    needs_human_review: bool # 是否需要人工审核（状态标志）

# 步骤 3: 定义各个节点（Node）的函数
def retrieve_from_kb(state: AgentState):
    """节点1：查询知识库"""
    result = query_knowledge_base(state["user_query"])
    return {"messages": [HumanMessage(content=f"Knowledge base result: {result}")]}

def query_order_tool(state: AgentState):
    """节点2：查询订单"""
    # 这里可以添加从用户问题中提取order_id的逻辑（或用LLM提取）
    order_id = "12345" # 简化示例
    result = query_order_api(order_id)
    return {"messages": [HumanMessage(content=f"Order query result: {result}")]}

def generate_final_response(state: AgentState):
    """节点3：基于所有信息生成最终回复"""
    llm = ChatOpenAI(model="gpt-4")
    # 综合所有上下文消息生成回复
    response = llm.invoke(state["messages"])
    return {"messages": [response], "needs_human_review": False} # 假设不需要人工审核

def human_review_node(state: AgentState):
    """节点4：人工审核节点（示例）"""
    print(f"Response needing review: {state['messages'][-1].content}")
    # 这里可以集成邮件、钉钉、Slack等通知系统
    return {"needs_human_review": True}

# 步骤 4: 构建图（Graph）并定义边（Edges）
builder = StateGraph(AgentState)

# 添加节点
builder.add_node("retrieve", retrieve_from_kb)
builder.add_node("query_order", query_order_tool)
builder.add_node("generate_response", generate_final_response)
builder.add_node("human_review", human_review_node)

# 设置入口点
builder.set_entry_point("retrieve")

# 定义边：从 retrieve 之后，根据条件决定下一步
def route_after_retrieve(state: AgentState):
    # 这里可以添加逻辑判断：如果知识库结果满意，就去生成回复；否则去查询订单
    # 例如，可以检查结果中是否包含“订单”关键词
    if "order" in state["user_query"].lower():
        return "query_order"
    else:
        return "generate_response"

builder.add_conditional_edges("retrieve", route_after_retrieve)
builder.add_edge("query_order", "generate_response")
builder.add_edge("generate_response", END) # 通常结束

# 也可以添加条件边来决定是否需要人工审核
# def should_review(state): return "human_review" if state.get("needs_human_review") else END
# builder.add_conditional_edges("generate_response", should_review)

# 编译图
graph = builder.compile()

# 步骤 5: 定义工作流执行入口
def langgraph_workflow_handle_query(user_input: str) -> str:
    """LangGraph工作流处理入口"""
    initial_state = {"messages": [], "user_query": user_input, "needs_human_review": False}
    final_state = graph.invoke(initial_state)
    final_message = final_state["messages"][-1]
    return final_message.content

可控的客户 onboarding 审批工作流

一个新客户申请启用高级服务，流程包含自动化检查、风险评估，并可能在特定情况下需要人工审批

• 极致的可控性与可观测性：整个业务流程一目了然，每个状态的变化都被清晰记录，非常适合审计和合规要求高的企业。
• 错误处理与循环：可以轻松处理失败重试、循环审批等复杂逻辑。
• 集成人工环节：完美支持自动化与人工操作的混合工作流（Human-in-the-loop）。

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated, List
from langchain_core.messages import HumanMessage, BaseMessage
import operator
from langchain.chat_models import ChatOpenAI

# 1. 定义状态机（State）的结构，这是LangGraph的核心
class ApplicationState(TypedDict):
    # 整个工作流的完整消息记录
    messages: Annotated[List[BaseMessage], operator.add]
    # 客户申请信息
    application_data: dict
    # 自动化检查结果
    auto_check_result: str | None
    # 是否需要人工审批
    needs_manual_review: bool
    # 最终决策
    final_decision: str | None

# 2. 定义各个节点（Node）函数

def input_node(state: ApplicationState):
    """初始节点：接收用户输入并初始化状态"""
    # 模拟从外部系统接收到的申请数据
    customer_app = {
        "company_name": "Acme Inc.",
        "requested_service_tier": "Enterprise",
        "monthly_volume": 950000, # 高流量触发风控检查
        "country": "US"
    }
    return {
        "messages": [HumanMessage(content=f"New application received: {customer_app}")],
        "application_data": customer_app
    }

def automated_check_node(state: ApplicationState):
    """节点：执行自动化检查和风控"""
    app_data = state["application_data"]
    llm = ChatOpenAI(temperature=0)
    
    # 让LLM根据规则进行风险评估
    risk_prompt = f"""
    Based on the following application, perform a risk assessment.
    Rules: 
    - If monthly volume > 1,000,000, flag for review.
    - If country is not on approved list (US, CA, UK), flag for review.
    - Otherwise, approve.

    Application: {app_data}
    Your response should be only 'APPROVED' or 'FLAGGED' and a brief reason.
    """
    response = llm.invoke(risk_prompt)
    decision = response.content

    # 判断是否需要人工审批
    needs_review = "FLAGGED" in decision

    return {
        "messages": [HumanMessage(content=f"Automated check completed: {decision}")],
        "auto_check_result": decision,
        "needs_manual_review": needs_review
    }

def manual_review_node(state: ApplicationState):
    """节点：模拟人工审批（在实际应用中，这里会等待人工输入）"""
    # 在实际项目中，这里可能：1. 发送邮件 2. 创建工单 3. 调用API等待回调
    print(f"[模拟] 发送邮件给风控团队，申请需要人工审批: {state['application_data']}")
    # 模拟人工审批通过
    manual_decision = "APPROVED" 
    return {"messages": [HumanMessage(content=f"Manual review decision: {manual_decision}")]}

def approval_node(state: ApplicationState):
    """节点：最终批准"""
    return {
        "messages": [HumanMessage(content="Application fully approved. Onboarding process started.")],
        "final_decision": "APPROVED"
    }

def rejection_node(state: ApplicationState):
    """节点：最终拒绝"""
    return {
        "messages": [HumanMessage(content="Application rejected.")],
        "final_decision": "REJECTED"
    }

# 3. 构建图（Graph）并定义边（Edges）
builder = StateGraph(ApplicationState)

# 添加节点
builder.add_node("input", input_node)
builder.add_node("auto_check", automated_check_node)
builder.add_node("manual_review", manual_review_node)
builder.add_node("approve", approval_node)
builder.add_node("reject", rejection_node)

# 设置入口点
builder.set_entry_point("input")

# 定义连接关系（控制流）
builder.add_edge("input", "auto_check")

# 根据自动化检查的结果决定下一步流向
def route_after_auto_check(state: ApplicationState):
    if state["needs_manual_review"]:
        return "manual_review"
    elif "APPROVED" in state["auto_check_result"]:
        return "approve"
    else:
        return "reject"

builder.add_conditional_edges("auto_check", route_after_auto_check, ["manual_review", "approve", "reject"])

# 从人工审批节点出来后，再次决定流向
def route_after_manual_review(state: ApplicationState):
    # 这里简化处理，假设人工总是批准
    return "approve"

builder.add_conditional_edges("manual_review", route_after_manual_review, ["approve"])
builder.add_edge("approve", END)
builder.add_edge("reject", END)

# 4. 编译图
graph = builder.compile()

# 5. 执行工作流
final_state = graph.invoke({})
print("\n工作流执行完毕。最终状态:")
print(f"决策: {final_state['final_decision']}")
print(f"完整消息记录:")
for msg in final_state['messages']:
    print(f"- {msg.content}")

在实际项目中，这些框架并非孤立使用，而是形成一个调用链：

1. 用户请求首先进入LangGraph工作流。
2. LangGraph的第一个节点调用 LlamaIndex 进行知识库检索。
3. 根据路由规则，LangGraph可能调用 LangChain 封装的工具（如订单查询API）。
4. 对于极其复杂、需要多角色会诊的问题，LangGraph可以触发一个子图，该子图调用 AutoGen 的群聊来解决问题。
5. 最后，由LangGraph收集所有结果，生成最终回复或触发人工审核节点。

LangChain案例：展示了其作为通用粘合剂的能力，灵活调用各种工具完成任务导向型的对话。

LlamaIndex案例：展示了其在RAG场景下的专业性和对生产环境特性的支持（数据加载、索引优化、来源追溯）。

AutoGen案例：展示了多智能体协作如何解决单一模型难以完成的复杂、多步骤创造性任务。

LangGraph案例：展示了如何用状态机清晰、可靠地建模一个具有条件分支和人工节点的企业审批流程。