动手学大模型应用开发，第2天：调用大模型

Prompt 最初是 NLP（自然语言处理）研究者为下游任务设计出来的一种任务专属的输入模板，类似于一种任务（例如：分类，聚类等）会对应一种 Prompt。在 ChatGPT 推出并获得大量应用之后，Prompt 开始被推广为给大模型的所有输入。即，我们每一次访问大模型的输入为一个 Prompt，而大模型给我们的返回结果则被称为 Completion。

AAI机器之心

942人浏览 · 2025-02-27 11:56:10

AAI机器之心 · 2025-02-27 11:56:10 发布

一、基本概念

1. Prompt

例如，在下面示例中，我们给 ChatGPT 的提问 “NLP 中的 Prompt 指什么”是我们的提问，其实也就是我们此次的 Prompt；而 ChatGPT 的返回结果就是此次的 Completion。也就是对于 ChatGPT 模型，该 Prompt 对应的 Completion 是下图的展示。

ChatGPT Prompt Examples

后续我们都将会使用 Prompt 替代给 LLM 的输入，使用 Completion 替代 LLM 的输出。同时，我们会结合具体案例，介绍如何设计 Prompt 能够充分发挥 LLM 的能力。

2. Temperature

LLM 生成是具有随机性的，在模型的顶层通过选取不同预测概率的预测结果来生成最后的结果。我们一般可以通过控制 Temperature 参数来控制 LLM 生成结果的随机性与创造性。

Temperature 一般取值在 0~1 之间，当取值较低接近0时，预测的随机性会较低，产生更保守、可预测的文本，不太可能生成意想不到或不寻常的词。当取值较高接近1时，预测的随机性会较高，所有词被选择的可能性更大，会产生更有创意、多样化的文本，更有可能生成不寻常或意想不到的词。

例如，当我们使用 ChatGPT 要求其为我们想一个关于跨语言模型的硕士毕业论文选题，当我们将 Temperature 设置为0时，模型回复为：

    `题目：基于跨语言模型的机器翻译性能优化研究          摘要：随着全球化的发展，跨语言交流的需求日益增长。机器翻译作为一种自动化翻译技术，为跨语言交流提供了便利。然而，由于语言之间的差异性，机器翻译系统在不同语言对之间的性能存在差异。本论文旨在通过研究跨语言模型，探索如何优化机器翻译的性能，提高翻译质量和准确性。          关键词：跨语言模型，机器翻译，性能优化，翻译质量，准确性          1. 引言       1.1 研究背景和意义       1.2 国内外研究现状       1.3 研究目标和内容          2. 跨语言模型的原理和方法       2.1 传统机器翻译方法       2.2 跨语言模型的基本原理       2.3 跨语言模型的常用方法和技术          3. 跨语言模型在机器翻译中的应用       3.1 跨语言模型在机器翻译中的优势和挑战       3.2 跨语言模型在不同语言对上的性能表现比较       3.3 跨语言模型在特定领域机器翻译中的应用案例分析          4. 跨语言模型的性能优化方法       4.1 数据预处理和特征选择       4.2 模型参数调优和训练策略       4.3 跨语言模型与其他技术的结合应用          5. 实验设计与结果分析       5.1 实验设计和数据集介绍       5.2 实验结果分析和对比       5.3 实验结果的可行性和可靠性验证          6. 结论与展望       6.1 研究工作总结       6.2 存在的问题和不足       6.3 进一步研究方向和展望          参考文献          注：以上仅为一个选题示例，具体选题应根据个人兴趣和研究背景进行调整和修改。`

当我们将 Temperature 设置为1时，模型回复为：

    `以下是关于跨语言模型的几个硕士毕业论文选题建议：          1. 跨语言文本分类模型的比较和优化——通过比较不同跨语言模型的性能，分析其在不同语言之间的适应性和准确性，并尝试优化现有模型，提高跨语言文本分类的效果。          2. 基于跨语言模型的机器翻译性能分析——通过比较不同跨语言模型在机器翻译任务中的表现，研究不同语言之间的短板和优势，并探讨如何针对性地改进跨语言机器翻译的性能。          3. 跨语言情感分析模型的构建与应用——使用跨语言模型构建情感分析模型，通过比较模型在不同语言上的准确性和一致性，分析不同语言中情感表达的差异，并探索在多语言场景下的情感分析应用。          4. 多任务学习下的跨语言模型训练——探索多任务学习下跨语言模型的训练方法和效果，通过同时训练多个任务来提高跨语言模型的泛化能力和性能，并验证多任务学习对跨语言模型的影响。          5. 跨语言问答系统的构建与评估——构建跨语言问答系统，通过跨语言模型实现问题的自动解析和答案的生成，并评估系统在多语言环境下的效果和可用性。          6. 基于预训练的跨语言模型的应用于语音识别——将预训练的跨语言模型应用于语音识别任务中，研究其对语音识别准确性和多语种适应性的影响，并比较不同模型对多语种语音数据的处理能力。          选择适合自己兴趣和研究方向的选题，并与导师进行深入讨论和确认。`

对于不同的问题与应用场景，我们可能需要设置不同的 Temperature。例如，在本教程搭建的个人知识库助手项目中，我们一般将 Temperature 设置为0，从而保证助手对知识库内容的稳定使用，规避错误内容、模型幻觉；在产品智能客服、科研论文写作等场景中，我们同样更需要稳定性而不是创造性；但在个性化 AI、创意营销文案生成等场景中，我们就更需要创意性，从而更倾向于将 Temperature 设置为较高的值。

3. System Prompt

System Prompt 是随着 ChatGPT API 开放并逐步得到大量使用的一个新兴概念，事实上，它并不在大模型本身训练中得到体现，而是大模型服务方为提升用户体验所设置的一种策略。

具体来说，在使用 ChatGPT API 时，你可以设置两种 Prompt：一种是 System Prompt，该种 Prompt 内容会在整个会话过程中持久地影响模型的回复，且相比于普通 Prompt 具有更高的重要性；另一种是 User Prompt，这更偏向于咱们平时的 Prompt，即需要模型做出回复的输入。

我们一般设置 System Prompt 来对模型进行一些初始化设定，例如，我们可以在 System Prompt 中给模型设定我们希望它具备的人设如一个个人知识库助手等。System Prompt 一般在一个会话中仅有一个。在通过 System Prompt 设定好模型的人设或是初始设置后，我们可以通过 User Prompt 给出模型需要遵循的指令。例如，当我们需要一个幽默风趣的个人知识库助手，并向这个助手提问我今天有什么事时，可以如下地构造 Prompt：

    `{           "system prompt":"你是一个幽默风趣的个人知识库助手，可以根据给定的知识库内容回答用户的提问，注意，你的回答风格应是幽默风趣的",           "user prompt":"我今天有什么事务？"       }`

通过如上 Prompt 的构造，我们可以让模型以幽默风趣的风格回答用户提出的问题。注意，如果有多个用户问题，那么我们只需要添加对应数量的 User Prompt 即可，System Prompt 仅需构造一个。

二、调用 ChatGPT

1. ChatGPT

ChatGPT，发布于2022年11月，是目前火热出圈的大语言模型（Large Language Model，LLM）的代表产品。在2022年底，也正是 ChatGPT 的惊人表现引发了 LLM 的热潮。时至目前，由 OpenAI 发布的 ChatGPT-4 仍然是 LLM 性能上限的代表，ChatGPT 也仍然是目前使用人数最多、使用热度最大、最具发展潜力的 LLM 产品。事实上，在圈外人看来，ChatGPT 即是 LLM 的代称。

OpenAI 除发布了免费的 Web 端产品外，也提供了多种 ChatGPT API，支持开发者通过 Python 或 Request 请求来调用 ChatGPT，向自己的服务中嵌入 LLM 的强大能力。可选择的主要模型包括 ChatGPT-3.5 和 ChatGPT-4，但每个模型也存在多个上下文版本，例如 ChatGPT-3.5 就有最原始的 4K 上下文长度的模型，也有 16K 上下文长度的模型 gpt-turbo-16k-0613。

在本章节，我们将主要讲述两种通过 Python 代码调用 ChatGPT API 的方法：直接调用 OpenAI 的原生接口，或是基于 LangChain 调用 ChatGPT API。

这份 LLM大模型资料 包括LLM大模型书籍、640套大模型行业报告、LLM大模型学习视频、LLM大模型学习路线、开源大模型学习教程等, 😝有需要的小伙伴，可以 扫描下方二维码领取🆓↓↓↓

👉CSDN大礼包🎁：全网最全《LLM大模型入门+进阶学习资源包》免费分享（安全链接，放心点击）👈

2. 获取并配置 OpenAI API Key

OpenAI API 服务是付费的，每一个开发者都需要首先获取并配置 OpenAI API Key，才能在自己构建的应用中访问 ChatGPT。我们将在这部分简述如何获取并配置 OpenAI API Key。

在获取OpenAI API key之前我们需要openai官网中注册一个账号。这里假设我们已经有了openai账号，先在openai官网登录，登录后如下图所示：

我们选择API，然后点击右上角的头像，选择View API keys，如下图所示：

点击Create new secret key按钮创建OpenAI API key，我们将创建好的OpenAI API key复制以此形式OPENAI_API_KEY="sk-..."保存到.env文件中，并将.env文件保存在项目根目录下。

下面是读取.env文件的代码

import os   import openai   from dotenv import load_dotenv, find_dotenv      # 读取本地/项目的环境变量。      # find_dotenv()寻找并定位.env文件的路径   # load_dotenv()读取该.env文件，并将其中的环境变量加载到当前的运行环境中     # 如果你设置的是全局的环境变量，这行代码则没有任何作用。   _ = load_dotenv(find_dotenv())      # 如果你需要通过代理端口访问，你需要如下配置   os.environ['HTTPS_PROXY'] = 'http://127.0.0.1:7890'   os.environ["HTTP_PROXY"] = 'http://127.0.0.1:7890'      # 获取环境变量 OPENAI_API_KEY   openai.api_key = os.environ['OPENAI_API_KEY']

3. 调用 OpenAI 原生接口

调用 ChatGPT 需要使用 ChatCompletion API，该 API 提供了 ChatGPT 系列模型的调用，包括 ChatGPT-3.5，ChatGPT-4 等。

ChatCompletion API 调用方法如下：

import openai   # 导入所需库   # 注意，此处我们假设你已根据上文配置了 OpenAI API Key，如没有将访问失败   completion = openai.ChatCompletion.create(       # 创建一个 ChatCompletion       # 调用模型：ChatGPT-3.5       model="gpt-3.5-turbo",       # message 是你的 prompt       messages=[           {"role": "system", "content": "You are a helpful assistant."},           {"role": "user", "content": "Hello!"}       ]   )

调用该 API 会返回一个 ChatCompletion 对象，其中包括了回答文本、创建时间、ID等属性。我们一般需要的是回答文本，也就是回答对象中的 content 信息。

completion

<OpenAIObject chat.completion id=chatcmpl-80QUFny7lXqOcfu5CZMRYhgXqUCv0 at 0x7f1fbc0bd770> JSON: {     "choices": [       {         "finish_reason": "stop",         "index": 0,         "message": {           "content": "Hello! How can I assist you today?",           "role": "assistant"         }       }     ],     "created": 1695112507,     "id": "chatcmpl-80QUFny7lXqOcfu5CZMRYhgXqUCv0",     "model": "gpt-3.5-turbo-0613",     "object": "chat.completion",     "usage": {       "completion_tokens": 9,       "prompt_tokens": 19,       "total_tokens": 28     }   }

print(completion["choices"][0]["message"]["content"])

Hello! How can I assist you today?

此处我们详细介绍调用 API 常会用到的几个参数：

model，即调用的模型，一般取值包括“gpt-3.5-turbo”（ChatGPT-3.5）、“gpt-3.5-16k-0613”（ChatGPT-3.5 16K 版本）、“gpt-4”（ChatGPT-4）。注意，不同模型的成本是不一样的。
message，即我们的 prompt。ChatCompletion 的 message 需要传入一个列表，列表中包括多个不同角色的 prompt。我们可以选择的角色一般包括 system：即前文中提到的 system prompt；user：用户输入的 prompt；assitance：助手，一般是模型历史回复，作为给模型参考的示例。
temperature，温度。即前文中提到的 Temperature 系数。
max_tokens，最大 token 数，即模型输出的最大 token 数。OpenAI 计算 token 数是合并计算 Prompt 和 Completion 的总 token 数，要求总 token 数不能超过模型上限（如默认模型 token 上限为 4096）。因此，如果输入的 prompt 较长，需要设置较小的 max_token 值，否则会报错超出限制长度。

OpenAI 提供了充分的自定义空间，支持我们通过自定义 prompt 来提升模型效果，但我们一般不需要使用到 system prompt 与 assistance prompt，因此我们会给出如下一个函数，对 OpenAI API 做了一定封装，支持我们直接传入 Prompt 并获得模型的输出：

#一个封装 OpenAI 接口的函数，参数为 Prompt，返回对应结果   def get_completion(prompt, model="gpt-3.5-turbo", temperature = 0):       '''       prompt: 对应的提示词       model: 调用的模型，默认为 gpt-3.5-turbo(ChatGPT)，有内测资格的用户可以选择 gpt-4       '''       messages = [{"role": "user", "content": prompt}]       response = openai.ChatCompletion.create(           model=model,           messages=messages,           temperature=temperature, # 模型输出的温度系数，控制输出的随机程度       )       # 调用 OpenAI 的 ChatCompletion 接口       return response.choices[0].message["content"]

在上述函数中，我们封装了 messages 的细节，仅使用 user prompt 来实现调用。事实上，在简单场景中，该函数完全足够使用。我们后续将该函数封装在项目 /project/llm/call_llm.py 文件中，支持以相同方式访问不同底层模型，具体代码逻辑同此处。

4. 基于 LangChain 调用 ChatGPT

LangChain 提供了对于多种大模型的封装，基于 LangChain 的接口可以便捷地调用 ChatGPT 并将其集合在以 LangChain 为基础框架搭建的个人应用中。我们在此简述如何使用 LangChain 接口来调用 ChatGPT。

注意，基于 LangChain 接口调用 ChatGPT 同样需要配置你的个人密钥，配置方法同上。

从langchain.chat_models导入OpenAI的对话模型ChatOpenAI。除去OpenAI以外，langchain.chat_models还集成了其他对话模型，更多细节可以查看Langchain官方文档。

from langchain.chat_models import ChatOpenAI

接下来你需要实例化一个 ChatOpenAI 类，可以在实例化时传入超参数来控制回答，例如 temperature 参数。

# 这里我们将参数temperature设置为0.0，从而减少生成答案的随机性。   # 如果你想要每次得到不一样的有新意的答案，可以尝试调整该参数。   chat = ChatOpenAI(temperature=0.0)   chat

ChatOpenAI(cache=None, verbose=False, callbacks=None, callback_manager=None, tags=None, metadata=None, client=<class 'openai.api_resources.chat_completion.ChatCompletion'>, model_name='gpt-3.5-turbo', temperature=0.0, model_kwargs={}, openai_api_key='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', openai_api_base='', openai_organization='', openai_proxy='', request_timeout=None, max_retries=6, streaming=False, n=1, max_tokens=None, tiktoken_model_name=None)

可以看到，默认调用的是 ChatGPT-3.5 模型。

几种常用的超参数设置包括：

model_name：所要使用的模型，默认为 ‘gpt-3.5-turbo’，参数设置与 OpenAI 原生接口参数设置一致。
temperature：温度系数，取值同原生接口。
openai_api_key：OpenAI API key，如果不使用环境变量设置 API Key，也可以在实例化时设置。
openai_proxy：设置代理，如果不使用环境变量设置代理，也可以在实例化时设置。
streaming：是否使用流式传输，即逐字输出模型回答，默认为 False，此处不赘述。
max_tokens：模型输出的最大 token 数，意义及取值同上。

为了便于开发者使用，LangChain 设置了 Template 来设置 Prompt。Template，即模板，是 LangChain 设置好的一种 Prompt 格式，开发者可以直接调用 Template 向里面填充个性化任务，来便捷地完成个性化任务的 Prompt 设置。Template 实则是一个包括 Python 字符串范式的字符，可以使用 format 方法进行填充。

我们需要先构造一个个性化 Template：

from langchain.prompts import ChatPromptTemplate      # 这里我们要求模型对给定文本进行中文翻译   template_string = """Translate the text \   that is delimited by triple backticks \   into a Chinese. \   text: ```{text}```"""      # 接着将 Template 实例化      chat_template = ChatPromptTemplate.from_template(template_string)

此处我们设置了一个用于文本翻译的 Template，这样的写法是一种定式，可以较大程度发挥模型性能。在之后我们会详细介绍设计 Prompt 的原则与技巧。

在上文 Template 中，我们设置了一个变量 text，作为用户的输入即需要进行中文翻译的给定文本。在每一次调用中，我们可以改变 text 的值，从而自动化实现任务部署和分发。

在完成 Template 后，我们需要针对模型调用 format 方法，将 template 转化为模型输入的形式。例如，在调用 ChatGPT 时，我们实则是要将 Template 转化为上文实现过的 message 格式。

# 我们首先设置变量值      text = "Today is a nice day."      # 接着调用 format_messages 将 template 转化为 message 格式      message = chat_template.format_messages(text=text)   print(message)

[HumanMessage(content='Translate the text that is delimited by triple backticks into a Chinses. text: ```Today is a nice day.```\n', additional_kwargs={}, example=False)]

可以看到，转化之后是 LangChain 设定好的一种专用于调用类似于 ChatGPT 的模型格式的数据类型。接着，我们可以使用实例化的类型直接传入我们设定好的 prompt：

response = chat(message)   response

AIMessage(content='今天是个好天气。', additional_kwargs={}, example=False)

可以看到，返回值的 content 属性即为模型的返回文本。

三、调用百度文心

1. 文心一言

文心一言，由百度于2023年3月27日推出的中文大模型，是目前国内大语言模型的代表产品。受限于中文语料质量差异及国内计算资源、计算技术瓶颈，文心一言在整体性能上距离 ChatGPT 仍有一定差异，但在中文语境下已展现出了较为优越的性能。文心一言所考虑的落地场景包括多模态生成、文学创作等多种商业场景，其目标是在中文语境下赶超 ChatGPT。当然，要真正战胜 ChatGPT，百度还有很长的路要走；但在生成式 AI 监管较为严格的国内，作为第一批被允许向公众开放的生成式 AI 应用，文心一言相对无法被公开使用的 ChatGPT 还是具备一定商业上的优势。

百度同样提供了文心一言的 API 接口，其于推出大模型的同时推出了文心千帆企业级大语言模型服务平台，包括了百度整套大语言模型开发工作链。对于不具备大模型实际落地能力的中小企业或传统企业，考虑文心千帆是一个可行的选择。当然，本教程仅包括通过文心千帆平台调用文心一言 API，对于其他企业级服务不予讨论。不过，值得额外注意的事，国内大模型厂商对于 API 的服务相对疏忽，文心一言 API 的实际性能与其 Web 应用所展现出来的能力还存在一定差异。

在本章节中，我们同样将讲述两种通过 Python 代码调用百度文心一言大模型的方法：直接调用百度文心原生接口；使用 LangChain 调用百度文心接口。

2. 获取文心一言调用秘钥

同样，要调用文心一言 API，需要先获取文心一言调用秘钥，在代码中需要配置自己的秘钥才能实现对模型的调用。

百度文心有两层秘钥认证，第一层是拥有调用权限的账户可以从账户中获取的 API_Key 和 Secret_Key，每一个账户可以创建若干个应用，每个应用会对应一个 API_Key 和 Secret_Key。

在获取完成 API_Key 和 Secret_Key 后，还需要基于这两个 Key 去获取 access_token 值。access_token 是第二层认证，基于 access_token 即可调用百度文心大模型，而 access_token 是可以控制基于时间或流量过期的。通过上述两层秘钥认证，可以进一步提高企业服务的安全性。

当然，在本教程中，我们并不需要将两层秘钥分离。我们将在该部分简述如何获取 API_Key、Secret_Key 以及如何基于 Key 获取 access_token 值，后续我们将直接通过 access_token 来调用文心大模型。

首先我们需要进入文心千帆服务平台，点击上述应用接入按钮，创建一个调用文心大模型的应用。注意，你需要首先有一个经过实名认证的百度账号。

接着点击“去创建”按钮，进入应用创建界面：

简单输入基本信息，选择默认配置，创建应用即可。

创建完成后，我们可以在控制台看到创建的应用的 AppID、API Key、Secret Key。使用这里的 API Key 和 Secret Key 即可进行 access_token 的获取。

access_token 需要通过代码 post 访问指定网址得到：

import requests   import json      def get_access_token():       """       使用 API Key，Secret Key 获取access_token，替换下列示例中的应用API Key、应用Secret Key       """       # 指定网址       url = "https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id={api_key}&client_secret={secret_key}"       # 设置 POST 访问       payload = json.dumps("")       headers = {           'Content-Type': 'application/json',           'Accept': 'application/json'       }       # 通过 POST 访问获取账户对应的 access_token       response = requests.request("POST", url, headers=headers, data=payload)       return response.json().get("access_token")

通过上述代码，即可获取到账户对应的 access_token，后续使用 access_token 即可调用百度文心大模型。

3. 调用百度文心原生接口

在完成 access_token 的获取后，可以同样通过 POST 访问来调用百度文心原生接口：

def get_wenxin(prompt):       # 调用接口       url = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/eb-instant?access_token={access_token}"       # 配置 POST 参数       payload = json.dumps({           "messages": [               {                   "role": "user",# user prompt                   "content": "{}".format(prompt)# 输入的 prompt               }           ]       })       headers = {           'Content-Type': 'application/json'       }       # 发起请求       response = requests.request("POST", url, headers=headers, data=payload)       # 返回的是一个 Json 字符串       js = json.loads(response.text)       print(js["result"])

百度文心的 Prompt 格式同 OpenAI 的 Prompt 格式相似，但文心并没有提供 system prompt 级别的配置，仅支持 user、assistant 两个级别，可以在传入参数的 message 中配置。我们此处仅使用 user prompt 来实现调用。

同时，百度文心返回的数据也是一个 Json 字符串，我们可以调用其中的 result 属性来获取返回数据。

get_wenxin("你好")

您好！我是百度研发的知识增强大语言模型，中文名是文心一言，英文名是ERNIE Bot。我能够与人对话互动，回答问题，协助创作，高效便捷地帮助人们获取信息、知识和灵感。

百度千帆提供了多种模型接口供调用，此处我们主要使用 ERNIE-Bot-turbo 模型的 chat 接口，也就是常说的百度文心大模型。此处简要介绍文心大模型接口的常用参数：

· messages，即调用的 Prompt。文心的 messages 配置与 ChatGPT 有一定区别，其不支持 max_token 参数，由模型自行控制最大 token 数，content 总长度不能超过11200字符，否则模型就会自行对前文依次遗忘。文心的 messages 有以下几点要求：① 一个成员为单轮对话，多个成员为多轮对话；② 最后一个 message 为当前对话，前面的 message 为历史对话；③ 必须为奇数个对象，message 中的 role 必须依次是 user、assistant。      · stream，是否使用流式传输。      · temperature：温度系数，默认0.95，文心的 temperature 参数要求范围在0~1之间，不能设置为0。

我们同样封装一个调用百度文心大模型的函数供之后使用：

# 一个封装 Wenxin 接口的函数，参数为 Prompt，返回对应结果   def get_completion_weixin(prompt, temperature = 0.1, access_token = ""):       '''       prompt: 对应的提示词       temperature：温度系数       access_token：已获取到的秘钥       '''       url = f"https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/eb-instant?access_token={access_token}"       # 配置 POST 参数       payload = json.dumps({           "messages": [               {                   "role": "user",# user prompt                   "content": "{}".format(prompt)# 输入的 prompt               }           ],           "temperature" : temperature       })       headers = {           'Content-Type': 'application/json'       }       # 发起请求       response = requests.request("POST", url, headers=headers, data=payload)       # 返回的是一个 Json 字符串       js = json.loads(response.text)       # print(js)       return js["result"]

prompt = "你好"   access_token = "xxx"   get_completion_weixin(prompt, access_token=access_token)

'您好！我是百度研发的知识增强大语言模型，中文名是文心一言，英文名是ERNIE Bot。我能够与人对话互动，回答问题，协助创作，高效便捷地帮助人们获取信息、知识和灵感。'

4. 使用 LangChain 调用百度文心

我们同样可以通过 LangChain 框架来调用百度文心大模型，以将文心模型接入到我们的应用框架中。

但是，原生的 LangChain 是不支持文心调用的，我们需要自定义一个支持文心模型调用的 LLM。在《附一 LangChain自定义LLM》中，我们简述了如何自定义 LLM。

此处，我们可以直接调用已自定义好的 Wenxin_LLM。

from wenxin_llm import Wenxin_LLM

我们希望像调用 ChatGPT 那样直接将秘钥存储在 .env 文件中，并将其加载到环境变量，从而隐藏秘钥的具体细节，保证安全性。因此，我们需要在 .env 文件中配置 wenxin_api_key 和 wenxin_secret_key，并使用以下代码加载：

from dotenv import find_dotenv, load_dotenv   import os      # 读取本地/项目的环境变量。      # find_dotenv()寻找并定位.env文件的路径   # load_dotenv()读取该.env文件，并将其中的环境变量加载到当前的运行环境中   # 如果你设置的是全局的环境变量，这行代码则没有任何作用。   _ = load_dotenv(find_dotenv())      # 获取环境变量 OPENAI_API_KEY   wenxin_api_key = os.environ["wenxin_api_key"]   wenxin_secret_key = os.environ["wenxin_secret_key"]      <!---->      llm = Wenxin_LLM(api_key=wenxin_api_key, secret_key=wenxin_secret_key)

llm("你好")

'您好！我是百度研发的知识增强大语言模型，中文名是文心一言，英文名是ERNIE Bot。我能够与人对话互动，回答问题，协助创作，高效便捷地帮助人们获取信息、知识和灵感。'

从而我们可以将文心大模型加入到 LangChain 架构中，实现在应用中对文心大模型的调用。

四、调用讯飞星火

1. 讯飞星火认知大模型

讯飞星火认知大模型，由科大讯飞于2023年5月推出的中文大模型，也是国内大模型的代表产品之一。同样，受限于中文语境与算力资源，星火在使用体验上与 ChatGPT 还存在差异，但是，作为与文心不分伯仲的国内中文大模型，仍然值得期待与尝试。相较于存在显著资源、技术优势的百度，科大讯飞想要杀出重围，成为国内大模型的佼佼者，需要充分利用相对优势，至少目前来看，星火并未掉队。同时，不知道是否因为讯飞 API 还没有全面开放，讯飞 API 的测试使用效果比文心更好，值得期待。

目前，讯飞星火大模型 API 已进入 ββ 测试阶段，每一个讯飞账户都可以申请若干 token 的试用。但是，相对于文心与 GPT 几乎完全一致的 API 调用方式，星火 API 需要使用 WebSocket 来进行调用，对企业友好，但对初学者、新手开发者来说调用难度较大。本章节将指导开发者如何将星火 API 封装为可直接通过 request 调用的 API 接口从而和其他大模型保持一致，也将介绍如何将其封装成个性化 LLM 嵌入 LangChain 使用。

2. 申请调用权限

相对于文心复杂的申请流程，讯飞的权限申请显得简单易操作得多：

我们可以使用 Datawhale 提供的专属链接，通过该链接进入可以获得更多的免费额度，点击“免费试用”：

如果是没有领取过免费试用包的用户，可以领取到 100000 token 的试用量；如果已领取过，就会自动跳转到下方购买产品的页面。完成领取后，点击上文中的“服务管理”即可进入控制台：

在该界面，我们就可以看到我们获取到的 APPID、APISecret 和 APIKey 了。

3. 调用原生星火 API

星火 API 需要通过 WebSocket 进行连接，相对来说配置较为复杂，讯飞给出了配置示例 SparkApi.py 和连接示例 test.py，此处我们仅讲解 test.py 里的调用逻辑，配置示例代码直接使用即可。

注意，需要在环境中安装配置示例中的所需第三方库。

首先我们需要配置秘钥信息：

import SparkApi   #以下密钥信息从控制台获取   appid = ""     #填写控制台中获取的 APPID 信息   api_secret = ""   #填写控制台中获取的 APISecret 信息   api_key =""    #填写控制台中获取的 APIKey 信息      #用于配置大模型版本，默认“general/generalv2”   domain = "general"   # v1.5版本   # domain = "generalv2"    # v2.0版本      #云端环境的服务地址   Spark_url = "ws://spark-api.xf-yun.com/v1.1/chat"  # v1.5环境的地址   # Spark_url = "ws://spark-api.xf-yun.com/v2.1/chat"  # v2.0环境的地址

星火的调用传参和文心类似，也需要传入一个列表，列表中包括 role 和 prompt，我们首先定义一个从用户输入 prompt 生成传入参数的函数：

def getText(role, content, text = []):       # role 是指定角色，content 是 prompt 内容       jsoncon = {}       jsoncon["role"] = role       jsoncon["content"] = content       text.append(jsoncon)       return text

接着，我们将一个用户输入 prompt 封装为这样一个传入参数列表：

question = getText("user", "你好")   question

[{'role': 'user', 'content': '你好'}]

然后再调用 SparkApi.py 中封装的 main 函数即可：

response = SparkApi.main(appid,api_key,api_secret,Spark_url,domain,question)   response

你好！很高兴为您提供帮助。请问有什么问题我可以帮您解答吗？

4. 统一 API 调用方式

由于星火使用了 WebSocket 连接，不能直接使用 request 来进行访问，同其他大模型 API 访问方式具有一定差异。我们可以通过 FastAPI 将星火 API 封装成本地 API，从而实现统一的模型调用方式。我们在《附2 将大模型 API 封装成本地 API》中讲解了如何实现本地 API 的封装，此处仅讲解如何启动并调用本地 API。

在我们完成本地 API 的封装后（spark_api.py），我们可以通过 uvicorn 命令启动：

! uvicorn spark_api:app

启动之后，默认会在本地 8000 端口开启 API 服务。

启动 API 之后，我们可以向本地 8000 端口发起 Request 请求来访问 API：

import requests      api_url = "http://127.0.0.1:8000/spark"   headers = {"Content-Type": "application/json"}   data = {       "prompt" : "你好",       "temperature" : 0.2,       "max_tokens" : 3096}      response = requests.post(api_url, headers=headers, json=data)   response.text

'"你好！有什么我可以帮助你的吗？"'

同样，我们可以用一个函数来封装 requests 访问的细节：

def get_completion_spark(prompt, temperature = 0.1, max_tokens = 4096):          api_url = "http://127.0.0.1:8000/spark"       headers = {"Content-Type": "application/json"}       data = {           "prompt" : prompt,           "temperature" : temperature,           "max_tokens" : max_tokens}          response = requests.post(api_url, headers=headers, json=data)       return response.text

get_completion_spark("你好")

'"你好！有什么我可以帮助你的吗？"'

星火 API 同样可以制作成自定义 LLM 并接入 LangChain，制作方式同文心大模型，此处就不再赘述，如有需要可查看项目代码/project/llm/spark_llm。

五、调用智谱 AI

1. ChatGLM 大模型

智谱 AI 是由清华大学计算机系技术成果转化而来的公司，致力于打造新一代认知智能通用模型。公司合作研发了双语千亿级超大规模预训练模型 GLM-130B，并构建了高精度通用知识图谱，形成数据与知识双轮驱动的认知引擎，基于此模型打造了 ChatGLM（chatglm.cn）。

ChatGLM 系列模型，包括 ChatGLM-130B 和 ChatGLM-6B 模型，支持相对复杂的自然语言指令，并且能够解决困难的推理类问题。其中，ChatGLM-6B 模型吸引了全球超过 160 万人下载安装，该模型在 Hugging Face (HF) 全球大模型下载榜中连续 12 天位居第一名，在国内外的开源社区中产生了较大的影响。

本章节将指导开发者如何将智谱 AI API 的使用方式，也将介绍如何将其封装成个性化 LLM 嵌入 LangChain 使用。

2. 申请调用权限

首先进入到智谱AI开放平台，点击“开始使用”或者“开发者工具台”进行注册：

如果是没有领取过免费试用包的用户，可以领取到 18 元的 token 的试用量；如下图右边绿色框所示。智谱 AI 提供了三种不同的模型 API，ChatGLM-Pro, ChatGLM-Std, ChatGLM-Lite 三种不同的模型分别适用于不同的场景，可以点击蓝色框中的立即体验直接体验。对于需要使用 API key 来搭建应用的话，需要点击右边红框中的查看 API key，就会进入到我们个人的 API 管理列表中。

在该界面，我们就可以看到我们获取到的 API 所对应的应用名字和 API key 了。

我们可以点击 添加新的 API key 并输入对应的名字即可生成新的 API key。

3. 调用智谱 AI API

智谱 AI 提供了 SDK 和原生 HTTP 来实现模型 API 的调用，建议使用 SDK 进行调用以获得更好的编程体验。

注意，需要在环境中安装配置示例中的所需第三方库。

首先我们需要配置秘钥信息：

!pip install zhipuai

import zhipuai   zhipuai.api_key = "your api key" #填写控制台中获取的 APIKey 信息      model = "chatglm_std" #用于配置大模型版本

智谱的调用传参和其他类似，也需要传入一个列表，列表中包括 role 和 prompt，我们首先定义一个从用户输入 prompt 生成传入参数的函数：

def getText(role, content, text = []):       # role 是指定角色，content 是 prompt 内容       jsoncon = {}       jsoncon["role"] = role       jsoncon["content"] = content       text.append(jsoncon)       return text

接着，我们将一个用户输入 prompt 封装为这样一个传入参数列表：

question = getText("user", "你好")   question

[{'role': 'user', 'content': '你好'}]

然后再调用 zhipuai SDK 中封装的 invoke 函数即可：

# 请求模型   response = zhipuai.model_api.invoke(       model=model,       prompt=question   )   print(response)

{'code': 200, 'msg': '操作成功', 'data': {'request_id': '8023318729410566227', 'task_id': '8023318729410566227', 'task_status': 'SUCCESS', 'choices': [{'role': 'assistant', 'content': '" 你好👋！我是人工智能助手 智谱清言，可以叫我小智🤖，很高兴见到你，欢迎问我任何问题。"'}], 'usage': {'prompt_tokens': 2, 'completion_tokens': 28, 'total_tokens': 30}}, 'success': True}

这里对传入 zhipuai 的参数进行简单介绍：

prompt (list): 调用对话模型时，将当前对话信息列表作为提示输入给模型; 按照 {“role”: “user”, “content”: “你好”} 的键值对形式进行传参; 总长度超过模型最长输入限制后会自动截断，需按时间由旧到新排序。
temperature (float): 采样温度，控制输出的随机性，必须为正数。取值范围是：(0.0,1.0]，不能等于 0，默认值为 0.95。值越大，会使输出更随机，更具创造性；值越小，输出会更加稳定或确定。
top_p (float): 用温度取样的另一种方法，称为核取样。取值范围是：(0.0, 1.0) ，开区间，不能等于 0 或 1，默认值为 0.7。模型考虑具有 top_p 概率质量 tokens 的结果。例如：0.1 意味着模型解码器只考虑从前 10% 的概率的候选集中取 tokens。
request_id (string): 由用户端传参，需保证唯一性；用于区分每次请求的唯一标识，用户端不传时平台会默认生成
return_type (string): 用于控制每次返回内容的类型，空或者没有此字段时默认按照 json_string 返回。json_string 返回标准的 JSON 字符串。text 返回原始的文本内容
建议您根据应用场景调整 top_p 或 temperature 参数，但不要同时调整两个参数

4. 使用 LangChain 调用智谱 AI

我们同样可以通过 LangChain 框架来调用智谱 AI 大模型，以将其接入到我们的应用框架中。

同文心大模型类似，原生的 LangChain 是不支持智谱 AI 调用的，我们需要自定义一个 LLM。

此处，我们可以直接调用已自定义好的 ZhipuAILLM

from zhipuai_llm import ZhipuAILLM

zhipuai_model = ZhipuAILLM(model="chatglm_std", temperature=0, zhipuai_api_key=zhipuai.api_key)

zhipuai_model.generate(['你好'])

LLMResult(generations=[[Generation(text='" 你好👋！我是人工智能助手 智谱清言，可以叫我小智🤖，很高兴见到你，欢迎问我任何问题。"', generation_info=None)]], llm_output=None, run=[RunInfo(run_id=UUID('36840571-ce83-4bcb-8095-a222d59f32a4'))])

六、调用智谱 AI 生成 embedding

1. 调用智谱 AI Embedding API

智谱 AI 及ChatGLM 在上一章已经进行了简单介绍，本章将介绍如何通过其获得文本的 embedding 的，以及将其封装成个性化 embedding 嵌入 LangChain 使用。关于什么是 embedding，具体作用为何，请参见第四部分《数据库搭建》。

import zhipuai   zhipuai.api_key = "your api key" #填写控制台中获取的 APIKey 信息      model = "text_embedding" #选择调用生成 embedding 的模型

自定义要生产 embedding 的文本

text = "要生成 embedding 的输入文本，字符串形式。每个输入不得超过模型的最大输入tokens数量512"

调用远程 API

response = zhipuai.model_api.invoke(       model=model,       prompt=text   )

官方的 SDK 返回的结果是字典的格式，这里我们可以直接传入键获得值。

我们通过查看 code 是否 == 200 来判断请求是否成功

print(response['code'])

返回的 embedding, token 等内容被存放在 data 中。我们可以查看生产 embedding 的长度

print(f"生成的 embedding 长度为: {len(response['data']['embedding'])}")

生成的 embedding 长度为: 1024

对于每次模型的调用来说，都是要消耗 token 的（花钱），token 的消耗都存放在 data 的 usage 中。

一般情况下 ChatGLM 模型中 token 和字数的换算比例约为 1:1.8，但因为不同模型的分词不同，所以换算比例也存在差异，每一次实际处理 token 数量以模型返回为准。

我们可以查看输入的 tokens

print(f"用户输入的 tokens 数量为: {response['data']['usage']['prompt_tokens']}")

用户输入的 tokens 数量为: 28

print(f"用户输入的文本长度为: {len(text)}")

用户输入的文本长度为: 52

print(f"本次 token 和字数的换算比例为: {response['data']['usage']['prompt_tokens']/len(text)}, 和理论值 1:1.8 = {1/1.8} 接近")

本次 token 和字数的换算比例为: 0.5384615384615384, 和理论值 1:1.8 = 0.5555555555555556 接近

因为模型其实没有生成新的文本，只是获取到输入的 embedding，所以 token 数为0

print(f"模型输出的 tokens 数量为: {response['data']['usage']['completion_tokens']}")

模型输出的 tokens 数量为: 0

print(f"总 tokens 数量为: {response['data']['usage']['total_tokens']}")

总 tokens 数量为: 28

2. 使用 LangChain 调用智谱 AI Embedding

我们同样可以通过 LangChain 框架来调用智谱 AI 大模型，以将其接入到我们的应用框架中。

原生的 LangChain 是不支持智谱 AI Embedding 调用的，我们需要自定义一个 Embedding。

此处，我们可以直接调用已自定义好的 ZhipuAILLM

import zhipuai

from zhipuai_embedding import ZhipuAIEmbeddings

zhipuai.api_key = "xxx"     #输入你的 api_key

zhipuai_embeddings = ZhipuAIEmbeddings(zhipuai_api_key=zhipuai.api_key)

我们可以生成 query 的 embedding。

query_embedding = zhipuai_embeddings.embed_query('你好')      print(query_embedding[:10])

[-0.13970163464546204, 0.04416792839765549, 0.020967043936252594, -0.19684536755084991, 0.08451296389102936, -0.0685092955827713, -0.05186789482831955, 0.11296232044696808, 0.12375720590353012, 0.1507660448551178]

我们也可以生成 doc_list 的 embedding。

doc_list = [       '你好',       '什么是机器学习',       '什么是深度学习',       '什么是大模型'   ]      doc_embeddings = zhipuai_embeddings.embed_documents(doc_list)

print('\n'.join([f'{doc} 的 embedding 为 {doc_embedding[:10]}...\n' for doc, doc_embedding in zip(doc_list, doc_embeddings)]))

你好 的 embedding 为 [-0.13970163464546204, 0.04416792839765549, 0.020967043936252594, -0.19684536755084991, 0.08451296389102936, -0.0685092955827713, -0.05186789482831955, 0.11296232044696808, 0.12375720590353012, 0.1507660448551178]...  
  
什么是机器学习 的 embedding 为 [-0.04628180339932442, -0.09553179144859314, 0.010844158940017223, -0.1201983317732811, 0.16935010254383087, -0.15349552035331726, 0.17940732836723328, 0.1256963312625885, 0.09910263121128082, 0.1022590845823288]...  
  
什么是深度学习 的 embedding 为 [-0.09552870690822601, -0.03116282820701599, 0.11060678958892822, 0.08925414085388184, 0.06898286193609238, -0.07559530436992645, 0.2021033763885498, -0.04418506473302841, 0.10697835683822632, -0.0666293203830719]...  
  
什么是大模型 的 embedding 为 [0.10551410913467407, 0.1735556423664093, -0.24402201175689697, 0.02649446204304695, 0.09757085889577866, 0.030247822403907776, 0.4318920969963074, 0.06334380805492401, -0.02869655191898346, -0.1011139303445816]...

七、langchain 核心组件详解

1. 模型输入/输出

LangChain 中模型输入/输出模块是与各种大语言模型进行交互的基本组件，是大语言模型应用的核心元素。模型 I/O 允许您管理 prompt（提示），通过通用接口调用语言模型以及从模型输出中提取信息。该模块的基本流程如下图所示。

主要包含以下部分：Prompts、Language Models以及 Output Parsers。用户原始输入与模型和示例进行组合，然后输入给大语言模型，再根据大语言模型的返回结果进行输出或者结构化处理。

2. 数据连接

大语言模型(Large Language Model, LLM), 比如 ChatGPT , 可以回答许多不同的问题。但是大语言模型的知识来源于其训练数据集，并没有用户的信息（比如用户的个人数据，公司的自有数据），也没有最新发生时事的信息（在大模型数据训练后发表的文章或者新闻）。因此大模型能给出的答案比较受限。如果能够让大模型在训练数据集的基础上，利用我们自有数据中的信息来回答我们的问题，那便能够得到更有用的答案。

为了支持上述应用的构建，LangChain 数据连接（Data connection）模块通过以下方式提供组件来加载、转换、存储和查询数据：Document loaders、Document transformers、Text embedding models、Vector stores 以及 Retrievers。数据连接模块部分的基本框架如下图所示。

3. 链（Chain）

虽然独立使用大型语言模型能够应对一些简单任务，但对于更加复杂的需求，可能需要将多个大型语言模型进行链式组合，或与其他组件进行链式调用。链允许将多个组件组合在一起，创建一个单一的、连贯的应用程序。例如，可以创建一个链，接受用户输入，使用 PromptTemplate 对其进行格式化，然后将格式化后的提示词传递给大语言模型。也可以通过将多个链组合在一起或将链与其他组件组合来构建更复杂的链。

大语言模型链（LLMChain）是一个简单但非常强大的链，也是后面我们将要介绍的许多链的基础。我们以它为例，进行介绍：

import warnings   warnings.filterwarnings('ignore')      from langchain.chat_models import ChatOpenAI    from langchain.prompts import ChatPromptTemplate     from langchain.chains import LLMChain        # 这里我们将参数temperature设置为0.0，从而减少生成答案的随机性。   # 如果你想要每次得到不一样的有新意的答案，可以尝试调整该参数。   llm = ChatOpenAI(temperature=0.0)        #初始化提示模版   prompt = ChatPromptTemplate.from_template("描述制造{product}的一个公司的最佳名称是什么?")      #将大语言模型(LLM)和提示（Prompt）组合成链   chain = LLMChain(llm=llm, prompt=prompt)      #运行大语言模型链   product = "大号床单套装"   chain.run(product)

运行输出：

‘“豪华床纺”’

除了上例中给出的 LLMChain，LangChain 中链还包含 RouterChain、SimpleSequentialChain、SequentialChain、TransformChain 等。

RouterChain 可以根据输入数据的某些属性/特征值，选择调用不同的子链（Subchain）。
SimpleSequentialChain 是最简单的序列链形式，其中每个步骤具有单一的输入/输出，上一个步骤的输出是下一个步骤的输入。
SequentialChain 是简单顺序链的更复杂形式，允许多个输入/输出。
TransformChain 可以引入自定义转换函数，对输入进行处理后进行输出。

以下是使用 SimpleSequentialChain 的代码示例：

from langchain.chains import SimpleSequentialChain   llm = ChatOpenAI(temperature=0.9)      #创建两个子链      # 提示模板 1 ：这个提示将接受产品并返回最佳名称来描述该公司   first_prompt = ChatPromptTemplate.from_template(          "描述制造{product}的一个公司的最好的名称是什么"   )   chain_one = LLMChain(llm=llm, prompt=first_prompt)      # 提示模板 2 ：接受公司名称，然后输出该公司的长为20个单词的描述   second_prompt = ChatPromptTemplate.from_template(          "写一个20字的描述对于下面这个\       公司：{company_name}的"   )   chain_two = LLMChain(llm=llm, prompt=second_prompt)      #构建简单顺序链   #现在我们可以组合两个LLMChain，以便我们可以在一个步骤中创建公司名称和描述   overall_simple_chain = SimpleSequentialChain(chains=[chain_one, chain_two], verbose=True)         #运行简单顺序链   product = "大号床单套装"   overall_simple_chain.run(product)

运行输出：

> Entering new SimpleSequentialChain chain...  
优床制造公司  
优床制造公司是一家专注于生产高品质床具的公司。  
  
> Finished chain.  
  
  
'优床制造公司是一家专注于生产高品质床具的公司。'

4. 记忆（Memory）

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

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

5. 代理（Agents）

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

6.回调（Callback）

LangChain提供了一个回调系统，允许您连接到LLM应用程序的各个阶段。这对于日志记录、监视、流式处理和其他任务非常有用。

Callback 模块扮演着记录整个流程运行情况的角色，充当类似于日志的功能。在每个关键节点，它记录了相应的信息，以便跟踪整个应用的运行情况。例如，在 Agent 模块中，它记录了调用 Tool 的次数以及每次调用的返回参数值。Callback 模块可以将收集到的信息直接输出到控制台，也可以输出到文件，甚至可以传输到第三方应用程序，就像一个独立的日志管理系统一样。通过这些日志，可以分析应用的运行情况，统计异常率，并识别运行中的瓶颈模块以进行优化。

Callback 模块的具体实现包括两个主要功能，对应CallbackHandler 和 CallbackManager 的基类功能：

CallbackHandler 用于记录每个应用场景（如 Agent、LLchain 或 Tool ）的日志，它是单个日志处理器，主要记录单个场景的完整日志信息。
而CallbackManager则封装和管理所有的 CallbackHandler ，包括单个场景的处理器，也包括整个运行时链路的处理器。"

在哪里传入回调 ?

该参数可用于整个 API 中的大多数对象（链、模型、工具、代理等），位于两个不同位置：：

构造函数回调：在构造函数中定义，例如 LLMChain(callbacks=[handler], tags=[‘a-tag’]) ，它将被用于对该对象的所有调用，并且将只针对该对象，例如，如果你向 LLMChain 构造函数传递一个 handler ，它将不会被附属于该链的 Model 使用。

请求回调：定义在用于发出请求的 call() / run() / apply() 方法中，例如 chain.call(inputs, callbacks=[handler]) ，它将仅用于该特定请求，以及它包含的所有子请求（例如，对 LLMChain 的调用会触发对 Model 的调用，该 Model 使用 call() 方法中传递的相同 handler）。

verbose 参数在整个 API 的大多数对象（链、模型、工具、代理等）上都可以作为构造参数使用，例如 LLMChain(verbose=True)，它相当于将 ConsoleCallbackHandler 传递给该对象和所有子对象的 callbacks 参数。这对调试很有用，因为它将把所有事件记录到控制台。

你想在什么时候使用这些东西呢？

构造函数回调对诸如日志、监控等用例最有用，这些用例不是针对单个请求，而是针对整个链。例如，如果你想记录所有向 LLMChain 发出的请求，你可以向构造函数传递一个处理程序。

请求回调对流媒体等用例最有用，你想把单个请求的输出流向特定的 websocket 连接，或其他类似用例。例如，如果你想把单个请求的输出流到一个 websocket ，你会把一个处理程序传递给 call() 方法.

关于langchain组件的更多使用方法和示例，可以参考以下材料：

langchain 官方文档
面向开发者的 LLM 入门课程

八、总结

在本章中，我们简要介绍了四种常用大模型 API 的调用方式：ChatGPT、百度文心、讯飞星火、智谱 AI。四种模型 API 都具有不同的调用要求，我们分别进行了介绍并对其原生接口进行了封装，方便用户直接调用使用；同时，我们也简要介绍了如何将大模型 API 封装到 LangChain 的自定义 LLM 中，如何将大模型 API 封装成统一方式调用的本地 API，以及如何将大模型 Embedding API 封装到 LangChain 的自定义 LLM 中。我们分别以百度文心、讯飞星火、智谱 AI作为示例介绍了调用方式，欢迎读者们自行实践尝试将更多的模型进行统一封装。

学习完本章，你应该掌握了常用大模型的基本调用方式，那么接下来，你就可以开始着手基于大模型打造自己的应用啦！

以上所有代码仅为思路，因API更新太快，请以官方文档为准！

如何系统的去学习大模型LLM ？

大模型时代，火爆出圈的LLM大模型让程序员们开始重新评估自己的本领。 “AI会取代那些行业？”“谁的饭碗又将不保了？”等问题热议不断。

事实上，抢你饭碗的不是AI，而是会利用AI的人。

继科大讯飞、阿里、华为等巨头公司发布AI产品后，很多中小企业也陆续进场！超高年薪，挖掘AI大模型人才！ 如今大厂老板们，也更倾向于会AI的人，普通程序员，还有应对的机会吗？

与其焦虑……

不如成为「掌握AI工具的技术人」，毕竟AI时代，谁先尝试，谁就能占得先机！

但是LLM相关的内容很多，现在网上的老课程老教材关于LLM又太少。所以现在小白入门就只能靠自学，学习成本和门槛很高。

基于此，我用做产品的心态来打磨这份大模型教程，深挖痛点并持续修改了近70次后，终于把整个AI大模型的学习门槛，降到了最低！

在这个版本当中：

第一您不需要具备任何算法和数学的基础
第二不要求准备高配置的电脑
第三不必懂Python等任何编程语言

您只需要听我讲，跟着我做即可，为了让学习的道路变得更简单，这份大模型教程已经给大家整理并打包，现在将这份 LLM大模型资料 分享出来：包括LLM大模型书籍、640套大模型行业报告、LLM大模型学习视频、LLM大模型学习路线、开源大模型学习教程等, 😝有需要的小伙伴，可以 扫描下方二维码领取🆓↓↓↓

👉CSDN大礼包🎁：全网最全《LLM大模型入门+进阶学习资源包》免费分享（安全链接，放心点击）👈

一、LLM大模型经典书籍

AI大模型已经成为了当今科技领域的一大热点，那以下这些大模型书籍就是非常不错的学习资源。

在这里插入图片描述

二、640套LLM大模型报告合集

这套包含640份报告的合集，涵盖了大模型的理论研究、技术实现、行业应用等多个方面。无论您是科研人员、工程师，还是对AI大模型感兴趣的爱好者，这套报告合集都将为您提供宝贵的信息和启示。(几乎涵盖所有行业)
在这里插入图片描述

三、LLM大模型系列视频教程

在这里插入图片描述

四、LLM大模型开源教程（LLaLA/Meta/chatglm/chatgpt）

在这里插入图片描述

五、AI产品经理大模型教程

在这里插入图片描述

LLM大模型学习路线 ↓

阶段1：AI大模型时代的基础理解

目标：了解AI大模型的基本概念、发展历程和核心原理。
内容：
- L1.1 人工智能简述与大模型起源
- L1.2 大模型与通用人工智能
- L1.3 GPT模型的发展历程
- L1.4 模型工程
- L1.4.1 知识大模型
- L1.4.2 生产大模型
- L1.4.3 模型工程方法论
- L1.4.4 模型工程实践
- L1.5 GPT应用案例

阶段2：AI大模型API应用开发工程

目标：掌握AI大模型API的使用和开发，以及相关的编程技能。
内容：
- L2.1 API接口
- L2.1.1 OpenAI API接口
- L2.1.2 Python接口接入
- L2.1.3 BOT工具类框架
- L2.1.4 代码示例
- L2.2 Prompt框架
- L2.3 流水线工程
- L2.4 总结与展望