LangChain实战快速入门笔记（一）--LangChain使用概述

作者：CSDN博客
文章目录

一、介绍LangChain

1.什么是LangChain2.有哪些大模型应用开发应用开发框架？3.为什么需要LangChain4.LangChain的使用场景5.LangChin资料介绍6.LangChain架构设计

6.1 总体架构图6.2 内部架构详情



二、开发前准备工作

2.1 前置知识2.2 相关环境安装

2.2.1 安装 Python 或 Anaconda2.2.2 创建虚拟环境2.2.3 如何下载安装包2.2.4 pycharm开发环境



三、大模型应用开发

3.1 基于RAG架构的开发3.2 基于Agent架构的开发3.3 大模型应用开发的4个场景

3.3.1 场景 1：纯 Prompt3.3.2 场景 2：Agent + Function Calling3.3.3 场景 3：RAG3.3.4 场景 4：Fine-tuning（精调/微调）



四、LangChain的核心组件

4.1 一个问题引发的思考

4.2 核心组件的概述4.3 核心组件的说明

核心组件1：Model I/O核心组件2：Chains核心组件3：Memory核心组件4：Agents核心组件5：Retrieval核心组件6：Callbacks

4.4 小结

5.LangChain的helloword

5.1 获取大模型5.2 使用提示词模板5.3 使用输出解析器5.4 使用向量存储5.5 RAG（检索增强生成）5.6 使用Agent



总结

---

一、介绍LangChain

1.什么是LangChain

LangChain 是 2022 年 10 月，由哈佛大学的 Harrison Chase（哈里森・蔡斯）发起研发的一个开源框架，用于开发由大语言模型（LLMs）驱动的应用程序。
比如，搭建 “智能体”（Agent）、问答系统（QA）、对话机器人、文档搜索系统、企业私有知识库等。
简而言之：
LangChain ≠ LLMs
LangChain 之于 LLMs，类似 Spring 之于 JavaLangChain 之于 LLMs，类似 Django、Flask 之于 Python顾名思义，
LangChain 中的 “Lang” 是指 language，即大语言模型，“Chain” 即 “链”，也就是将大模型与外部数据 & 各种组件连接成链，以此构建 AI 应用程序。
大模型相关的岗位：

2.有哪些大模型应用开发应用开发框架？

3.为什么需要LangChain

问题 1：LLMs 用的好好的，干嘛还需要 LangChain？
在大语言模型（LLM）如 ChatGPT、Claude、DeepSeek 等快速发展的今天，开发者不仅希望能 “使用” 这些模型，还希望能将它们灵活集成到自己的应用中，实现更强大的对话能力、检索增强生成（RAG）、工具调用（Tool Calling）、多轮推理等功能。

LangChain 为更方便解决这些问题，而生的。比如：大模型默认不能联网，如果需要联网，用 langchain。
问题 2：我们可以使用 GPT 或 GLM4 等模型的 API 进行开发，为何需要 LangChain 这样的框架？
不使用 LangChain，确实可以使用 GPT 或 GLM4 等模型的 API 进行开发。比如，搭建 “智能体”（Agent）、问答系统、对话机器人等复杂的 LLM 应用。
但使用 LangChain 的好处：
（1）简化开发难度：更简单、更高效、效果更好
（2）学习成本更低：不同模型的 API 不同，调用方式也有区别，切换模型时学习成本高。使用 LangChain，可以以统一、规范的方式进行调用，有更好的移植性。
（3）现成的链式组装：LangChain 提供了一些现成的链式组装，用于完成特定的高级任务。让复杂的逻辑变得结构化、易组合、易扩展

问题 3：LangChain 提供了哪些功能呢？
LangChain 是一个帮助你构建 LLM 应用的全套工具集。这里涉及到 prompt 构建、LLM 接入、记忆管理、工具调用、RAG、智能体开发等模块。
学习 LangChain 最好的方式就是做项目。
4.LangChain的使用场景

LangChain的位置：

5.LangChin资料介绍

官网地址：https://www.langchain.com/langchain
官网文档：https://python.langchain.com/docs/introduction/
API 文档：https://python.langchain.com/api_reference/github
地址：https://github.com/langchain-ai/langchain
6.LangChain架构设计

6.1 总体架构图

V0.1版本

V0.2/V0.3版本

6.2 内部架构详情

结构1：LangChain
langchain：构成应用程序认知架构的 Chains，Agents，Retrieval strategies 等

构成应用程序的链、智能体、RAG。

langchain-community：第三方集成

比如：Model I/O、Retrieval、Tool & Toolkit；合作伙伴包 langchain-openai，langchain-anthropic 等。

langchain-Core：基础抽象和 LangChain 表达式语言（LCEL）
小结：LangChain，就是 AI 应用组装套件，封装了一堆的 API。langchain 框架不大，但是里面嵌碎的知识点特别多。就像玩乐高，提供了很多标准化的乐高零件（比如，连接器、轮子等）
结构 2：LangGraph
LangGraph 可以看做基于 LangChain 的 api 的进一步封装，能够协调多个 Chain、Agent、Tools 完成更复杂的任务，实现更高级的功能。
结构 3：LangSmith
https://docs.smith.langchain.com/
链路追踪。提供了 6 大功能，涉及 Debugging (调试)、Playground (沙盒)、Prompt Management (提示管理)、Annotation (注释)、Testing (测试)、Monitoring (监控) 等。与 LangChain 无缝集成，帮助你从原型阶段过渡到生产阶段。

正是因为 LangSmith 这样的工具出现，才使得 LangChain 意义更大，要不仅靠一些 API（当然也可以不用，用原生的 API），支持不住 LangChain 的热度。

结构 4：LangServe
将 LangChain 的可运行项和链部署为 REST API，使得它们可以通过网络进行调用。
Java 怎么调用 langchain 呢？就通过这个 langserve。将 langchain 应用包装成一个 rest api，对外暴露服务。同时，支持更高的并发，稳定性更好。
总结：LangChain 当中，最有前途的两个模块就是：LangGraph，LangSmith。
LangChain 能做 RAG，其它的一些框架也能做，而且做的也不错，比如 LlamaIndex。所以这时候 LangChain 要在 Agent 这块发力，那就需要 LangGraph。而 LangSmith，做运维、监控。故，二者是 LangChain 里最有前途的。
二、开发前准备工作

2.1 前置知识

1.Python基础语法
2.大语言模型基础
2.2 相关环境安装

2.2.1 安装 Python 或 Anaconda

LangChain 基于 Python 开发，因此需确保系统中安装了 Python。
方式 1：直接下载 Python 安装包。推荐版本为 Python 3.10 及以上Python 官网：https://www.python.org/
方式 2：使用包管理工具（如 Anaconda）进行安装。通过 Anaconda 可以轻松创建和管理虚拟环境，为项目提供独立的依赖空间，避免不同项目之间的依赖冲突。
2.2.2 创建虚拟环境

为了保持项目的独立性与环境的干净，建议使用虚拟环境。可以在 Anaconda 中创建虚拟环境。
2.2.3 如何下载安装包

比如：安装 langchain 包
方式 1：使用 pip 指令
基础指令：

1. # 安装包（默认最新版）
2. pip install langchain
4. # 指定版本
5. pip installlangchain==0.3.7
7. # 批量安装（空格分隔）
8. pip install langchain requests numpy
10. # 升级包
11. pip install --upgrade langchain
13. # 卸载包
14. pip uninstall langchain
16. # 查看已安装包
17. pip list

复制代码

高级操作

1. # 国内镜像加速（解决下载慢）-i: 指定镜像源
2. pip install -i https://mirrors.aliyun.com/pypi/simple/ langchain
4. # 从本地/URL安装:
5. pip install ./local_package.whl
6. pip install https://github.com/user/repo/archive/main.zip

复制代码

方式2：使用conda指令

1. # 安装包（默认仓库）
2. conda install langchain
4. # 指定频道（如 conda-forge）
5. conda install -c conda-forge langchain==0.3.7
7. # 更新包
8. conda update langchain
10. # 卸载包
11. conda uninstall langchain
13. # 查看已安装包
14. conda list

复制代码

-c：是–channel的缩写，conda 用于指定包的安装来源渠道。
conda-forge：该源比官方默认渠道更新更快、包更全

建议：二者最好不好混用，推荐先 conda 装基础包，后 pip 补充的顺序。

1. # 检查包来源
2. conda list  # conda 安装的包显示频道, pip安装的显示 pypi

复制代码

2.2.4 pycharm开发环境

pycharm作为专业的Python IDE，简单易上手
三、大模型应用开发

大模型应用技术特点：门槛低，天花板高
3.1 基于RAG架构的开发

背景:
· 大模型的知识冻结
· 大模型幻觉
而RAG就可以非常准确的解决这两个问题
举例：
LLM 在考试的时候面对陌生的领域，答复能力有限，然后就准备放飞自我了。而此时 RAG 给了一些提示和思路，让 LLM 懂了开始往这个提示的方向做，最终考试的正确率从 60% 到了 90%！

何为RAG？
Retrieval-Augmented Generation（检索增强生成）

检索 - 增强 - 生成过程：检索可以理解为第 10 步，增强理解为第 12 步（这里的提示词包含检索到的数据），生成理解为第 15 步。

类似的细节图：

强调一下难点的步骤：

这些过程中的难点：1、文件解析 2、文件切割 3、知识检索 4、知识重排序
Reranker 的使用场景：
· 适合：追求回答高精度和高相关性的场景中特别适合使用 Reranker，例如专业知识库或者客服系统等应用。
· 不适合：引入 reranker 会增加召回时间，增加检索延迟。服务对响应时间要求高时，使用 reranker 可能不合适。
这里有三个位置涉及到大模型的使用：
· 第 3 步向量化时，需要使用 EmbeddingModels。
· 第 7 步重排序时，需要使用 RerankModels。
· 第 9 步生成答案时，需要使用 LLM。
3.2 基于Agent架构的开发

充分利用 LLM 的推理决策能力，通过增加规划、记忆和工具调用的能力，构造一个能够独立思考、逐步完成给定目标的智能体。
OpenAI 的元老翁丽莲 (Lilian Weng) 于 2023 年 6 月在个人博客首次提出了现代 AI Agent 架构。

一个数学公式来表示：
Agent = LLM + Memory + Tools + Planning + Action
智能体核心要素被细化为以下模块：
1、大模型（LLM）
作为 “大脑”：提供推理、规划和知识理解能力，是 AI Agent 的决策中枢。

大脑主要由一个大型语言模型 LLM 组成，承担着信息处理和决策等功能，并可以呈现推理和规划的过程，能很好地应对未知任务。

2、记忆（Memory）记忆机制能让智能体在处理重复工作时调用以前的经验，从而避免用户进行大量重复交互。

短期记忆：存储单次对话周期的上下文信息，属于临时信息存储机制。受限于模型的上下文窗口长度。

ChatGPT：支持约 8k token 的上下文>GPT4：支持约 32k token 的上下文
最新的很多大模型：都支持 100 万、1000 万 token 的上下文（相当于 2000 万字文本或 20 小时视频）
一般情况下模型中 token 和字数的换算比例大致如下：
○ 1 个英文字符 ≈ 0.3 个 token。
○ 1 个中文字符 ≈ 0.6 个 token。

长期记忆：可以横跨多个任务或时间周期，可存储并调用核心知识，非即时任务。
○ 长期记忆，可以通过模型参数微调（固化知识）、知识图谱（结构化语义网络）或向量数据库（相似性检索）方式实现。

3、工具使用（Tool Use）：
调用外部工具（如 API、数据库）扩展能力边界。

4、规划决策（Planning）：
通过任务分解、反思与自省框架实现复杂任务处理。例如，利用思维链（Chain of Thought）将目标拆解为子任务，并通过反馈优化策略。

5、行动（Action）：
实际执行决策的模块，涵盖软件接口操作（如自动订票）和物理交互（如机器人执行搬运）。比如：检索、推理、编程等。

智能体会形成完整的计划流程。例如先读取以前工作的经验和记忆，之后规划子目标并使用相应工具去处理问题，最后输出给用户并完成反思。

3.3 大模型应用开发的4个场景

3.3.1 场景 1：纯 Prompt

·Prompt 是操作大模型的唯一接口
·当人看：你说一句，ta 回一句，你再说一句，ta 再回一句…

3.3.2 场景 2：Agent + Function Calling

·Agent：AI 主动提要求
·Function Calling：需要对接外部系统时，AI 要求执行某个函数
·当人看：你问 ta「我明天去杭州出差，要带伞吗？」，ta 让你先看天气预报，你看了告诉 ta，ta 再告诉你要不要带伞

3.3.3 场景 3：RAG

场景 3：RAG (Retrieval-Augmented Generation)
RAG：需要补充领域知识时使用
·Embeddings：把文字转换为更易于相似度计算的编码。这种编码叫向量
·向量数据库：把向量存起来，方便查找
·向量搜索：根据输入向量，找到最相似的向量
举例：考试答题时，到书上找相关内容，再结合题目组成答案

这个在智能客服上用的最广泛。
3.3.4 场景 4：Fine-tuning（精调/微调）

举例：努力学习考试内容，长期记住，活学活用。

特点：成本最高；在前面的方式解决不了问题的情况下，再使用。
如何选择
面对一个需求，如何开始，如何选择技术方案？下面是个常用思路：

注意：最容易被忽略的，是准备测试数据。
四、LangChain的核心组件

学习 Langchain 最简单直接的方法就是阅读官方文档。https://python.langchain.com/v0.1/docs/modules/
通过文档目录我们可以看到，Langchain 构成的核心组件。
4.1 一个问题引发的思考

如果要组织一个 AI 应用，开发者一般需要什么？
第 1，提示词模板的构建，不仅仅只包含用户输入。
第 2，模型调用与返回，参数设置，返回内容的格式化输出。
第 3，知识库查询，这里会包含文档加载，切割，以及转化为词嵌入（Embedding）向量。
第 4，其他第三方工具调用，一般包含天气查询、Google 搜索、一些自定义的接口能力调用。
第 5，记忆获取，每一个对话都有上下文，在开启对话之前总得获取到之前的上下文吧？
4.2 核心组件的概述

LangChain 的核心组件涉及六大模块，这六大模块提供了一个全面且强大的框架，使开发者能够创建复杂、高效且用户友好的基于大模型的应用。

4.3 核心组件的说明

核心组件1：Model I/O

这个模块使⽤最多，也最简单

Model I/O：标准化各个大模型的输入和输出，包含输入模版，模型本身和格式化输出。
以下是使用语言模型从输入到输出的基本流程。

以下是对每一块的总结：
·Format(格式化) ：即指代Prompts Template，通过模板管理大模型的输入。将原始数据格式化成
模型可以处理的形式，插入到一个模板问题中，然后送入模型进行处理。
·Predict(预测) ：即指代Models，使用通用接口调用不同的大语言模型。接受被送进来的问题，然
后基于这个问题进行预测或生成回答。
·Parse(生成) ：即指代Output Parser 部分，用来从模型的推理中提取信息，并按照预先设定好的
模版来规范化输出。比如，格式化成一个结构化的JSON对象。
核心组件2：Chains

Chain：“链条”，用于将多个模块串联起来组成一个完整的流程，是 LangChain 框架中最重要的模块。
例如，一个 Chain 可能包括一个 Prompt 模板、一个语言模型和一个输出解析器，它们一起工作以处理
用户输入、生成响应并处理输出。
常见的Chain类型：
· LLMChain ：最基础的模型调用链
· SequentialChain ：多个链串联执行
· RouterChain ：自动分析用户的需求，引导到最适合的链
· RetrievalQA ：结合向量数据库进行问答的链
核心组件3：Memory

Memory：记忆模块，用于保存对话历史或上下文信息，以便在后续对话中使用。
常见的 Memory 类型：
· ConversationBufferMemory ：保存完整的对话历史
· ConversationSummaryMemory ：保存对话内容的精简摘要（适合长对话）
· ConversationSummaryBufferMemory ：混合型记忆机制，兼具上面两个类型的特点
· VectorStoreRetrieverMemory ：保存对话历史存储在向量数据库中
核心组件4：Agents

Agents，对应着智能体，是 LangChain 的高阶能力，它可以自主选择工具并规划执行步骤。
Agent 的关键组成：
· AgentType ：定义决策逻辑的工作流模式
· Tool ：是一些内置的功能模块，如API调用、搜索引擎、文本处理、数据查询等工具。Agents通过这些工具来执行特定的功能。
· AgentExecutor ：用来运行智能体并执行其决策的工具，负责协调智能体的决策和实际的工具执行。

⽬前最热⻔的智能体开发实践，未来能够真正实现通⽤⼈⼯智能的落地⽅案。
这⾥的Agent，就会涉及到前⾯讲的memory，以及tools。

核心组件5：Retrieval

Retrieval：对应着RAG，检索外部数据，然后在执行生成步骤时将其传递到 LLM。步骤包括文档加载、切割、Embedding等

· Source ：数据源，即大模型可以识别的多种类型的数据：视频、图片、文本、代码、文档等。
· Load ：负责将来自不同数据源的非结构化数据，加载为文档(Document)对象
· Transform ：负责对加载的文档进行转换和处理，比如将文本拆分为具有语义意义的小块。
· Embed ：将文本编码为向量的能力。一种用于嵌入文档，另一种用于嵌入查询
· Store ：将向量化后的数据进行存储
· Retrieve ：从大规模文本库中检索和查询相关的文本段落

绿⾊的是⼊库存储前的操作。

核心组件6：Callbacks

Callbacks：回调机制，允许连接到 LLM 应用程序的各个阶段，可以监控和分析LangChain的运行情况，比如日志记录、监控、流传输等，以优化性能。

回调函数，对于程序员们应该都不陌⽣。这个函数允许我们在LLM的各个阶段使⽤各种各样的“钩⼦”，从而达实现⽇志的记录、监控以及流式传输等功能。

4.4 小结

(1)Model I/O模块：使用最多，也最简单
(2)Chains 模块： 最重要的模块
(3)Retrieval模块、Agents模块：大模型的主要落地场景
在这个基础上，其它组件要么是它们的辅助，要么只是完成常规应用程序的任务。

辅助：⽐如，向量数据库的分块和嵌⼊，⽤于追踪、观测的Callbacks
任务：⽐如，Tools，Memory
我们要做的就是⼀个⼀个module去攻破，最后将他们融会贯通，也就成为⼀名合格的LangChain
学习者了。

5.LangChain的helloword

5.1 获取大模型

1. # 导入 dotenv 库的 load_dotenv 函数，用于加载环境变量文件（.env）中的配置import dotenv
2. from langchain_openai import ChatOpenAI
3. import os
5. dotenv.load_dotenv()# 加载当前目录下的 .env 文件
7. os.environ['OPENAI_API_KEY']= os.getenv("OPENAI_API_KEY1")
8. os.environ['OPENAI_BASE_URL']= os.getenv("OPENAI_BASE_URL")# 创建大模型实例
9. llm = ChatOpenAI(model="gpt-4o-mini")# 默认使用 gpt-3.5-turbo# 直接提供问题，并调用llm
10. response = llm.invoke("什么是大模型？")print(response)

复制代码

其中，需要在当前工程下提供
.env 文件，文件中提供如下信息：

1. OPENAI_API_KEY1="sk-cvUm8OddQbly.............AGgIHTm9kMH7Bf226G2"#你自己的密钥
2. OPENAI_BASE_URL="https://api.openai-proxy.org/v1"#url是固定值，统一写成这样

复制代码

密钥来自于：https://www.closeai-asia.com/

5.2 使用提示词模板

1. from langchain_core.prompts import ChatPromptTemplate
3. # 需要注意的一点是，这里需要指明具体的role，在这里是system和用户
4. prompt = ChatPromptTemplate.from_messages([("system","你是世界级的技术文档编写者"),("user","{input}")# {input}为变量])# 我们可以把prompt和具体llm的调用和在一起。
5. chain = prompt | llm
6. message = chain.invoke({"input":"大模型中的LangChain是什么？"})print(message)# print(type(message))

复制代码

5.3 使用输出解析器

1. from langchain_openai import ChatOpenAI
2. from langchain_core.prompts import ChatPromptTemplate
3. from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
5. # 初始化模型
6. llm = ChatOpenAI(model="gpt-4o-mini")# 创建提示模板
7. prompt = ChatPromptTemplate.from_messages([("system","你是世界级的技术文档编写者。"),("user","{input}")])# 使用输出解析器# output_parser = StrOutputParser()
8. output_parser = JsonOutputParser()# 将其添加到上一个链中# chain = prompt | llm
9. chain = prompt | llm | output_parser
11. # 调用它并提出同样的问题。答案是一个字符串，而不是ChatMessage# chain.invoke({"input": "LangChain是什么?"})
12. chain.invoke({"input":"LangChain是什么? 用JSON格式回复，问题用question，回答用answer"})

复制代码

或者

1. from langchain_openai import ChatOpenAI
2. from langchain_core.prompts import ChatPromptTemplate
3. from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
5. # 初始化模型
6. llm = ChatOpenAI(model="gpt-4o-mini")# 创建提示模板
7. prompt = ChatPromptTemplate.from_messages([("system","你是世界级的技术文档编写者。输出格式要求：{format_instructions}"),("user","{input}")])# 使用输出解析器# output_parser = StrOutputParser()
8. output_parser = JsonOutputParser()# 将其添加到上一个链中# chain = prompt | llm
9. chain = prompt | llm | output_parser
11. # 调用它并提出同样的问题。答案是一个字符串，而不是ChatMessage# chain.invoke({"input": "LangChain是什么?"})
12. chain.invoke({"input":"LangChain是什么?","format_instructions": output_parser.get_format_instructions()})

复制代码

5.4 使用向量存储

使用一个简单的本地向量存储 FAISS，首先需要安装它

1. pip install faiss-cpu
2. #或者
3. conda install faiss-cpu
5. pip installlangchain_community==0.3.7
6. #或者
7. conda installlangchain_community==0.3.7

复制代码

1. pip install faiss-cpu
2. #或者
3. conda install faiss-cpu
5. pip installlangchain_community==0.3.7
6. #或者
7. conda installlangchain_community==0.3.7

复制代码

1. # 导入和使用 WebBaseLoaderfrom langchain_community.document_loaders import WebBaseLoader
2. import bs4
4. loader = WebBaseLoader(
5.     web_path="https://www.gov.cn/xinwen/2020-06/01/content_5516649.htm",
6.     bs_kwargs=dict(parse_only=bs4.SoupStrainer(id="UCAP-CONTENT")))
7. docs = loader.load()# print(docs)# 对于嵌入模型，这里通过 API调用from langchain_openai import OpenAIEmbeddings
9. embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")from langchain_community.vectorstores import FAISS
10. from langchain_text_splitters import RecursiveCharacterTextSplitter
12. # 使用分割器分割文档
13. text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
14. documents = text_splitter.split_documents(docs)print(len(documents))# 向量存储 embeddings 会将 documents 中的每个文本片段转换为向量，并将这些向量存储在 FAISS 向量数据库中
15. vector = FAISS.from_documents(documents, embeddings)

复制代码

5.5 RAG（检索增强生成）

基于外部知识，增强大模型回复

1. from langchain_core.prompts import PromptTemplate
3. retriever = vector.as_retriever()
4. retriever.search_kwargs ={"k":3}
5. docs = retriever.invoke("建设用地使用权是什么？")# for i,doc in enumerate(docs):#  print(f"第{i+1}条规定：")#  print(doc)# 6.定义提示词模板
6. prompt_template ="""
7. 你是一个问答机器人。
8. 你的任务是根据下述给定的已知信息回答用户问题。
9. 确保你的回复完全依据下述已知信息。不要编造答案。
10. 如果下述已知信息不足以回答用户的问题，请直接回复“我无法回答您的问题”。
12. 已知信息:
13. {info}
15. 用户问:
16. {question}
18. 请用中文回答用户问题。
19. """# 7.得到提示词模板对象
20. template = PromptTemplate.from_template(prompt_template)# 8.得到提示词对象
21. prompt = template.format(info=docs, question="建设用地使用权是什么？")# 9. 调用LLM
22. response = llm.invoke(prompt)print(response.content)

复制代码

5.6 使用Agent

1. from langchain.tools.retriever import create_retriever_tool
3. # 检索器工具
4. retriever_tool = create_retriever_tool(
5.     retriever,"CivilCodeRetriever","搜索有关中华人民共和国民法典的信息。关于中华人民共和国民法典的任何问题，您必须使用此工具",)
7. tools =[retriever_tool]from langchain import hub
8. from langchain.agents import create_openai_functions_agent
9. from langchain.agents import AgentExecutor
11. # https://smith.langchain.com/hub
12. prompt = hub.pull("hwchase17/openai-functions-agent")
13. agent = create_openai_functions_agent(llm, tools, prompt)
14. agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)# 运行代理
15. agent_executor.invoke({"input":"建设用地使用权是什么"})

复制代码

总结

学习笔记

原文地址：https://blog.csdn.net/weixin_43665177/article/details/155453114