智能体执行器 (Agent Executor)

概述

智能体执行器(Agent Executor)是LangChain框架中的核心组件，负责协调智能体的思考过程和工具调用。它充当了智能体与其环境之间的桥梁，管理执行流程，并确保任务能够被正确完成。智能体执行器接收用户输入，将其传递给智能体进行推理，然后执行智能体决定要采取的行动，并将结果返回给智能体继续推理，直到任务完成。

工作原理

智能体执行器的工作流程如下：

1. 接收输入：接收用户查询或任务描述
2. 智能体规划：将输入传递给智能体，智能体决定下一步行动
3. 工具执行：执行智能体选择的工具
4. 结果处理：将工具执行结果返回给智能体
5. 迭代或完成：智能体可能决定执行更多操作或返回最终答案
6. 输出结果：将智能体的最终回答返回给用户

主要特性

• 循环控制：管理智能体的推理-行动循环
• 早期停止条件：可自定义何时停止迭代（最大迭代次数、特定标记等）
• 状态跟踪：维护对话历史和执行状态
• 错误处理：处理工具执行过程中的异常
• 中间步骤返回：可选择性地返回思考过程和中间步骤

基本用法示例

以下是创建和使用基本智能体执行器的完整示例：

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import DuckDuckGoSearchRun, WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

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

# 创建工具集合
tools = [
    DuckDuckGoSearchRun(name="搜索"),
    WikipediaQueryRun(name="维基百科", api_wrapper=WikipediaAPIWrapper())
]

# 创建智能体提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有帮助的AI助手。你有权访问以下工具：{tools}"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

# 创建智能体
agent = create_react_agent(llm=llm, tools=tools, prompt=prompt)

# 创建智能体执行器
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 执行智能体查询
result = agent_executor.invoke({"input": "谁是阿尔伯特·爱因斯坦，他在哪一年获得诺贝尔奖？"})

print(result["output"])

高级用法

自定义早期停止条件

from typing import List, Tuple, Union, Dict, Any
from langchain.schema import AgentAction, AgentFinish

def custom_stopping_condition(
    intermediate_steps: List[Tuple[AgentAction, str]]
) -> bool:
    # 实现你自定义的停止逻辑
    # 例如，如果中间步骤超过5个或者检测到某些关键词
    if len(intermediate_steps) > 5:
        return True
    for action, _ in intermediate_steps:
        if "critical_info_found" in action.log:
            return True
    return False

# 使用自定义停止条件创建执行器
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    early_stopping_method="force",  # 可以是 "force" 或 "generate"
    custom_stopping_condition=custom_stopping_condition
)

返回中间步骤

# 设置return_intermediate_steps=True以返回中间推理和操作步骤
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    return_intermediate_steps=True
)

result = agent_executor.invoke({"input": "比较太阳系中最大的三颗行星"})

# 访问中间步骤
for i, (action, observation) in enumerate(result["intermediate_steps"]):
    print(f"步骤 {i+1}:")
    print(f"  行动: {action.tool} - {action.tool_input}")
    print(f"  观察: {observation}\n")

处理工具错误

def faulty_tool(*args, **kwargs):
    raise Exception("此工具故意失败以展示错误处理")

tools = [
    DuckDuckGoSearchRun(name="搜索"),
    Tool(
        name="有问题的工具",
        func=faulty_tool,
        description="这个工具会引发错误"
    )
]

# 设置max_iterations以避免无限循环
# 设置handle_parsing_errors以处理LLM输出解析错误
# 设置handle_tool_errors以处理工具执行错误
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=5,
    handle_parsing_errors=True,
    handle_tool_errors=True
)

最佳实践

1. 适当设置最大迭代次数：防止智能体陷入无限循环。

   agent_executor = AgentExecutor(agent=agent, tools=tools, max_iterations=10)
   

2. 启用详细模式进行调试：开发时启用verbose=True以查看执行过程。

3. 处理错误：启用错误处理功能以增强稳健性。

   agent_executor = AgentExecutor(
       agent=agent, 
       tools=tools, 
       handle_parsing_errors=True,
       handle_tool_errors=True
   )
   

4. 使用LangSmith进行监控：将执行器与LangSmith集成以监控性能。

   import os
   os.environ["LANGCHAIN_TRACING_V2"] = "true"
   os.environ["LANGCHAIN_API_KEY"] = "your-api-key"
   

5. 使用异步API提高性能：对于需要处理多个查询的应用，使用异步API。

   result = await agent_executor.ainvoke({"input": "查询内容"})
   

常见问题与解决方案

1. 智能体执行器陷入循环

   • 解决方案：设置合理的max_iterations值
   • 实现自定义停止条件

2. 工具执行失败

   • 解决方案：启用handle_tool_errors=True
   • 为工具提供更明确的描述和错误处理

3. 解析错误

   • 解决方案：启用handle_parsing_errors=True
   • 使用更结构化的提示模板指导LLM输出

4. 长响应超时

   • 解决方案：实现异步执行和流式响应
   • 将复杂任务分解为更小的子任务

高级场景

将AgentExecutor集成到更大的应用程序中

from langchain.chains import ConversationChain, LLMChain
from langchain.memory import ConversationBufferMemory

# 创建带记忆的对话链
memory = ConversationBufferMemory(return_messages=True)
conversation_chain = ConversationChain(llm=llm, memory=memory, verbose=True)

def process_user_query(query):
    # 决定是否需要使用工具
    planning_chain = LLMChain(llm=llm, prompt=planning_prompt)
    plan = planning_chain.run(query=query)
    
    if "需要工具" in plan:
        # 使用智能体执行器处理查询
        return agent_executor.invoke({"input": query})["output"]
    else:
        # 使用简单对话链处理查询
        return conversation_chain.run(query)

总结

智能体执行器是LangChain中最强大的组件之一，它使LLM能够通过迭代推理和工具使用来解决复杂问题。通过了解其工作原理并遵循最佳实践，开发者可以创建能够解决各种任务的强大智能体系统。