LLMs应用开发学习(1) - Intro to LangChain
2025-03-27 20:24:56

Intro to LangChain

**说明：**这个文档用于简单记录我的LangChain学习，在学习过程中，我发现想要系统性地学习LangChain是非常繁琐的，因为它各部分内容的耦合性非常高，无法对单一知识点进行系统概括。所以，学习LangChain的方法是：

  1. 了解LangChain能干什么
  2. 阅读示例代码
  3. 学完各个部分后，自己上手写一个糅合各个功能的Chat Bot

内容简介

通过对LLM或大型语言模型给出提示(prompt)，现在可以比以往更快地开发AI应用程序，但是一个应用程序可能需要进行多轮提示以及解析输出。在此过程有很多重复代码需要编写，基于此需求，哈里森·蔡斯 (Harrison Chase) 创建了LangChain，使开发过程变得更加丝滑。LangChain开源社区快速发展，贡献者已达数百人，正以惊人的速度更新代码和功能。

LangChain 是一个用于开发由大型语言模型 (LLMs) 驱动的应用程序的框架。简单来说，LangChain 可以为LLMs提供一层封装，使得开发下游应用变得简单。

大纲

  • 模型(Models)：集成各种语言模型与向量模型。
  • 存储(Memory)：存储对话历史记录。
  • 链(Chains)：将组件组合实现端到端应用。
  • 代理(Agents)：扩展模型的推理能力。

Install

你可以通过pip来安装LangChain，同时你可能还需要安装其他必要的组件库。

1
2
pip install langchain
pip install langchain-community

quick start

1
2
3
from langchain_community.chat_models import ChatTongyi
chat = ChatTongyi(model='qwen-1.8b-chat',temperature=0.1,api_key='YOUR_KEY')
print(chat.invoke("你好").content)

模型

Prompting Template

在LangChain中，调用模型和使用Prompting Template 变得简便。在应用于比较复杂的场景时，提示可能会非常长并且包含涉及许多细节。使用提示模版，可以让我们更为方便地重复使用设计好的提示。

首先需要使用f字符串定义一个普通的提示模板，使用from_template生成Prompting Template，然后在调用chat的时候填补上这个模板变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate

# 创建ChatTongyi模型实例
chat = ChatTongyi(
    model='qwen-1.8b-chat',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)

# 定义提示模板
template = "请友好地回应以下问候：{greeting}"
prompt = ChatPromptTemplate.from_template(template)

# 使用提示模板生成消息
messages = prompt.format_messages(greeting="你好")

# 调用模型并输出结果
result = chat.invoke(messages)
print(result.content)

Response Template

类似的，在使用Response Template的时候，我们需要使用from_response_schemas来生成Template。

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
46
47
48
49
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate
from langchain.output_parsers import ResponseSchema, StructuredOutputParser

# 创建ChatTongyi模型实例
chat = ChatTongyi(
    model='qwen-1.8b-chat',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)

# 定义提示模板
template = """请根据以下描述，提取相关信息：{description}
                {format_instructions}
            """
prompt = ChatPromptTemplate.from_template(template)

# 定义响应模式（ResponseSchema）
name_schema = ResponseSchema(
    name="name",
    description="描述中提到的名称，如果没有则返回空字符串"
)
age_schema = ResponseSchema(
    name="age",
    description="描述中提到的年龄，如果没有则返回 -1"
)
response_schemas = [name_schema, age_schema]

# 创建输出解析器
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
format_instructions = output_parser.get_format_instructions()
print("输出格式规定：",format_instructions)

# 示例描述
description = "小明今年18岁，是个很聪明的学生。"

# 使用提示模板生成消息，并加入格式化指令
messages = prompt.format_messages(
    description=description,
    format_instructions=format_instructions
)

# 调用模型并获取结果
result = chat.invoke(messages)
print("原始结果:", result.content)

# 使用输出解析器解析结果
parsed_result = output_parser.parse(result.content)
print("解析后的结果:", parsed_result)

得到的结果如下：

存储

在与语言模型交互时，你可能已经注意到一个关键问题：它们并不记忆你之前的交流内容，这在我们构建一些应用程序（如聊天机器人）的时候，带来了很大的挑战，使得对话似乎缺乏真正的连续性。因此，在本节中我们将介绍 LangChain 中的储存模块，即如何将先前的对话嵌入到语言模型中的，使其具有连续对话的能力。

当使用 LangChain 中的储存(Memory)模块时，它旨在保存、组织和跟踪整个对话的历史，从而为用户和模型之间的交互提供连续的上下文。

LangChain 提供了多种储存类型。其中，缓冲区储存允许保留最近的聊天消息，摘要储存则提供了对整个对话的摘要。实体储存则允许在多轮对话中保留有关特定实体的信息。这些记忆组件都是模块化的，可与其他组件组合使用，从而增强机器人的对话管理能力。储存模块可以通过简单的 API 调用来访问和更新，允许开发人员更轻松地实现对话历史记录的管理和维护。

本文主要介绍其中四种储存模块，其他模块可查看文档学习。

  • 对话缓存储存 (ConversationBufferMemory）
  • 对话缓存窗口储存 (ConversationBufferWindowMemory）
  • 对话令牌缓存储存 (ConversationTokenBufferMemory）
  • 对话摘要缓存储存 (ConversationSummaryBufferMemory）

在 LangChain 中，储存指的是大语言模型（LLM）的短期记忆。为什么是短期记忆？那是因为LLM训练好之后 (获得了一些长期记忆)，它的参数便不会因为用户的输入而发生改变。当用户与训练好的LLM进行对话时，LLM 会暂时记住用户的输入和它已经生成的输出，以便预测之后的输出，而模型输出完毕后，它便会“遗忘”之前用户的输入和它的输出。因此，之前的这些信息只能称作为 LLM 的短期记忆。

为了延长 LLM 短期记忆的保留时间，则需要借助一些外部储存方式来进行记忆，以便在用户与 LLM 对话中，LLM 能够尽可能的知道用户与它所进行的历史对话信息。

ConversationBufferMemory

缓存所有历史消息。

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
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# 创建ChatTongyi模型实例
chat = ChatTongyi(
    model='qwen-1.8b-chat',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)

# 初始化ConversationBufferMemory
memory = ConversationBufferMemory()

# 定义一个简单的提示模板，这里可以根据具体需求调整
template = "用户说：{input}"

# 创建ConversationChain，将模型、提示模板和内存整合
conversation = ConversationChain(
    llm=chat,
    memory=memory,
    verbose=True
)

response1 = conversation.predict(input="我的名字叫小李")

response2 = conversation.predict(input="1+1=？")

response3 = conversation.predict(input="我叫什么名字？")

# 查看对话历史记录
print("对话历史记录:", memory.buffer)

输出如下：

ConversationBufferWindowMemory

存储最近的k轮对话。

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
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate
from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationChain


# 创建ChatTongyi模型实例
chat = ChatTongyi(
    model='qwen2-7b-instruct',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)

# 初始化ConversationBufferWindowMemory，设置窗口大小为2
memory = ConversationBufferWindowMemory(k=1)

# 创建ConversationChain，将模型、提示模板和内存整合
conversation = ConversationChain(
    llm=chat,
    memory=memory,
    verbose=False
)

print("第一轮对话：")
print(conversation.predict(input="你好, 我叫小唐"))

print("第二轮对话：")
print(conversation.predict(input="1+1等于多少？"))

print("第三轮对话：")
print(conversation.predict(input="我叫什么名字？"))

输出：

ConversationTokenBufferMemory

涉及到token限制时，可能需要安装tokenizer相关的包，如transformers。除此以外，你还可以使用摘要式的存储，详见官方文档。

使用对话字符缓存记忆，内存将限制保存的token数量。如果字符数量超出指定数目，它会切掉这个对话的早期部分 以保留与最近的交流相对应的字符数量，但不超过字符限制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from langchain_community.chat_models import ChatTongyi
from langchain.memory import ConversationTokenBufferMemory

# 创建ChatTongyi模型实例
chat = ChatTongyi(
    model='qwen2-7b-instruct',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)

# 初始化ConversationTokenBufferMemory，设置token_limit为30（可根据需要调整）
memory = ConversationTokenBufferMemory(
    llm=chat,  # 传入语言模型实例，用于估计token数量
    max_token_limit=30  # 设置最大token数量限制
)

# 保存对话上下文
memory.save_context({"input": "朝辞白帝彩云间，"}, {"output": "千里江陵一日还。"})
memory.save_context({"input": "两岸猿声啼不住，"}, {"output": "轻舟已过万重山。"})

# 加载内存变量
memory_data = memory.load_memory_variables({})
print(memory_data)

输出：

1
{'history': 'AI: 轻舟已过万重山。'}

模型链

链（Chains）通常将大语言模型（LLM）与提示（Prompt）结合在一起，基于此，我们可以对文本或数据进行一系列操作。链（Chains）可以一次性接受多个输入。例如，我们可以创建一个链，该链接受用户输入，使用提示模板对其进行格式化，然后将格式化的响应传递给 LLM 。我们可以通过将多个链组合在一起，或者通过将链与其他组件组合在一起来构建更复杂的链。

LLMChain

这是最简单的最基本的链。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import LLMChain

# 创建ChatTongyi模型实例
chat = ChatTongyi(
    model='qwen2-7b-instruct',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)
# 初始化提示模版，这个提示将接受一个名为product的变量
prompt = ChatPromptTemplate.from_template("描述制造{product}的一个公司的最佳名称是什么?")
# 构建大语言模型链
chain = LLMChain(llm=chat, prompt=prompt)
# 运行大语言模型链
product = "智能手表"
result = chain.run(product)
print(result)

输出：

image-20250323161919789

SimpleSequentialChain

顺序链（SequentialChains）是按预定义顺序执行其链接的链。具体来说，我们将使用简单顺序链（SimpleSequentialChain），这是顺序链的最简单类型，其中每个步骤都有一个输入/输出，一个步骤的输出是下一个步骤的输入。

例如，对于上面的例子，也许我们希望将输出格式化，把所有得到的公司名称使用有序列表输出。

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
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import LLMChain, SimpleSequentialChain
from typing import List

# 创建ChatTongyi模型实例
chat = ChatTongyi(
    model='qwen2-7b-instruct',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)

# 第一个提示模版，这个提示将接受一个名为product的变量
prompt1 = ChatPromptTemplate.from_template("描述制造{product}的一个公司的最佳名称是什么?")
# 构建第一个大语言模型链
chain1 = LLMChain(llm=chat, prompt=prompt1)

# 第二个提示模版，这个提示将接受一个名为company_names的变量
prompt2 = ChatPromptTemplate.from_template("将以下公司名称：{company_names} 格式化为如123等有序列表。不要输出其他任何东西。")
# 构建第二个大语言模型链
chain2 = LLMChain(llm=chat, prompt=prompt2)

# 创建简单顺序链，将两个链按顺序连接
sequential_chain = SimpleSequentialChain(chains=[chain1, chain2], verbose=True)

# 运行简单顺序链
product = "智能手表"
result = sequential_chain.run(product)
print(result)

输出：

SequentialChain

或许，我们同时需要有多个输入和输出，甚至需要在链条中产生交点，这时可以使用SimpleSequentialChain。

比如，我们希望上述的案例中，既能够输出有序列表，也能够输出无序列表

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
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import LLMChain, SequentialChain
from typing import List

# 创建ChatTongyi模型实例
chat = ChatTongyi(
    model='qwen2-7b-instruct',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)

# 第一个提示模版，这个提示将接受一个名为product的变量
prompt1 = ChatPromptTemplate.from_template("描述制造{product}的一个公司的最佳名称是什么?")
# 构建第一个大语言模型链
chain1 = LLMChain(llm=chat, prompt=prompt1, output_key='company_names')

# 第二个提示模版，这个提示将接受一个名为company_names的变量
prompt2 = ChatPromptTemplate.from_template("将以下公司名称：{company_names} 格式化为如123等有序列表。不要输出其他任何东西。")
# 构建第二个大语言模型链
chain2 = LLMChain(llm=chat, prompt=prompt2, output_key='ordered_list')

# 第三个提示模版，这个提示将接受一个名为company_names的变量
prompt3 = ChatPromptTemplate.from_template("将以下公司名称：{company_names} 格式化为无序列表，列表项用'- '开头。不要输出其他任何东西。")
# 构建第三个大语言模型链
chain3 = LLMChain(llm=chat, prompt=prompt3, output_key='unordered_list')

# 创建顺序链，将三个链按顺序连接
sequential_chain = SequentialChain(
    chains=[chain1, chain2, chain3],
    input_variables=['product'],
    output_variables=['ordered_list', 'unordered_list'],
    verbose=True
)

# 运行顺序链
product = "智能手表"
result = sequential_chain(product)
print(result)

输出：

1
2
3
4
5
{
 'product': '智能手表', 
 'ordered_list': '1. FitTech Innovations\n2. ChronoMind\n3. TimeWise Innovations\n4. EvoLoop\n5. SmarTrend\n6. HorizonWearables\n7. VivoLink', 
 'unordered_list': '- FitTech Innovations\n- ChronoMind\n- TimeWise Innovations\n- EvoLoop\n- SmarTrend\n- HorizonWearables\n- VivoLink'
}

Router

到目前为止，我们已经学习了大语言模型链和顺序链。但是，如果我们想做一些更复杂的事情怎么办？一个相当常见但基本的操作是根据输入将其路由到一条链，具体取决于该输入到底是什么。如果你有多个子链，每个子链都专门用于特定类型的输入，那么可以组成一个路由链，它首先决定将它传递给哪个子链，然后将它传递给那个链。

路由器由两个组件组成：

  • 路由链（Router Chain）：路由器链本身，负责选择要调用的下一个链（可以理解为URL路由函数）
  • destination_chains：路由器链可以路由到的链（可以理解为进行操作的函数）
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableBranch, RunnablePassthrough
from langchain.chains import LLMChain
from typing import Dict
from langchain.chains.router import MultiPromptChain  #导入多提示链
from langchain.chains.router.llm_router import LLMRouterChain,RouterOutputParser
from langchain.prompts import PromptTemplate


# 创建ChatTongyi模型实例
llm = ChatTongyi(
    model='qwen2-7b-instruct',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)


# 中文
#第一个提示适合回答物理问题
physics_template = """你是一个非常聪明的物理专家。 \
你擅长用一种简洁并且易于理解的方式去回答问题。\
当你不知道问题的答案时，你承认\
你不知道.

这是一个问题:
{input}"""


#第二个提示适合回答数学问题
math_template = """你是一个非常优秀的数学家。 \
你擅长回答数学问题。 \
你之所以如此优秀， \
是因为你能够将棘手的问题分解为组成部分，\
回答组成部分，然后将它们组合在一起，回答更广泛的问题。

这是一个问题：
{input}"""


#第三个适合回答历史问题
history_template = """你是以为非常优秀的历史学家。 \
你对一系列历史时期的人物、事件和背景有着极好的学识和理解\
你有能力思考、反思、辩证、讨论和评估过去。\
你尊重历史证据，并有能力利用它来支持你的解释和判断。

这是一个问题:
{input}"""


#第四个适合回答计算机问题
computerscience_template = """ 你是一个成功的计算机科学专家。\
你有创造力、协作精神、\
前瞻性思维、自信、解决问题的能力、\
对理论和算法的理解以及出色的沟通技巧。\
你非常擅长回答编程问题。\
你之所以如此优秀，是因为你知道  \
如何通过以机器可以轻松解释的命令式步骤描述解决方案来解决问题，\
并且你知道如何选择在时间复杂性和空间复杂性之间取得良好平衡的解决方案。

这还是一个输入：
{input}"""


# 中文
prompt_infos = [
    {
        "名字": "物理学",
        "描述": "擅长回答关于物理学的问题",
        "提示模板": physics_template
    },
    {
        "名字": "数学",
        "描述": "擅长回答数学问题",
        "提示模板": math_template
    },
    {
        "名字": "历史",
        "描述": "擅长回答历史问题",
        "提示模板": history_template
    },
    {
        "名字": "计算机科学",
        "描述": "擅长回答计算机科学问题",
        "提示模板": computerscience_template
    }
]

destination_chains = {}
for p_info in prompt_infos:
    name = p_info["名字"]
    prompt_template = p_info["提示模板"]
    prompt = ChatPromptTemplate.from_template(template=prompt_template)
    chain = LLMChain(llm=llm, prompt=prompt)
    destination_chains[name] = chain

destinations = [f"{p['名字']}: {p['描述']}" for p in prompt_infos]
destinations_str = "\n".join(destinations)


default_prompt = ChatPromptTemplate.from_template("{input}")
default_chain = LLMChain(llm=llm, prompt=default_prompt)


# 多提示路由模板
MULTI_PROMPT_ROUTER_TEMPLATE = """给语言模型一个原始文本输入，\
让其选择最适合输入的模型提示。\
系统将为您提供可用提示的名称以及最适合改提示的描述。\
如果你认为修改原始输入最终会导致语言模型做出更好的响应，\
你也可以修改原始输入。


<< 格式 >>
返回一个带有JSON对象的markdown代码片段，该JSON对象的格式如下：
```json
{{{{
    "destination": 字符串 \ 使用的提示名字或者使用 "DEFAULT"
    "next_inputs": 字符串 \ 原始输入的改进版本
}}}}



记住：“destination”必须是下面指定的候选提示名称之一，\
或者如果输入不太适合任何候选提示，\
则可以是 “DEFAULT” 。
记住：如果您认为不需要任何修改，\
则 “next_inputs” 可以只是原始输入。

<< 候选提示 >>
{destinations}

<< 输入 >>
{{input}}

<< 输出 (记得要包含 ```json)>>

样例:
<< 输入 >>
"什么是黑体辐射?"
<< 输出 >>
```json
{{{{
    "destination": 字符串 \ 使用的提示名字或者使用 "DEFAULT"
    "next_inputs": 字符串 \ 原始输入的改进版本
}}}}

"""


router_template = MULTI_PROMPT_ROUTER_TEMPLATE.format(
    destinations=destinations_str
)
router_prompt = PromptTemplate(
    template=router_template,
    input_variables=["input"],
    output_parser=RouterOutputParser(),
)

router_chain = LLMRouterChain.from_llm(llm, router_prompt)


#多提示链
chain = MultiPromptChain(router_chain=router_chain,    #路由链路
                         destination_chains=destination_chains,   #目标链路
                         default_chain=default_chain,      #默认链路
                         verbose=True
                        )


re = chain.run("什么是黑体辐射？")
print(re)

输出：

image-20250323164523168

Agent

大型语言模型（LLMs）非常强大，但它们缺乏“最笨”的计算机程序可以轻松处理的特定能力。LLM 对逻辑推理、计算和检索外部信息的能力较弱，这与最简单的计算机程序形成对比。例如，语言模型无法准确回答简单的计算问题，还有当询问最近发生的事件时，其回答也可能过时或错误，因为无法主动获取最新信息。这是由于当前语言模型仅依赖预训练数据，与外界“断开”。要克服这一缺陷，LangChain框架提出了“代理”(Agent)的解决方案。

代理作为语言模型的外部模块，可提供计算、逻辑、检索等功能的支持，使语言模型获得异常强大的推理和获取信息的超能力。

在本章中，我们将详细介绍代理的工作机制、种类、以及如何在LangChain中将其与语言模型配合，构建功能更全面、智能程度更高的应用程序。代理机制极大扩展了语言模型的边界，是当前提升其智能的重要途径之一。让我们开始学习如何通过代理释放语言模型的最大潜力。

LangChain内置工具llm-math和wikipedia

要使用代理 (Agents) ，我们需要三样东西：

  • 一个基本的 LLM
  • 我们将要进行交互的工具 Tools
  • 一个控制交互的代理 (Agents) 。

注意：agent实际上是通过调用pip所安装的包来实现工具调用的，因此，你可能需要安装相关的包才能使agent工作。

1
2
pip install wikipedia
pip install numexpr

代码实现：

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
from langchain_community.chat_models import ChatTongyi
from langchain.agents import load_tools, initialize_agent
from langchain.agents import AgentType
from langchain.prompts import MessagesPlaceholder
from langchain.memory import ConversationBufferMemory

# 创建ChatTongyi模型实例
llm = ChatTongyi(
    model='qwen2-7b-instruct',
    temperature=0.1,
    api_key='sk-433e7960427b44c3b4ff7158ae37608e'
)

# 加载工具
tools = load_tools(
    ["llm-math", "wikipedia"],
    llm=llm
)

# 初始化记忆
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# 初始化代理
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    handle_parsing_errors=True,
    verbose=True,
    agent_kwargs={
        "extra_prompt_messages": [MessagesPlaceholder(variable_name="chat_history")]
    }
)

# 使用代理回答数学问题
agent("计算300的25%")

输出：

image-20250323184523459

agent是一步步识别你的需求，并调用工具解决问题的。其步骤如下：

  1. 模型对于接下来需要做什么，给出思考

    思考：我可以使用计算工具来计算300的25%

  2. 模型基于思考采取行动

    行动: 使用计算器（calculator），输入（action_input）300*0.25

  3. 模型得到观察

    观察：答案: 75.0

  4. 基于观察，模型对于接下来需要做什么，给出思考

    思考: 计算工具返回了300的25%，答案为75

  5. 给出最终答案（Final Answer）

    最终答案: 300的25%等于75。

  6. 以字典的形式给出最终答案。

LangChain内置工具PythonREPLTool

这个工具可以让agent创建一个自己的python交互式环境，然后编写python代码进行逻辑处理，得到特定结果。

下面是一个将人名转化为拼音的agent用例：

1
2
3
4
5
6
7
8
9
10
11
from langchain.agents.agent_toolkits import create_python_agent
from langchain.tools.python.tool import PythonREPLTool

agent = create_python_agent(
    llm,  #使用前面一节已经加载的大语言模型
    tool=PythonREPLTool(), #使用Python交互式环境工具 REPLTool
    verbose=True #输出中间步骤
)
customer_list = ["小明","小黄","小红","小蓝","小橘","小绿",]

agent.run(f"将使用pinyin拼音库这些客户名字转换为拼音，并打印输出列表: {customer_list}。")

定义自己的tool

langchain的定制能力非凡，允许你定义自己的tool，你可以将一个自定义的函数通过@tool注解封装为tool。

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
# 导入tool函数装饰器
from langchain.agents import tool
from datetime import date

@tool
def time(text: str) -> str:
    """
    返回今天的日期，用于任何需要知道今天日期的问题。\
    输入应该总是一个空字符串，\
    这个函数将总是返回今天的日期，任何日期计算应该在这个函数之外进行。
    """
    return str(date.today())

# 初始化代理
agent= initialize_agent(
    tools=[time], #将刚刚创建的时间工具加入代理
    llm=llm, #初始化的模型
    agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,  #代理类型
    handle_parsing_errors=True, #处理解析错误
    verbose = True #输出中间步骤
)

# 使用代理询问今天的日期. 
# 注: 代理有时候可能会出错（该功能正在开发中）。如果出现错误，请尝试再次运行它。
agent("今天的日期是？")

参考

1 面向开发者的大模型手册

2 吴恩达面向开发者的 Prompt 工程