全网最全AI智能体框架终极指南：从CoT到Plan-and-Execute，附LangGraph完整代码 原创

# 基础依赖
pip install langchain langchain-openai langchain-community

# LangGraph（用于高级Agent功能）
pip install langgraph

# 工具依赖
pip install tavily-python  # 搜索工具
pip install arxiv  # 学术论文搜索
pip install wikipedia-api  # Wikipedia查询

# 可选：监控和调试
pip install langsmith

import os
os.environ["OPENAI_API_KEY"] = "your-api-key"
os.environ["TAVILY_API_KEY"] = "your-tavily-key"  # 获取地址：https://tavily.com

prompt = """
问题：如果一个班级有28个学生，其中女生比男生多4人，请问男生有多少人？

让我们一步步思考：
"""

prompt = """
问题：Roger有5个网球。他又买了2罐网球，每罐有3个球。他现在有多少个网球？
思考过程：Roger开始有5个球。2罐，每罐3个球，就是2×3=6个球。5+6=11个球。
答案：11个球

问题：食堂有23个苹果。如果他们用了20个做午餐，又买了6个，他们有多少个苹果？
思考过程：[模型生成]
"""

Thought 1: 我需要搜索最新的人口数据
Action 1: Search("中国人口 2024")
Observation 1: 根据最新统计，中国人口约为14.1亿

Thought 2: 现在我需要计算两倍的值
Action 2: Calculate(14.1 * 2)
Observation 2: 28.2

Thought 3: 我现在知道答案了
Final Answer: 中国人口的两倍是28.2亿

from langchain import hub
from langchain.agents import AgentExecutor, create_react_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI

# 初始化LLM
llm = ChatOpenAI(model="gpt-4", temperature=0)

# 定义工具
tools = [
    TavilySearchResults(max_results=3, description="搜索互联网获取最新信息")
]

# 使用预定义的ReAct提示词模板
prompt = hub.pull("hwchase17/react")

# 创建ReAct agent
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 执行查询
result = agent_executor.invoke({
    "input": "2024年诺贝尔物理学奖获得者是谁？他们的主要贡献是什么？"
})

from langchain_core.prompts import PromptTemplate

template = '''Answer the following questions as best you can. 
You have access to the following tools:

{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought: {agent_scratchpad}'''

prompt = PromptTemplate.from_template(template)

# 使用自定义提示词创建agent
agent = create_react_agent(llm, tools, prompt)

from langchain.chat_models import init_chat_model
from langchain_tavily import TavilySearch
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent

# 创建带有记忆功能的ReAct agent
memory = MemorySaver()
model = init_chat_model("anthropic:claude-3-5-sonnet-latest")
search = TavilySearch(max_results=2)
tools = [search]

# 创建支持多轮对话的agent
agent_executor = create_react_agent(
    model, 
    tools, 
    checkpointer=memory  # 启用对话记忆
)

# 使用配置管理对话线程
config = {"configurable": {"thread_id": "abc123"}}

# 第一轮对话
response1 = agent_executor.invoke(
    {"messages": [{"role": "user", "content": "我叫张三，住在北京"}]},
    config
)

# 第二轮对话（agent会记住之前的信息）
response2 = agent_executor.invoke(
    {"messages": [{"role": "user", "content": "我住在哪里？"}]},
    config
)

from langchain_core.tools import tool

@tool
def get_weather(location: str) -> str:
    """获取指定城市的天气信息"""
    # 这里可以调用真实的天气API
    if"北京"in location:
        return"北京今天晴天，温度23°C，空气质量良好"
    returnf"无法获取{location}的天气信息"

@tool
def calculate(expression: str) -> str:
    """计算数学表达式"""
    try:
        result = eval(expression)
        returnf"计算结果：{result}"
    except:
        return"计算错误，请检查表达式"

# 使用自定义工具创建agent
tools = [get_weather, calculate, search]
agent = create_react_agent(model, tools, checkpointer=memory)

# 安装experimental包
# pip install langchain-experimental

from langchain.chains import LLMMathChain
from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
from langchain_core.tools import Tool
from langchain_experimental.plan_and_execute import (
    PlanAndExecute,
    load_agent_executor,
    load_chat_planner,
)
from langchain_openai import ChatOpenAI

# 初始化LLM
llm = ChatOpenAI(model="gpt-4", temperature=0)

# 定义工具
search = DuckDuckGoSearchAPIWrapper()
llm_math_chain = LLMMathChain.from_llm(llm=llm)

tools = [
    Tool(
        name="Search",
        func=search.run,
        description="用于搜索当前事件和信息"
    ),
    Tool(
        name="Calculator",
        func=llm_math_chain.run,
        description="用于数学计算"
    ),
]

# 创建planner和executor
planner = load_chat_planner(llm)
executor = load_agent_executor(llm, tools, verbose=True)

# 创建Plan-and-Execute agent
agent = PlanAndExecute(planner=planner, executor=executor, verbose=True)

# 使用agent
result = agent.run("研究2024年诺贝尔物理学奖获得者并计算他们的平均年龄")

from typing import Union, List, Tuple, Optional
from pydantic import BaseModel, Field
from enum import Enum

class ExecutionStatus(Enum):
    """执行状态枚举"""
    SUCCESS = "success"
    FAILURE = "failure"
    PARTIAL = "partial"
    NEEDS_RETRY = "needs_retry"

class PlanEvaluation(BaseModel):
    """计划评估结果"""
    needs_replan: bool = Field(description="是否需要重新规划")
    reason: Optional[str] = Field(description="需要重新规划的原因")
    new_plan: Optional[List[str]] = Field(description="新的执行计划")
    continue_execution: bool = Field(description="是否继续执行")

class SmartPlanExecute(TypedDict):
    """增强的状态定义"""
    input: str
    original_plan: List[str]  # 保存原始计划
    plan: List[str]  # 当前待执行的计划
    past_steps: List[Tuple[str, str, ExecutionStatus]]  # 包含状态
    response: Optional[str]
    replan_count: int  # 重新规划次数
    max_replans: int  # 最大重新规划次数

asyncdef smart_execute_step(state: SmartPlanExecute):
    """智能执行步骤，包含错误处理"""
    ifnot state["plan"]:
        return {}
    
    task = state["plan"][0]
    max_retries = 3
    
    for attempt in range(max_retries):
        try:
            # 执行任务
            result = await agent_executor.ainvoke({
                "messages": [{"role": "user", "content": task}]
            })
            
            # 评估执行结果
            status = await evaluate_execution_result(task, result)
            
            # 记录执行结果
            return {
                "past_steps": [(task, result["messages"][-1].content, status)],
                "plan": state["plan"][1:]  # 移除已执行的步骤
            }
            
        except Exception as e:
            if attempt < max_retries - 1:
                await asyncio.sleep(2 ** attempt)  # 指数退避
                continue
            else:
                # 记录失败
                return {
                    "past_steps": [(task, f"执行失败: {str(e)}", ExecutionStatus.FAILURE)],
                    "plan": state["plan"][1:]
                }

asyncdef evaluate_execution_result(task: str, result: dict) -> ExecutionStatus:
    """评估任务执行结果"""
    evaluation_prompt = """
    评估以下任务执行结果：
    
    任务：{task}
    结果：{result}
    
    请判断执行状态：
    - SUCCESS: 完全成功
    - PARTIAL: 部分成功，可能需要补充
    - FAILURE: 执行失败
    - NEEDS_RETRY: 需要重试
    
    只返回状态值。
    """
    
    response = await llm.ainvoke(
        evaluation_prompt.format(
            task=task,
            result=result["messages"][-1].content
        )
    )
    
    # 解析状态
    status_text = response.content.strip().upper()
    for status in ExecutionStatus:
        if status.value.upper() in status_text or status.name in status_text:
            return status
    
    return ExecutionStatus.SUCCESS  # 默认为成功

asyncdef intelligent_replan_step(state: SmartPlanExecute):
    """智能重新规划，考虑多种因素"""
    # 检查是否超过最大重新规划次数
    if state["replan_count"] >= state.get("max_replans", 3):
        return {
            "response": "达到最大重新规划次数，使用当前结果生成报告。\n" + 
                       await generate_best_effort_report(state)
        }
    
    # 分析执行历史
    analysis = await analyze_execution_history(state)
    
    if analysis.needs_replan:
        # 生成新计划
        new_plan = await generate_adaptive_plan(
            state["input"],
            state["past_steps"],
            state["plan"],
            analysis.reason
        )
        
        return {
            "plan": new_plan,
            "replan_count": state["replan_count"] + 1
        }
    
    elif len(state["plan"]) == 0:
        # 所有步骤完成，生成最终报告
        return {"response": await generate_intelligent_report(state)}
    
    else:
        # 继续执行
        return {}

asyncdef analyze_execution_history(state: SmartPlanExecute) -> PlanEvaluation:
    """深度分析执行历史"""
    # 统计执行状态
    status_counts = {}
    for _, _, status in state["past_steps"]:
        status_counts[status] = status_counts.get(status, 0) + 1
    
    # 获取最近的执行结果
    recent_failures = [
        (task, result) for task, result, status in state["past_steps"][-3:]
        if status in [ExecutionStatus.FAILURE, ExecutionStatus.NEEDS_RETRY]
    ]
    
    # 构建分析提示
    analysis_prompt = """
    分析任务执行情况并决定是否需要重新规划：
    
    原始目标：{input}
    执行统计：{status_counts}
    最近失败：{recent_failures}
    剩余任务：{remaining_tasks}
    
    考虑因素：
    1. 失败率是否过高？
    2. 是否发现了原计划未考虑的情况？
    3. 剩余任务是否仍然适用？
    4. 是否需要新的方法或工具？
    
    返回JSON格式：
    {{
        "needs_replan": true/false,
        "reason": "重新规划的原因",
        "suggestions": ["建议1", "建议2"]
    }}
    """
    
    response = await llm.ainvoke(
        analysis_prompt.format(
            input=state["input"],
            status_counts=status_counts,
            recent_failures=recent_failures,
            remaining_tasks=state["plan"]
        )
    )
    
    # 解析响应
    import json
    try:
        analysis_data = json.loads(response.content)
        return PlanEvaluation(
            needs_replan=analysis_data.get("needs_replan", False),
            reason=analysis_data.get("reason"),
            continue_execution=not analysis_data.get("needs_replan", False)
        )
    except:
        # 如果解析失败，默认继续执行
        return PlanEvaluation(
            needs_replan=False,
            continue_execution=True
        )

asyncdef generate_adaptive_plan(
    original_goal: str,
    past_steps: List[Tuple],
    remaining_tasks: List[str],
    replan_reason: str
) -> List[str]:
    """生成自适应的新计划"""
    adaptive_prompt = """
    基于执行历史生成新的计划：
    
    原始目标：{goal}
    已执行步骤：{past}
    原剩余任务：{remaining}
    重新规划原因：{reason}
    
    请生成新的执行计划，要求：
    1. 避免重复已成功的步骤
    2. 解决发现的问题
    3. 使用替代方法处理失败的任务
    4. 保持计划简洁高效
    
    每行一个步骤：
    """
    
    response = await llm.ainvoke(
        adaptive_prompt.format(
            goal=original_goal,
            past=past_steps,
            remaining=remaining_tasks,
            reason=replan_reason
        )
    )
    
    return parse_new_plan(response.content)

# 构建增强的工作流
def build_smart_plan_execute_workflow():
    workflow = StateGraph(SmartPlanExecute)
    
    # 添加节点
    workflow.add_node("planner", initial_plan_step)
    workflow.add_node("executor", smart_execute_step)
    workflow.add_node("analyzer", intelligent_replan_step)
    
    # 设置流程
    workflow.set_entry_point("planner")
    workflow.add_edge("planner", "executor")
    workflow.add_edge("executor", "analyzer")
    
    # 条件边：根据分析结果决定下一步
    def route_after_analysis(state: SmartPlanExecute):
        if"response"in state and state["response"]:
            return"end"
        elif state["plan"]:
            return"executor"
        else:
            return"end"
    
    workflow.add_conditional_edges(
        "analyzer",
        route_after_analysis,
        {
            "executor": "executor",
            "end": END
        }
    )
    
    return workflow.compile()

# 使用示例
smart_agent = build_smart_plan_execute_workflow()

result = await smart_agent.ainvoke({
    "input": "分析竞争对手的产品策略并提出改进建议",
    "replan_count": 0,
    "max_replans": 3
})

class HybridAgent:
    def __init__(self):
        self.cot_llm = ChatOpenAI(model="gpt-3.5-turbo")
        self.react_agent = create_react_agent(...)
        self.plan_execute_agent = create_plan_and_execute_agent(...)
        
    def analyze_complexity(self, query: str) -> ComplexityAnalysis:
    """
    分析查询的复杂度，考虑以下因素：
    - 任务是否需要多步骤推理
    - 是否需要外部信息
    - 任务的结构化程度
    - 是否有明确的执行路径
    """
    pass
    
    def process(self, query):
        complexity = self.analyze_complexity(query)
        
        if complexity == "simple":
            # 简单问题直接用CoT
            return self.cot_llm.invoke(f"{query}\n让我们一步步思考：")
        elif complexity == "exploratory":
            # 探索性问题用ReAct
            return self.react_agent.invoke({"input": query})
        else:
            # 复杂结构化任务用Plan-and-Execute
            return self.plan_execute_agent.invoke({"input": query})

from langchain.cache import InMemoryCache
import langchain

# 启用缓存减少重复调用
langchain.llm_cache = InMemoryCache()

import asyncio

async def parallel_agent_execution(queries):
    agents = [create_react_agent(llm, tools) for _ in queries]
    tasks = [agent.ainvoke({"input": q}) for agent, q in zip(agents, queries)]
    return await asyncio.gather(*tasks)

def select_model(task_type):
    model_map = {
        "reasoning": "gpt-4",  # 复杂推理用大模型
        "extraction": "gpt-3.5-turbo",  # 信息提取用快速模型
        "classification": "gpt-3.5-turbo",  # 分类任务用快速模型
        "creative": "claude-3-opus"  # 创意任务用Claude
    }
    return model_map.get(task_type, "gpt-3.5-turbo")

from tenacity import retry, stop_after_attempt, wait_exponential

class RobustAgent:
    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
    asyncdef execute_with_retry(self, task):
        try:
            result = await self.agent.ainvoke(task)
            return result
        except Exception as e:
            # 记录错误
            logger.error(f"Agent execution failed: {e}")
            
            # 回退到更简单的方法
            if hasattr(self, 'fallback_agent'):
                returnawait self.fallback_agent.ainvoke(task)
            raise

任务类型判断：
├── 纯推理任务（不需要外部信息）
│   └── 使用 CoT
├── 需要实时信息或工具调用
│   ├── 探索性/动态任务
│   │   └── 使用 ReAct
│   └── 结构化/可预测任务
│       └── 使用 Plan-and-Execute

# 开始时使用简单的Zero-Shot CoT
prompt = "问题：{question}\n让我们一步步思考："

# 添加基础工具
tools = [search_tool]
agent = create_react_agent(llm, tools)

# 当流程稳定后，使用Plan-and-Execute提升效率
planner_agent = create_plan_and_execute_agent(
    planner_llm=expensive_model,  # 只在规划时使用大模型
    executor_llm=cheap_model,      # 执行时使用小模型
    tools=tools
)

# 使用LangSmith进行追踪
from langsmith import Client
client = Client()
# 启用追踪来监控agent性能