基于LangChain的Ai Agent （1）

OpenAI Functions Agent

概述

现有的大模型可以检测何时应该调用特定的函数,并应该将该函数的正确输入进行响应。在API调用中，您可以描述想要调用的函数，然后让模型智能地选择输出包含调用这些函数所需参数的JSON对象。

在LangChain中，create_openai_functions_agent是一个便捷的函数，用于创建能够与OpenAI提供的函数交互的代理。这使得开发人员可以创建智能应用程序，通过代理与用户进行更自然、更有效的对话。

from langchain import hub
from langchain.agents import create_openai_functions_agent, AgentExecutor
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
from langchain_core.tools import Tool


# 定义查询订单状态的函数
def query_order_status(order_id):
    if order_id == "12345":
        return "订单 12345 的状态是：已发货，预计送达时间是 3-5 个工作日。"
    else:
        return f"未找到订单 {order_id} 的信息，请检查订单号是否正确。"


# 定义退款政策说明函数
def refund_policy(keyword):
    print("keyword = ", keyword)
    return "我们的退款政策是：在购买后30天内可以申请全额退款，需提供购买凭证。"


# 初始化工具
tools = [TavilySearchResults(max_results=1),
         Tool(
             name="queryOrderStatus",
             func=query_order_status,
             description="根据订单ID查询订单状态"
         ),
         Tool(
             name="refundPolicy",
             func=refund_policy,
             description="查询退款政策内容"
         ),
         ]

# 获取使用的提示
prompt = hub.pull("hwchase17/openai-functions-agent")

# 选择将驱动代理的LLM
llm = ChatOpenAI(model="gpt-3.5-turbo-1106")

# 构建OpenAI函数代理
agent = create_openai_functions_agent(llm, tools, prompt)

# 通过传入代理和工具创建代理执行器
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 定义一些测试询问
queries = [
    "请问订单12345的状态是什么？",
    "你们的退款政策是什么？"
]

# 运行代理并输出结果
for input in queries:
    response = agent_executor.invoke({"input": input})
    print(f"客户提问：{input}")
    print(f"代理回答：{response}\n")

OpenAI Tools Agent

某些OpenAI模型可以检测何时应该调用一个或多个函数，并使用应该传递给函数的输入进行响应。在API调用中，可以描述函数，并让模型智能地选择输出包含参数的JSON对象来调用这些函数。这与函数调用非常相似。

OpenAI将调用单个函数的能力称为函数，将调用一个或多个函数的能力称为工具。

from langchain import hub
from langchain.agents import AgentExecutor,create_openai_tools_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
import os
import requests
from langchain_core.tools import Tool
from langchain.tools import BaseTool

from dotenv import load_dotenv

load_dotenv()

# 定义工具
class NumberMulTool(BaseTool):
    name: str = "number-mul"
    description: str = "对两个数字进行乘法运算。输入是一个包含两个数字的JSON对象，返回它们的乘积。"

    def _run(self, a: str, b: str) -> str:
        return str(int(a) * int(b))


# 初始化工具
tools = [TavilySearchResults(max_results=1), NumberMulTool()]

# 提示词，直接从langchain hub上下载
prompt = hub.pull("hwchase17/openai-tools-agent")

# 模型 
model = ChatOpenAI(model="qwen-plus",
                   openai_api_key="sk-xx",
                   openai_api_base="https://dashscope.aliyuncs.com/compatible-mode/v1")

# 定义AI Agent
agent = create_openai_tools_agent(
    llm=model,
    tools=tools,
    prompt=prompt
)

# 定义AgentExecutor，必须使用AgentExecutor，才能执行代理定义的工具
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 定义一些测试询问
queries = [
    "10乘5等于多少？",
    "目前市场上黄金的平均售价是多少？"
]

# 运行代理并输出结果
for input in queries:
    response = agent_executor.invoke({"input": input})
    print(f"提问：{input}")
    print(f"回答：{response}\n")

ReAct Agent

ReAct agent是 LangChain 中的一种聊天代理(Agent)类型。它具有以下独特的特点:

反思能力：ReAct 代理在给出响应之前,会先对自己的行为和预测进行深入的反思和评估。它会检查自己是否遵循了预先设定的规则和指令,是否达到了预期的目标。

自我纠错：如果 ReAct 代理在反思过程中发现自己存在问题或疏漏,它会主动尝试对自己的行为进行纠正和改正,以修复错误,提高自身的表现。

迭代学习：通过不断的反思和自我纠错,ReAct 代理可以在与用户的交互中逐步学习和优化自己的行为方式,不断提高回答的质量和准确性。

可解释性：ReAct 代理在给出最终响应时,会同时提供自己的思考过程和决策依据,使得它的行为更加透明和可解释。

访问 SerpApi ，注册账号，选择相应的订阅计划(Free)，然后获取API Key，利用这个API为大模型提供Google搜索工具。

安装SerpAPI库

pip install google-search-results  -i https://pypi.org/simple

import os
os.environ["SERPAPI_API_KEY"] = xxx

# 加载所需的库
from langchain_community.agent_toolkits.load_tools import load_tools
from langchain.agents import AgentExecutor
from langchain.agents import create_react_agent
from langchain_openai import ChatOpenAI
from langchain import hub

# 初始化大模型:语言模型控制代理
llm= ChatOpenAI(model="qwen-plus",
                   openai_api_key="sk-5xx",
                   openai_api_base="https://dashscope.aliyuncs.com/compatible-mode/v1")

# 设置工具:加载使用的工具，serpapi:调用Google搜索引擎 llm-math:通过LLM进行数学计算的工具
tools = load_tools(["serpapi", "llm-math"], llm=llm)

# 获取使用提示
prompt = hub.pull("hwchase17/react")
print(prompt)

# 初始化Agent:使用工具、语言模型和代理类型来初始化代理
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 让代理来回答提出的问题
agent_executor.invoke({"input": "目前市场上苹果手机16的平均售价是多少？如果我在此基础上加价5%卖出，应该如何定价？"})

可以看到ReAct的过程：

Structured Chat Agent

`create_structured_chat_agent `是 LangChain 提供的一个函数，用于创建结构化聊天代理。这种代理能够根据用户的输入调用预定义的工具函数，并将结果返回给用户。

# 使用 Tavily Search 测试代理
from langchain_community.tools.tavily_search import TavilySearchResults

tools = [TavilySearchResults(max_results=1)]

# 初始化大模型
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(temperature=0.5)

# 创建代理Agent
from langchain.agents import create_structured_chat_agent, AgentExecutor
from langchain import hub

# 获取使用提示，也可以自己写
prompt = hub.pull("hwchase17/structured-chat-agent")
# 初始化Agent
agent = create_structured_chat_agent(
    llm,
    tools,
    prompt
)

# 输入代理和工具，创建代理执行器
agent_executor = AgentExecutor(
    agent=agent, tools=tools, verbose=True, handle_parsing_errors=True
)

# 运行代理Agent
response = agent_executor.invoke({"input": "网站https://www.runoob.com中有哪些教程?"})
print(response)

# 使用 Tavily Search 测试代理
from langchain_community.tools.tavily_search import TavilySearchResults
from dotenv import load_dotenv

load_dotenv()

tools = [TavilySearchResults(max_results=1)]

# 初始化大模型
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="qwen-plus",
                   openai_api_key="sk-xx",
                   openai_api_base="https://dashscope.aliyuncs.com/compatible-mode/v1")

# 创建代理Agent
from langchain.agents import create_structured_chat_agent, AgentExecutor
from langchain import hub

# 获取使用提示，也可以自己写
prompt = hub.pull("hwchase17/structured-chat-agent")
# 初始化Agent
agent = create_structured_chat_agent(
    llm,
    tools,
    prompt
)

# 输入代理和工具，创建代理执行器
agent_executor = AgentExecutor(
    agent=agent, tools=tools, verbose=True, handle_parsing_errors=True
)

# 运行代理Agent
response = agent_executor.invoke({"input": "网站https://www.bilibili.com/中都包含哪些类型的视频?"})
print(response)

Self-Ask with Search Agent

Self-Ask with Search是一个通过搜索自我询问的代理，通过`询问+答案`的机制来帮助大模型寻找事实性问题的过渡性答案，从而引出最终答案。

from langchain import hub
from langchain.agents import AgentExecutor, create_self_ask_with_search_agent
from langchain_community.tools.tavily_search import TavilyAnswer
from langchain_openai import ChatOpenAI
import os
from dotenv import load_dotenv

load_dotenv()


# 将初始化工具，让它提供答案而不是文档
tools = [TavilyAnswer(max_results=1, name="Intermediate Answer", description="Answer Search")]

# 初始化大模型

llm = ChatOpenAI(model="qwen-plus",
                   openai_api_key="sk-xx",
                   openai_api_base="https://dashscope.aliyuncs.com/compatible-mode/v1")


# 获取使用提示 可以修改此提示
prompt = hub.pull("hwchase17/self-ask-with-search")

# 使用搜索代理构建自助询问
agent = create_self_ask_with_search_agent(llm, tools, prompt)

# 通过传入代理和工具创建代理执行程序
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 运行代理
agent_executor.invoke({"input": "深圳属于广东吗?"})

参考

https://blog.csdn.net/qq_38628046/article/details/137641664