LangChain之工具Tools（上）_langchain model 绑定tools

工具Tools

概述

工具是代理、链或LLM可以用来与世界互动的接口。它们结合了几个要素：

工具的名称

工具的描述

该工具输入的JSON模式

要调用的函数

是否应将工具结果直接返回给用户
1
2
3
4
5
6
7
8
9

LangChain通过提供统一框架集成功能的具体实现。在框架内，每个功能被封装成一个工具，具有自己的输入输出及处理方法。代理接收任务后，通过大模型推理选择适合的工具处理任务。一旦选定，LangChain将任务输入传递给该工具，工具处理输入生成输出。输出经过大模型推理，可用于其他工具的输入或作为最终结果返回给用户。

简单的说就是：代理根据任务类型和需求通过大模型推理选择工具处理任务，LangChain传递任务输入给工具生成输出，输出再经大模型推理，作为其他工具输入或最终结果返回给用户。

工具列表

具体工具Tools详情参考：Tools文档

参考连接

内置工具：有关所有内置工具的列表，请参阅此页面

自定义工具：虽然内置工具很有用，但很可能必须定义自己的工具。请参阅本指南

工具包：工具包是可以很好地协同工作的工具的集合。请参阅此页面

工具的初步认识

Wikidata工具

维基数据是一个自由开放的知识库，人类和机器都可以阅读和编辑。维基数据是世界上最大的开放知识库之一。

WikipediaAPIWrapper是维基百科的包装器，通过它进行维基百科的搜索查询

安装Wikidata相关库

pip install wikipedia
1

具体实现代码如下

from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper

# 初始化工具 可以根据需要进行配置
# 使用包装器WikipediaAPIWrapper进行搜索并获取页面摘要。默认情况下，它将返回前 k 个结果的页面摘要。它通过 doc_content_chars_max 限制文档内容。
api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=100)
tool = WikipediaQueryRun(api_wrapper=api_wrapper)

# 工具默认名称
print(tool.name)
# 工具默认的描述
print(tool.description)
# 输入内容 默认JSON模式
print(tool.args)
# 工具是否应该直接返回给用户
print(tool.return_direct)

# 可以用字典输入来调用这个工具
print(tool.run({"query": "langchain"}))
# 使用单个字符串输入来调用该工具。
print(tool.run("langchain"))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

wikipedia
A wrapper around Wikipedia. Useful for when you need to answer general questions about people, places, companies, facts, historical events, or other subjects. Input should be a search query.
{'query': {'title': 'Query', 'type': 'string'}}
False
Page: LangChain
Summary: LangChain is a framework designed to simplify the creation of applications 
Page: LangChain
Summary: LangChain is a framework designed to simplify the creation of applications 
1
2
3
4
5
6
7
8

自定义默认工具​

可以修改参数的内置名称、描述和JSON模式。

在定义参数的JSON模式时，重要的是输入保持与函数相同，因此不应更改它，但可以轻松地为每个输入定义自定义描述。

from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_core.pydantic_v1 import BaseModel, Field

# 初始化工具 可以根据需要进行配置
api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=100)


class WikiInputs(BaseModel):
    """维基百科工具的输入。"""

    query: str = Field(
        description="维基百科中的查询，字数应在3个字以内"
    )


tool = WikipediaQueryRun(
    name="wiki-tool",
    description="在维基百科中查找内容",
    args_schema=WikiInputs,
    api_wrapper=api_wrapper,
    return_direct=True,
)

print(tool.run("langchain"))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

工具的加载方式

通常使用以下形式代码加载工具

from langchain.agents import load_tools

tool_names = ['tool_name_1','tool_name_2']
tools = load_tools(tool_names)
1
2
3
4

有些工具（链、代理）可能需要使用LLM来初始化

from langchain.agents import load_tools

tool_names = ['tool_name_1','tool_name_2']
llm = ChatOpenAI(temperature=0.0)
tools = load_tools(tool_names, llm=llm)
1
2
3
4
5

自定义工具

在LangChain中，自定义工具有多种方法

@tool装饰器

@tool装饰器是定义自定义工具的最简单方法。装饰器默认使用函数名称作为工具名称，但可以通过传递字符串作为第一个参数来覆盖此设置。此外，装饰器将使用函数的文档字符串作为工具的描述 - 因此必须提供文档字符串。

示例：

from langchain.tools import tool

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

print(multiply.name)
print(multiply.description)
print(multiply.args)

res = multiply.run({"a": 10, "b": 20})
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13

输出：

通过将工具名称和 JSON 参数传递到工具装饰器来自定义

from langchain.pydantic_v1 import BaseModel, Field
from langchain.tools import tool

class SearchInput(BaseModel):
    query: str = Field(description="should be a search query")


@tool("search-tool", args_schema=SearchInput, return_direct=True)
def search(query: str) -> str:
    """Look up things online."""
    return "LangChain"

print(search.name)
print(search.description)
print(search.args)

res = search.run({"query": "start test"})
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

BaseTool

通过子类化 BaseTool 类来明确定义自定义工具。这可以最大程度地控制工具定义，但工作量会更大。

示例：

from langchain.pydantic_v1 import BaseModel, Field
from typing import Optional, Type
from langchain_core.tools import BaseTool

from langchain.callbacks.manager import (
    AsyncCallbackManagerForToolRun,
    CallbackManagerForToolRun,
)


class CalculatorInput(BaseModel):
    a: int = Field(description="第一个数字")
    b: int = Field(description="第二个数字")


class CustomCalculatorTool(BaseTool):
    name = "Calculator"
    description = "在需要回答有关数学的问题时很有用"
    args_schema: Type[BaseModel] = CalculatorInput
    return_direct: bool = True

    def _run(
            self, a: int, b: int, run_manager: Optional[CallbackManagerForToolRun] = None
    ) -> str:
        """使用该工具。"""
        return a * b

    async def _arun(
            self,
            a: int,
            b: int,
            run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
    ) -> str:
        """异步使用该工具。"""
        raise NotImplementedError("Calculator 不支持异步")


multiply = CustomCalculatorTool()
print(multiply.name)
print(multiply.description)
print(multiply.args)
print(multiply.return_direct)

res = multiply.run({"a": 10, "b": 20})
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

输出：

StructuredTool

还可以使用StructuredTool数据类。此方法是前两种方法的混合。它比从 BaseTool 类继承更方便，但提供的功能比仅使用装饰器更多

from langchain_core.tools import StructuredTool
def search_function(query: str):
    result = query + " : LangChain"
    return result

search = StructuredTool.from_function(
    func=search_function,
    name="Search",
    description="在需要回答有关当前事件的问题时很有用",
)

print(search.name)
print(search.description)
print(search.args)

res = search.run("start query")
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

自定义 args_schema 来提供有关输入的更多信息

from langchain.pydantic_v1 import BaseModel, Field
from langchain_core.tools import StructuredTool
class CalculatorInput(BaseModel):
    a: int = Field(description="第一个数字")
    b: int = Field(description="第二个数字")

def multiply(a: int, b: int) -> int:
    """将两个数字相乘。"""
    return a * b

calculator = StructuredTool.from_function(
        func=multiply,
        name="Calculator",
        description="multiply numbers",
        args_schema=CalculatorInput,
        return_direct=True,
    )

res = calculator.run({"a":10,"b":20})
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

处理工具错误

当工具遇到错误且异常未被捕获时，代理将停止执行。如果希望代理继续执行，可以引发 ToolException 并相应地设置 handle_tool_error。

from langchain_core.tools import StructuredTool
from langchain_core.tools import ToolException


def search_tool(s: str):
    raise ToolException("模拟出现异常")

search = StructuredTool.from_function(
    func=search_tool,
    name="Search_tool",
    description="一个搜索工具",
    handle_tool_error=True,
)

res = search.run("test")
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

当ToolException抛出时，代理不会停止工作，可以根据handle_tool_error工具的变量来处理异常，并将处理结果作为观察返回给代理，并以红色打印。

from langchain_core.tools import StructuredTool
from langchain_core.tools import ToolException


def search_tool(s: str):
    raise ToolException("模拟出现异常")


def _handle_error(error: ToolException) -> str:
    result = "工具执行发生错误：" + error.args[0]
    return result


search = StructuredTool.from_function(
    func=search_tool,
    name="Search_tool",
    description="一个搜索工具",
    handle_tool_error=_handle_error,
)

res = search.run("test")
print(res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22