Langchain 自定义工具和内置工具

使用介绍

自定义工具时的元素概念介绍

在Langchain中，工具（Tool）是与语言模型交互的基本单元。以下是自定义工具时的关键元素：

name

• 定义：工具的名称，用于唯一标识该工具。
• 作用：当工具被集成到Agent中时，Agent会根据工具名称来调用它。

description

• 定义：工具的功能描述，通常是一个字符串。
• 作用：帮助语言模型理解工具的作用。例如，在ReAct模式下，模型会根据工具的描述选择合适的工具来完成任务。

args_schema

• 定义：工具的输入参数结构，通常使用Pydantic模型定义。
• 如何使用：
  • 定义一个继承自pydantic.BaseModel的类，指定工具的输入参数。
  • 将该类赋值给args_schema属性。
• 示例：

  from pydantic import BaseModel, Field
  
  class SearchInput(BaseModel):
      query: str = Field(description="The search query")
  
  tool = StructuredTool(
      name="search",
      description="Searches the web for information.",
      args_schema=SearchInput,
      func=search_function
  )
  

return_direct

• 定义：是否直接返回工具的结果，而不经过后续处理。
• 作用：如果设置为True，工具的结果将直接返回给用户或Agent，而不会被进一步解析。

@tool/BaseTool/StructuredTool 的新建方式及参数介绍

@tool 装饰器

• 同步工具：

  from langchain.tools import tool
  
  @tool
  def search(query: str) -> str:
      return f"Search results for '{query}'"
  

• 异步工具：

  from langchain.tools import tool
  
  @tool
  async def async_search(query: str) -> str:
      return f"Async search results for '{query}'"
  

BaseTool 类

• 同步工具：

  from langchain.tools.base import BaseTool
  
  class MyTool(BaseTool):
      name = "my_tool"
      description = "A custom tool"
  
      def _run(self, input_str: str) -> str:
          return f"Processed input: {input_str}"
  
      async def _arun(self, input_str: str) -> str:
          return f"Async processed input: {input_str}"
  

• 参数：
  • name：工具名称。
  • description：工具描述。
  • _run：同步执行函数。
  • _arun：异步执行函数（可选）。

StructuredTool 类

• 同步工具：

  from langchain.tools.base import StructuredTool
  
  def search_function(query: str) -> str:
      return f"Search results for '{query}'"
  
  tool = StructuredTool(
      name="search",
      description="Searches the web for information.",
      args_schema=SearchInput,
      func=search_function
  )
  

• 异步工具：

  async def async_search_function(query: str) -> str:
      return f"Async search results for '{query}'"
  
  tool = StructuredTool(
      name="async_search",
      description="Performs an asynchronous web search.",
      args_schema=SearchInput,
      func=async_search_function
  )
  

使用场景

• @tool：适合快速定义简单的工具。
• BaseTool：适合需要更多自定义逻辑的工具。
• StructuredTool：适合需要严格输入验证的工具。

工具异常处理方案 (ToolException)

如何使用函数进行异常处理

• 在工具函数中捕获异常并返回友好的错误信息。
• 示例：

  from langchain.tools.base import ToolException
  
  def error_handling_tool(input_str: str) -> str:
      try:
          # 模拟可能出错的操作
          if not input_str:
              raise ValueError("Input cannot be empty")
          return f"Processed input: {input_str}"
      except Exception as e:
          raise ToolException(f"Error in tool: {e}")
  

集成到工具中

• 使用StructuredTool时，可以在func中添加异常处理逻辑。
• 示例：

  def safe_search_function(query: str) -> str:
      try:
          if not query:
              raise ValueError("Query cannot be empty")
          return f"Search results for '{query}'"
      except Exception as e:
          raise ToolException(f"Search failed: {e}")
  
  tool = StructuredTool(
      name="safe_search",
      description="Safe search with error handling.",
      args_schema=SearchInput,
      func=safe_search_function
  )
  

普通调用和Agent调用

普通调用

• 直接调用工具函数。
• 示例：

  result = search("Langchain")
  print(result)  # 输出: Search results for 'Langchain'
  

Agent调用

• 将工具集成到Agent中，通过Agent调用工具。
• 示例：

  from langchain.agents import initialize_agent
  from langchain.llms import OpenAI
  
  llm = OpenAI()
  tools = [search]
  
  agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)
  response = agent.run("What is Langchain?")
  print(response)
  

5. 最佳实践

@tool 装饰器

• 参数：
  • 确保description清晰准确。
  • 如果工具需要复杂输入，考虑使用StructuredTool。
• 异常处理：
  • 在工具函数中捕获所有可能的异常，并抛出ToolException。

BaseTool

• 参数：
  • 明确定义_run和_arun方法。
  • 使用args_schema确保输入格式正确。
• 异常处理：
  • 在_run和_arun中捕获异常并抛出ToolException。

StructuredTool

• 参数：
  • 使用args_schema定义输入参数。
  • 确保func函数逻辑清晰。
• 异常处理：
  • 在func中捕获异常并抛出ToolException。

综合建议

• 输入验证：始终验证输入数据，避免非法输入导致工具失败。
• 日志记录：在工具中添加日志记录，便于调试和监控。
• 文档化：为每个工具提供详细的description，帮助模型更好地理解和使用工具。

最佳实践

文字转SQL

1. 安装必要的库

首先，确保你已经安装了所需的库：

pip install langchain sqlalchemy openai

2. 创建 SQL 查询工具

我们将创建一个自定义的 SQL 查询工具，该工具可以执行 SQL 查询并返回结果。这里我们使用 SQLite 数据库作为示例。

2.1 定义工具类

from langchain.tools import BaseTool
from sqlalchemy import create_engine, text

class SQLQueryTool(BaseTool):
    name = "sql_query_tool"
    description = "A tool that executes SQL queries and returns the results."

    def __init__(self, db_url: str):
        self.engine = create_engine(db_url)

    def run(self, query: str) -> str:
        with self.engine.connect() as connection:
            result = connection.execute(text(query))
            rows = result.fetchall()
            columns = result.keys()
            return [dict(zip(columns, row)) for row in rows]

2.2 初始化工具

db_url = "sqlite:///example.db"  # 替换为你的数据库 URL
sql_query_tool = SQLQueryTool(db_url)

3. 创建自然语言到 SQL 的转换工具

我们将使用一个简单的自然语言处理库（如 sqlglot）来将自然语言文本转换为 SQL 查询。

3.1 安装 sqlglot

pip install sqlglot

3.2 定义转换工具类

import sqlglot
from langchain.tools import BaseTool

class NLtoSQLTool(BaseTool):
    name = "nl_to_sql_tool"
    description = "A tool that converts natural language to SQL queries."

    def run(self, nl_query: str) -> str:
        try:
            sql_query = sqlglot.transpile(nl_query, read="english", write="sql")[0]
            return sql_query
        except Exception as e:
            return f"Error converting natural language to SQL: {e}"

3.3 初始化转换工具

nl_to_sql_tool = NLtoSQLTool()

4. 创建 LangChain 环境

我们将创建一个 LangChain 环境，并将两个工具添加到其中。

4.1 创建 Agent

我们将使用 OpenAI 的 LLM 和 ReAct 策略来创建一个 Agent。

from langchain.llms import OpenAI
from langchain.agents import initialize_agent, Tool

# 初始化 OpenAI LLM
llm = OpenAI(api_key="your_openai_api_key")  # 替换为你的 OpenAI API 密钥

# 创建工具列表
tools = [
    Tool(
        name=sql_query_tool.name,
        func=sql_query_tool.run,
        description=sql_query_tool.description
    ),
    Tool(
        name=nl_to_sql_tool.name,
        func=nl_to_sql_tool.run,
        description=nl_to_sql_tool.description
    )
]

# 初始化 Agent
agent = initialize_agent(tools, llm, agent="react-docstore", verbose=True)

5. 使用 Agent 执行自然语言查询

现在我们可以使用这个 Agent 来执行自然语言查询。

nl_query = "查询年龄大于25岁的用户"
response = agent.run(nl_query)
print(response)

6. 完整代码示例

以下是完整的代码示例，包含了上述所有步骤。

from langchain.tools import BaseTool
from sqlalchemy import create_engine, text
import sqlglot
from langchain.llms import OpenAI
from langchain.agents import initialize_agent, Tool

# 定义 SQL 查询工具类
class SQLQueryTool(BaseTool):
    name = "sql_query_tool"
    description = "A tool that executes SQL queries and returns the results."

    def __init__(self, db_url: str):
        self.engine = create_engine(db_url)

    def run(self, query: str) -> str:
        with self.engine.connect() as connection:
            result = connection.execute(text(query))
            rows = result.fetchall()
            columns = result.keys()
            return [dict(zip(columns, row)) for row in rows]

# 初始化 SQL 查询工具
db_url = "sqlite:///example.db"  # 替换为你的数据库 URL
sql_query_tool = SQLQueryTool(db_url)

# 定义自然语言到 SQL 的转换工具类
class NLtoSQLTool(BaseTool):
    name = "nl_to_sql_tool"
    description = "A tool that converts natural language to SQL queries."

    def run(self, nl_query: str) -> str:
        try:
            sql_query = sqlglot.transpile(nl_query, read="english", write="sql")[0]
            return sql_query
        except Exception as e:
            return f"Error converting natural language to SQL: {e}"

# 初始化自然语言到 SQL 的转换工具
nl_to_sql_tool = NLtoSQLTool()

# 初始化 OpenAI LLM
llm = OpenAI(api_key="your_openai_api_key")  # 替换为你的 OpenAI API 密钥

# 创建工具列表
tools = [
    Tool(
        name=sql_query_tool.name,
        func=sql_query_tool.run,
        description=sql_query_tool.description
    ),
    Tool(
        name=nl_to_sql_tool.name,
        func=nl_to_sql_tool.run,
        description=nl_to_sql_tool.description
    )
]

# 初始化 Agent
agent = initialize_agent(tools, llm, agent="react-docstore", verbose=True)

# 使用 Agent 执行自然语言查询
nl_query = "查询年龄大于25岁的用户"
response = agent.run(nl_query)
print(response)

调用API

1. 自定义插件的基本概念

LangChain 的插件机制允许你通过 Python 类来封装特定的功能。一个插件通常包含以下几个部分：

• 初始化 (__init__)：用于设置插件所需的配置或依赖。
• 核心功能方法：实现插件的核心逻辑。
• 与 LangChain 的集成：通过 LangChain 提供的接口（如 Tool 或 Runnable）将插件注册到系统中。

2. 创建一个调用外部 API 的插件

假设我们有一个场景：需要调用一个天气 API 来获取某个城市的实时天气信息。我们将创建一个自定义插件来实现这一功能。

步骤 1: 定义插件类

首先，我们需要定义一个 Python 类来封装调用天气 API 的逻辑。

import requests

class WeatherAPIPlugin:
    def __init__(self, api_key):
        """
        初始化插件，设置 API 密钥。
        :param api_key: 天气 API 的密钥
        """
        self.api_key = api_key
        self.base_url = "https://api.weatherapi.com/v1/current.json"

    def get_weather(self, city):
        """
        获取指定城市的实时天气信息。
        :param city: 城市名称
        :return: 天气信息的字符串描述
        """
        params = {
            "key": self.api_key,
            "q": city
        }
        try:
            response = requests.get(self.base_url, params=params)
            response.raise_for_status()  # 检查请求是否成功
            data = response.json()
            weather_info = (
                f"当前 {city} 的天气情况:\n"
                f"温度: {data['current']['temp_c']}°C\n"
                f"湿度: {data['current']['humidity']}%\n"
                f"天气状况: {data['current']['condition']['text']}"
            )
            return weather_info
        except requests.exceptions.RequestException as e:
            return f"无法获取天气信息: {str(e)}"

步骤 2: 将插件封装为 LangChain 的 Tool

LangChain 提供了 Tool 类，用于将自定义功能集成到链式逻辑中。我们需要将 WeatherAPIPlugin 的功能封装为一个 Tool。

from langchain.tools import Tool

# 假设你的 API 密钥如下
API_KEY = "your_weather_api_key_here"

# 实例化插件
weather_plugin = WeatherAPIPlugin(api_key=API_KEY)

# 将插件封装为 LangChain 的 Tool
weather_tool = Tool(
    name="Weather API Tool",
    func=weather_plugin.get_weather,
    description="获取指定城市的实时天气信息。输入应为城市名称，例如 '北京'。"
)

步骤 3: 使用插件

现在我们可以将这个插件集成到 LangChain 的工作流中。以下是一个简单的示例，展示如何调用插件并获取天气信息。

from langchain.agents import initialize_agent, AgentType
from langchain.llms import OpenAI

# 初始化 LLM（这里使用 OpenAI 的 GPT 模型）
llm = OpenAI(temperature=0, openai_api_key="your_openai_api_key_here")

# 初始化代理（Agent），并将插件添加到工具列表中
agent = initialize_agent(
    tools=[weather_tool],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# 调用插件
response = agent.run("请告诉我北京的天气情况。")
print(response)

3. 示例运行结果

假设天气 API 返回的数据如下：

{
  "current": {
    "temp_c": 15,
    "humidity": 60,
    "condition": {
      "text": "晴朗"
    }
  }
}

运行上述代码后，输出可能如下：

当前 北京 的天气情况:
温度: 15°C
湿度: 60%
天气状况: 晴朗

智能家居插件

1. 背景知识：LangChain 的 Agent 和 Tool

LangChain 提供了一个灵活的架构，允许我们定义 Tool（工具）和 Agent（代理）。Tool 是封装特定功能的模块，而 Agent 则负责根据用户输入选择合适的 Tool 并执行任务。

对于家庭硬件的控制，我们可以将硬件接口封装为一个 Tool，然后通过 LangChain 的 Agent 来调用它。

2. 家庭硬件的典型场景

假设你有一个家庭自动化系统，其中包含以下硬件：

• 灯光控制器：可以打开或关闭灯光。
• 温度传感器：可以读取当前室内温度。
• 窗帘控制器：可以打开或关闭窗帘。

我们将这些硬件的功能封装为 LangChain 的 Tool，并通过自然语言交互来控制它们。

3. 创建自定义插件

3.1 硬件接口模拟

为了演示方便，我们假设有一个 Python API 可以与家庭硬件通信。以下是一个简单的模拟接口：

class HomeHardwareAPI:
    def __init__(self):
        self.light_status = "off"
        self.temperature = 22.5  # 模拟当前温度
        self.curtain_status = "closed"

    def toggle_light(self, action):
        if action.lower() == "on":
            self.light_status = "on"
            return "Light turned on."
        elif action.lower() == "off":
            self.light_status = "off"
            return "Light turned off."
        else:
            return "Invalid action."

    def get_temperature(self):
        return f"Current temperature is {self.temperature}°C."

    def control_curtains(self, action):
        if action.lower() == "open":
            self.curtain_status = "open"
            return "Curtains opened."
        elif action.lower() == "close":
            self.curtain_status = "closed"
            return "Curtains closed."
        else:
            return "Invalid action."

3.2 封装为 LangChain 工具

接下来，我们将上述硬件接口封装为 LangChain 的 Tool：

from langchain.agents import Tool
from langchain.chains.conversation.memory import ConversationBufferMemory
from langchain.chat_models import ChatOpenAI
from langchain.agents import initialize_agent

# 假设我们已经有一个硬件 API 实例
home_hardware_api = HomeHardwareAPI()

# 定义工具函数
def toggle_light(action):
    return home_hardware_api.toggle_light(action)

def get_temperature():
    return home_hardware_api.get_temperature()

def control_curtains(action):
    return home_hardware_api.control_curtains(action)

# 将工具封装为 LangChain 的 Tool
tools = [
    Tool(
        name="Toggle Light",
        func=lambda action: toggle_light(action),
        description="Use this tool to turn the light on or off. Input should be 'on' or 'off'."
    ),
    Tool(
        name="Get Temperature",
        func=get_temperature,
        description="Use this tool to get the current room temperature."
    ),
    Tool(
        name="Control Curtains",
        func=lambda action: control_curtains(action),
        description="Use this tool to open or close the curtains. Input should be 'open' or 'close'."
    )
]

4. 初始化 Agent

LangChain 的 Agent 负责解析用户的自然语言输入并调用相应的 Tool。以下是初始化 Agent 的代码：

# 初始化对话记忆
memory = ConversationBufferMemory(memory_key="chat_history")

# 使用 OpenAI 的 GPT-3.5-turbo 模型
llm = ChatOpenAI(temperature=0)

# 初始化 Agent
agent_chain = initialize_agent(
    tools, llm, agent="chat-conversational-react-description", verbose=True, memory=memory
)

5. 实际场景调用

5.1 用户输入示例

假设用户通过自然语言与系统交互，以下是一些可能的输入及其响应：

# 示例 1: 打开灯光
response = agent_chain.run("Please turn the light on.")
print(response)  # 输出: Light turned on.

# 示例 2: 获取当前温度
response = agent_chain.run("What is the current temperature?")
print(response)  # 输出: Current temperature is 22.5°C.

# 示例 3: 打开窗帘
response = agent_chain.run("Can you open the curtains?")
print(response)  # 输出: Curtains opened.

# 示例 4: 关闭灯光
response = agent_chain.run("Turn the light off.")
print(response)  # 输出: Light turned off.

6. 运行结果分析

• 当用户输入“Please turn the light on.”时，Agent 会识别出这是对灯光的操作请求，并调用 toggle_light 工具。
• 当用户输入“What is the current temperature?”时，Agent 会调用 get_temperature 工具返回当前温度。
• 类似地，其他命令也会被正确解析并执行。

7. 扩展功能

7.1 添加更多硬件支持

如果需要支持更多的硬件（例如空调、音响等），只需扩展 HomeHardwareAPI 类并添加相应的 Tool。

7.2 集成真实硬件

在实际应用中，你可以通过 MQTT、HTTP API 或其他协议与真实硬件通信。例如：

• 使用 MQTT 订阅/发布消息来控制灯光和窗帘。
• 通过 HTTP 请求获取传感器数据。

7.3 自然语言优化

为了让 Agent 更好地理解复杂的用户输入，可以训练一个定制化的语言模型，或者使用更高级的提示工程技巧。

8. 总结

通过 LangChain 的 Tool 和 Agent，我们可以轻松实现家庭硬件的智能化控制。本文展示了如何将硬件接口封装为 LangChain 的工具，并通过自然语言交互调用这些工具。希望这个示例能帮助你更好地理解和应用 LangChain！

内置Tools

Langchain 内置工具介绍

Langchain 提供了丰富的内置工具，这些工具分为两类：

1. langchain.tools：核心库中的工具。
2. langchain_community.tools：社区扩展的工具。

1. AI 工具 (生成文本)

简介

• 使用 LLM 生成文本。
• 常用于回答问题、生成内容等。

代码示例

from langchain.tools import AI
from langchain.llms import OpenAI

llm = OpenAI(temperature=0)
ai_tool = AI(name="ai", llm=llm, description="Generates text using an LLM.")

response = ai_tool.run("Write a short story about a cat.")
print(response)

2. Wikipedia 工具 (搜索维基百科)

简介

• 搜索维基百科以获取信息。
• 适合需要权威知识的任务。

代码示例

from langchain.tools import WikipediaQueryRun
from langchain.utilities import WikipediaAPIWrapper

wiki = WikipediaAPIWrapper()
wikipedia_tool = WikipediaQueryRun(api_wrapper=wiki, name="wikipedia")

response = wikipedia_tool.run("Python programming language")
print(response)

3. Arxiv 工具 (搜索学术论文)

简介

• 搜索 Arxiv 上的学术论文。
• 适合科研场景。

代码示例

from langchain.tools import ArxivQueryRun
from langchain.utilities import ArxivAPIWrapper

arxiv = ArxivAPIWrapper()
arxiv_tool = ArxivQueryRun(api_wrapper=arxiv, name="arxiv")

response = arxiv_tool.run("machine learning")
print(response)

4. SerpAPI 工具 (搜索引擎)

简介

• 使用 SerpAPI 搜索网络信息。
• 需要 API 密钥。

代码示例

from langchain.tools import SerpAPIWrapper

serp_api_key = "your_serp_api_key"
search = SerpAPIWrapper(serpapi_api_key=serp_api_key)

response = search.run("LangChain tutorial")
print(response)

5. GoogleSearch 工具 (谷歌搜索)

简介

• 使用 Google Custom Search API 搜索信息。
• 需要 API 密钥和搜索引擎 ID。

代码示例

from langchain.tools import GoogleSearchResults

google_api_key = "your_google_api_key"
search_engine_id = "your_search_engine_id"

search = GoogleSearchResults(api_key=google_api_key, k=3, cx=search_engine_id)
response = search.run("LangChain examples")
print(response)

6. DuckDuckGoSearch 工具 (DuckDuckGo 搜索)

简介

• 使用 DuckDuckGo 搜索信息。
• 不需要 API 密钥。

代码示例

from langchain.tools import DuckDuckGoSearchRun

duckduckgo_tool = DuckDuckGoSearchRun()

response = duckduckgo_tool.run("LangChain documentation")
print(response)

7. SQLDatabase 工具 (数据库查询)

简介

• 查询 SQL 数据库。
• 需要连接到数据库。

代码示例

from langchain.tools import SQLDatabaseTool
from langchain.utilities import SQLDatabase

db = SQLDatabase.from_uri("sqlite:///example.db")
sql_tool = SQLDatabaseTool(db=db, name="sql_database")

response = sql_tool.run("SELECT * FROM users LIMIT 5;")
print(response)

8. YouTubeSearch 巐具 (YouTube 搜索)

简介

• 搜索 YouTube 视频。
• 需要 API 密钥。

代码示例

from langchain.tools import YouTubeSearchTool

youtube_tool = YouTubeSearchTool()

response = youtube_tool.run("LangChain tutorial")
print(response)

9. FileManagement 工具 (文件管理)

简介

• 管理本地或远程文件。
• 支持读取、写入和删除文件。

代码示例

from langchain.tools.file_management import ReadFileTool, WriteFileTool

# 写入文件
write_tool = WriteFileTool()
write_tool.run("example.txt", "Hello, LangChain!")

# 读取文件
read_tool = ReadFileTool()
content = read_tool.run("example.txt")
print(content)

10. HumanInput 工具 (人工输入)

简介

• 请求人工输入。
• 适用于需要用户干预的场景。

代码示例

from langchain.tools import HumanInputRun

human_tool = HumanInputRun()

response = human_tool.run("What is your opinion on this?")
print(response)

总结

内置工具包

内置工具包的使用 (langchain_community.agent_toolkits)

langchain_community.agent_toolkits 提供了一系列预定义的工具包（toolkits），这些工具包将多个相关工具组合在一起，方便快速构建特定领域的 Agent

1. Zapier Toolkit (集成 Zapier 自动化工具)

简介

• 使用 Zapier API 调用各种自动化任务。
• 需要 Zapier 的 API 密钥。

代码示例

from langchain_community.agents.agent_toolkits import ZapierToolkit
from langchain_community.utilities.zapier import ZapierNLAWrapper

# 初始化 Zapier NLA Wrapper
zapier = ZapierNLAWrapper()

# 创建 Zapier Toolkit
toolkit = ZapierToolkit.from_zapier_nla_wrapper(zapier)

# 查看工具包中的工具
print(toolkit.get_tools())

2. Conversational Agent Toolkit (对话型 Agent 工具包)

简介

• 专为对话型 Agent 设计。
• 包含问答、搜索、生成等工具。

代码示例

from langchain_community.agents.agent_toolkits import create_conversational_react_agent
from langchain_community.tools import AI, WikipediaQueryRun
from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
from langchain.llms import OpenAI

# 初始化 LLM 和工具
llm = OpenAI(temperature=0)
wiki = WikipediaAPIWrapper()
tools = [AI(name="ai", llm=llm, description="Generates text using an LLM."),
         WikipediaQueryRun(api_wrapper=wiki, name="wikipedia")]

# 创建对话型 Agent
agent = create_conversational_react_agent(llm, tools)

# 运行 Agent
response = agent.run("What is the capital of France?")
print(response)

3. SQL Database Toolkit (SQL 数据库工具包)

简介

• 用于查询 SQL 数据库。
• 支持 SQLite、PostgreSQL 等数据库。

代码示例

from langchain_community.agents.agent_toolkits import SQLDatabaseToolkit
from langchain_community.utilities.sql_database import SQLDatabase
from langchain_community.agents.agent_toolkits import create_sql_agent
from langchain.llms import OpenAI

# 连接数据库
db = SQLDatabase.from_uri("sqlite:///example.db")

# 创建 SQL Toolkit
toolkit = SQLDatabaseToolkit(db=db)

# 创建 SQL Agent
agent = create_sql_agent(
    llm=OpenAI(temperature=0),
    toolkit=toolkit,
    verbose=True
)

# 查询数据库
response = agent.run("How many users are in the database?")
print(response)

4. GitHub Toolkit (GitHub 工具包)

简介

• 用于与 GitHub 交互。
• 支持查询仓库、提交、Issues 等。

代码示例

from langchain_community.agents.agent_toolkits import GitHubToolkit
from langchain_community.utilities.github import GitHubAPIWrapper

# 初始化 GitHub API Wrapper
github = GitHubAPIWrapper()

# 创建 GitHub Toolkit
toolkit = GitHubToolkit(github_api_wrapper=github)

# 查看工具包中的工具
print(toolkit.get_tools())

5. VectorStore Toolkit (向量存储工具包)

简介

• 用于与向量数据库交互。
• 常用于语义搜索和知识库管理。

代码示例

from langchain_community.agents.agent_toolkits import VectorStoreToolkit
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import OpenAIEmbeddings
from langchain_community.agents.agent_toolkits import create_vectorstore_agent
from langchain.llms import OpenAI

# 初始化向量存储
vectorstore = Chroma(embedding_function=OpenAIEmbeddings())

# 创建 VectorStore Toolkit
toolkit = VectorStoreToolkit(vectorstore=vectorstore)

# 创建 VectorStore Agent
agent = create_vectorstore_agent(
    llm=OpenAI(temperature=0),
    toolkit=toolkit,
    verbose=True
)

# 搜索向量数据库
response = agent.run("What is the most relevant document to 'LangChain'?")
print(response)

6. YouTube Toolkit (YouTube 工具包)

简介

• 用于与 YouTube 交互。
• 支持搜索视频、获取视频信息等。

代码示例

from langchain_community.agents.agent_toolkits import YouTubeToolkit
from langchain_community.utilities.youtube import YouTubeAPIWrapper

# 初始化 YouTube API Wrapper
youtube = YouTubeAPIWrapper()

# 创建 YouTube Toolkit
toolkit = YouTubeToolkit(youtube=youtube)

# 查看工具包中的工具
print(toolkit.get_tools())

7. SerpAPI Toolkit (搜索引擎工具包)

简介

• 用于搜索网络信息。
• 支持 Google、Bing 等搜索引擎。

代码示例

from langchain_community.agents.agent_toolkits import SerpAPIToolkit
from langchain_community.utilities.serpapi import SerpAPIWrapper

# 初始化 SerpAPI Wrapper
serpapi = SerpAPIWrapper(serpapi_api_key="your_serp_api_key")

# 创建 SerpAPI Toolkit
toolkit = SerpAPIToolkit(serpapi_wrapper=serpapi)

# 查看工具包中的工具
print(toolkit.get_tools())

8. File Management Toolkit (文件管理工具包)

简介

• 用于管理本地或远程文件。
• 支持读取、写入和删除文件。

代码示例

from langchain_community.agents.agent_toolkits import FileManagementToolkit

# 创建 File Management Toolkit
toolkit = FileManagementToolkit(root_dir="./files")

# 查看工具包中的工具
print(toolkit.get_tools())

总结