AI on 水元素长弓

Agent术语详解

Sun, 24 May 2026 20:50:34 +0800

大模型部分

LLM：

LLM 全称 Large Language Model，中文译为大语言模型。

基于海量文本数据训练，可实现自然语言理解、文本生成、逻辑推理、代码编写、问答创作等功能，常见模型包含GPT、文心一言、通义千问、讯飞星火、豆包等。

Prompt

Prompt 中文称作提示词，是用户向大语言模型下达的指令、提问、描述文本。

通过设定文字要求，引导LLM按照指定风格、格式、逻辑完成生成、问答、创作、翻译等任务。

Context

Context即上下文，指对话过程中历史问答、输入文本、背景信息等全部内容。

LLM依托上下文理解语义、承接对话逻辑，连贯完成多轮交互与长文本任务。

Memory

Memory意为记忆，是大模型存储对话历史、用户偏好、过往交互数据的模块。

用于留存过往信息，实现连续对话、个性化应答与历史内容复用。

智能体部分

RAG

RAG入门——上

RAG（Retrieval-Augmented Generation）即检索增强生成，为大模型提供了从特定数据源检索到的信息，以此来修正和补充生成的答案。可以总结为一个公式：RAG = 检索技术 + LLM 提示

注：上图均来自于黑马程序员大模型RAG与Agent智能体项目实战教程

简单来说RAG工作分为两条线

离线流程-R（Retrieval检索）：知识库预处理，通过查询各种的方式寻找文档/私有知识并加载，在分割，向量化之后形成向量数据库。
在线流程-A（Augmentation增强）G（Generation生成）：用户提问->检索环节->Prompt融合->大模型回答
同时离线流程中的向量数据库会流向在线流程的检索环节。w

模型本质上就是用户输入，模型给出输出，用户能做的就是在输入上做功夫。

RAG 就是在向模型提问之前基于已有的知识库或文档内容做检索，确保向模型提问的内容更精准以及包含足够的信息量用以提供给模型。

RAG 的核心价值：

解决知识实效性问题：大模型的训练数据有截止时间，RAG 可以接入最新文档（如公司财报、政策文件），让模型输出 “与时俱进”。
降低模型幻觉：模型的回答基于检索到的事实性资料，而非纯靠自身记忆，大幅减少编造信息的概率。
无需重新训练模型：相比微调（Fine-tuning），RAG 只需更新知识库，成本更低、效率更高。

模型上下文搜索协议 MCP

MCP：model context protocol

Agent入门

Sat, 16 May 2026 21:19:29 +0800

Agent入门

RAG开发——下

Sat, 16 May 2026 19:44:09 +0800

RAG开发——下

chain链

「将组件串联，上一个组件的输出作为下一个组件的输入」是 LangChain 链（尤其是 | 管道链）的核心工作原理，这也是链式调用的核心价值：实现数据的自动化流转与组件的协同工作，如下。

chain = prompt_template | model

核心前提：即 Runnable 子类对象才能入链（以及 Callable、Mapping 接口子类对象也可加入（后续了解用的不多））。

我们目前所学习到的组件，均是 Runnable 接口的子类，如下类的继承关系：

通过|链接提示词模板对象和模型对象

返回值chain对象是RunnableSerializable对象

是Runnable接口的直接子类
也是绝大多数组件的父类

通过invoke或stream进行阻塞执行或流式执行

组成的链在执行上有：上一个组件的输出作为下一个组件的输入的特性.(可以链接许多组件，比如连续链接多个模型)

 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


from langchain_core.prompts import ChatPromptTemplate,MessagesPlaceholder

from langchain_community.chat_models.tongyi import ChatTongyi
chat_prompt_template = ChatPromptTemplate.from_messages(
 [
 ("system", "你是一个边塞诗人，可以作诗。"),
 MessagesPlaceholder("history"),
 ("human", "请再来一首唐诗"),
 ]
)

history_data = [
 ("human", "你来写一个唐诗"),
 ("ai", "床前明月光，疑是地上霜，举头望明月，低头思故乡"),
 ("human", "好诗再来一个"),
 ("ai", "锄禾日当午，汗滴禾下锄，谁知盘中餐，粒粒皆辛苦"),
]

model = ChatTongyi(model="qwen3-max",streaming=True)

# 组成链，要求每一个组件都是Runnable接口的子类
chain = chat_prompt_template | model

# 通过链去调用invoke或stream
# res = chain.invoke({"history": history_data})
# print(res.content)

# 通过stream流式输出
for chunk in chain.stream({"history": history_data}):
 print(chunk.content, end="", flush=True)

RunnableSequence

RunnableSequence = 用 | 连接多个组件后，生成那个「链条对象」

它是 LangChain 链的官方学名

chain = prompt | model | parser得到的 chain 数据类型就是：RunnableSequence

所谓 | 管道符，本质就是：创建了一个 RunnableSequence 对象

1
2


运行
chain = prompt | model | parser

等同于官方写法：

1
2
3
4


运行
from langchain_core.runnables import RunnableSequence

chain = RunnableSequence(prompt, model, parser)

StrOutputParser字符串输出解析器

有如下代码，以第一次的输出结果去询问第二给模型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from langchain_core.prompts import PromptTemplate
from langchain_community.chat_models.tongyi import ChatTongyi

model = ChatTongyi(model="qwen3-max")

prompt = PromptTemplate.from_template(
 "我邻居姓: {lastname}, 刚生了{gender}, 请起名, 仅告知名字无需其它内容"
)

chain = prompt | model | model
res = chain.invoke({"lastname": "张", "gender": "女儿"})
print(res.content)

链的构建完全符合要求（参与的组件）

但是运行报错（ValueError: Invalid input type <class ’langchain_core.messages.ai.AIMessage’>. Must be a PromptValue, str, or list of BaseMessages.）

这是因为第一次model输出结果是：AIMessage，但是第二次model需要接受的类型不能是AIMessage，导致的报错。

所以我们此时要通过StrOutputParser字符串输出解析器，可以将AIMessage解析为简单的字符串，符合了模型invoke方法的要求。如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


from langchain_core.output_parsers import StrOutputParser
from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.prompts import PromptTemplate

parser = StrOutputParser()
model = ChatTongyi(model="qwen3-max")
prompt = PromptTemplate.from_template(
 "我邻居姓:{lastname},刚生了{gender}，请起名"
)

chain = prompt | model | parser |model

res = chain.invoke({"lastname":"张","gender":"女儿"})
print(res.content )

JsonOutputParser

我们运行代码后发现上一个模型的输出没有被处理就给了第二个模型，导致第二次是对第一次的回答直接回答，索要的结果不是我们想要的结果

所以我们在给第二次模型调用之前还需要对其进行处理

所以我们需要完成：

将模型输出的AIMessage->转为字典->注入第二个提示词模板中，形成新的提示词

示例代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


from langchain_core.output_parsers import StrOutputParser
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_community.chat_models.tongyi import ChatTongyi

str_parser = StrOutputParser()
json_parser = JsonOutputParser()

model = ChatTongyi(model="qwen3-max")

first_prompt = PromptTemplate.from_template(
 "我邻居姓: {lastname}, 刚生了{gender}, 请起名, 并封装到JSON格式返回给我, "
 "要求key是name, value就是起的名字。请严格遵守格式要求"
)

second_prompt = PromptTemplate.from_template(
 "姓名{name}, 请帮我解析含义。"
)

chain = first_prompt | model | json_parser | second_prompt | model | str_parser

res: str = chain.invoke({"lastname": "张", "gender": "女儿"})
print(res)
print(type(res))

其中

"我邻居姓: {lastname}, 刚生了{gender}, 请起名, 并封装到JSON格式返回给我, "
"要求key是name, value就是起的名字。请严格遵守格式要求"

通过在提示词中做文章让输出的值强制为JSON格式，否则可能会报错。

其转化过程可能为

RunnambeLambda

将普通函数转化为Runnable接口实例，方便自定义函数加入Chain

示例代码

 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_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableLambda
from langchain_core.prompts import PromptTemplate
from langchain_community.chat_models.tongyi import ChatTongyi

str_parser = StrOutputParser()
my_func = RunnableLambda(lambda ai_msg: {"name": ai_msg.content})

model = ChatTongyi(model="qwen3-max")

first_prompt = PromptTemplate.from_template(
 "我邻居姓: {lastname}, 刚生了{gender}, 请起名, 仅告知我名字, 不要额外信息"
)

second_prompt = PromptTemplate.from_template(
 "姓名{name}, 请帮我解析含义。"
)

chain = first_prompt | model | my_func | second_prompt | model | str_parser

res: str = chain.invoke({"lastname": "张", "gender": "女儿"})
print(res)
print(type(res))

当然，跳过RunnableLambda直接让函数加入链也是可以的。因为 Runnable接口在实现_or_的时候，支持Callable接口的实例，而函数就是Callable接口的实例。即它会自动完成转化动作。

临时记忆

LangChain内置了历史记录附加功能，帮助模型在有历史记忆的情况下回答

基于RunnableWithMessageHistory在原有链的基础上创建带有历史记录功能的新链（新Runnable实例）
基于InMemoryChatMessageHistory为历史记录提供内存存储（临时用）

1
2
3
4
5
6
7
8
9


from langchain_core.runnables.history import RunnableWithMessageHistory

# 通过RunnableWithMessageHistory获取一个新的带有历史记录功能的chain
conversation_chain = RunnableWithMessageHistory(
 some_chain, # 被附加历史消息的Runnable, 通常是chain
 None, # 获取指定会话ID的历史会话的函数
 input_messages_key="input", # 声明用户输入消息在模板中的占位符
 history_messages_key="chat_history" # 声明历史消息在模板中的占位符
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 获取指定会话ID的历史会话记录函数
chat_history_store = {} # 存放多个会话ID所对应的历史会话记录
# 函数传入为会话ID（字符串类型）
# 函数要求返回BaseChatMessageHistory的子类
# BaseChatMessageHistory类专用于存放某个会话的历史记录
# InMemoryChatMessageHistory是官方自带的基于内存存放历史记录的类
def get_history(session_id):
 if session_id not in chat_history_store:
 # 返回一个新的实例
 chat_history_store[session_id] = InMemoryChatMessageHistory()
 return chat_history_store[session_id]

RunnableWithMessageHistory 是 LangChain 内 Runnable 接口的实现，主要用于：

创建一个带有历史记忆功能的 Runnable 实例（链）

它在创建的时候需要提供一个 BaseChatMessageHistory 的具体实现（用来存储历史消息）

InMemoryChatMessageHistory 可以实现在内存中存储历史

额外的，如果想要在 invoke 或 stream 执行链的同时，将提示词 print 出来，可以在链中加入自定义函数实现。

注意：函数的输入应原封不动返回出去，避免破坏原有业务，仅在 return 之前，print 所需信息即可。

长期记忆

使用InMemoryChatMessageHistory仅可以在内存中临时存储会话记忆，一旦程序退出，则记忆丢失。

InMemoryChatMessageHistory类继承自BaseChatMessageHistory。

但是我们可以自行实现一个基于Json格式和本地文件的会话数据保存。

基于文件存储会话系统记录，以Session_id为文件名。

通过继承BaseChatMessageHistory实现如下三个方法：

add_messages:同步模式，添加消息
messages：同步模式，获取消息
clear：同步模式，清除消息

 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


import os
import json
from typing import Sequence

from langchain_core.messages import message_to_dict, messages_from_dict, BaseMessage
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_core.runnables.history import RunnableWithMessageHistory


class FileChatMessageHistory(BaseChatMessageHistory):

 def __init__(self, session_id, storage_path):
 self.session_id = session_id
 self.storage_path = storage_path
 self.file_path = os.path.join(self.storage_path, f"{self.session_id}.json")
 os.makedirs(self.storage_path, exist_ok=True)

 def add_messages(self, messages: Sequence[BaseMessage]) -> None:
 all_messages = list(self.messages)
 all_messages.extend(messages)
 new_messages = [message_to_dict(msg) for msg in all_messages]

 with open(self.file_path, "w", encoding="utf-8") as f:
 json.dump(new_messages, f, ensure_ascii=False, indent=2)

 @property
 def messages(self) -> list[BaseMessage]:
 try:
 # ✅ 这里必须是 "r" 读模式！！！
 with open(self.file_path, "r", encoding="utf-8") as f:
 message_data = json.load(f)
 return messages_from_dict(message_data)
 except FileNotFoundError:
 return []

 def clear(self) -> None:
 with open(self.file_path, "w", encoding="utf-8") as f:
 json.dump([], f)


def print_prompt(full_prompt):
 print("=" * 20, full_prompt.to_string(), "=" * 20)
 return full_prompt


model = ChatTongyi(model="qwen3-max")
prompt = PromptTemplate.from_template(
 "你需要根据对话历史回应用户问题。对话历史: {chat_history}。用户当前输入: {input}, 请给出回应"
)

base_chain = prompt | print_prompt | model | StrOutputParser()


def get_history(session_id):
 return FileChatMessageHistory(session_id, "./chat_history")


conversation_chain = RunnableWithMessageHistory(
 base_chain,
 get_history,
 input_messages_key="input",
 history_messages_key="chat_history"
)

if __name__ == '__main__':
 session_config = {"configurable": {"session_id": "user_001"}}

 res = conversation_chain.invoke({"input": "小明有两个猫"}, session_config)
 print("第一次执行", res)

 res = conversation_chain.invoke({"input": "小刚有一只狗"}, session_config)
 print("第二次执行", res)

 # res = conversation_chain.invoke({"input": "总共有几个宠物"}, session_config)
 # print("第三次执行", res)

Document Loaders 文档加载器

文档加载器提供了一套标准接口，用于将不同来源（如 CSV、PDF 或 JSON 等）的数据读取为 LangChain 的文档格式。这确保了无论数据来源如何，都能对其进行一致性处理。

文档加载器（内置或自行实现）需实现 BaseLoader 接口。

Class Document，是 LangChain 内文档的统一载体，所有文档加载器最终返回此类的实例。

一个基础的 Document 类实例，基于如下代码创建：

1
2
3
4
5


from langchain_core.documents import Document

document = Document(
 page_content="Hello, world!", metadata={"source": "https://example.com"}
)

可以看到，Document 类其核心记录了：

page_content: 文档内容
metadata: 文档元数据（字典）

不同的文档加载器可能定义了不同的参数，但是其都实现了统一的接口（方法）

load()：一次性加载全部文档
lazy_load()：延迟流式传输文档，对大型数据集很有用，避免内存溢出。

一个简单的 CSVLoader 的使用示例如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from langchain_community.document_loaders.csv_loader import CSVLoader

loader = CSVLoader(
 ... # 初始化参数
)

# 一次性加载全部文档
documents = loader.load()

# 对于大数据集，分段返回文档
for document in loader.lazy_load():
 print(document)

LangChain内置了许多文档加载器，详见官方文档

Vrctor stores 向量存储,基于向量并构建提示词

烂尾ing…

RunnablePassthrough

烂尾ing…

RAG开发——上

Sat, 16 May 2026 16:35:06 +0800

LangChain

LangChain简介

LangChain 由 Harrison Chase 创建于2022年10月，它是围绕LLMs（大语言模型）建立的一个框架。

LangChain自身并不开发LLMs，它的核心理念是为各种LLMs实现通用的接口，把LLMs相关的组件“链接”在一起，简化LLMs应用的开发难度，方便开发者快速地开发复杂的LLMs应用。

我们将其划分为六类

Prompts （提示词工程）
Models （调用模型）
History （管理会话记录历史）
Indexes （管理分析各类文档）
Chains （构建功能的执行链条）
Agent （构建智能体）

基本围绕了大模型所有的要求，实际上是一个Python的第三方库，提供了各种功能的Api

LangChain安装

1

pip install langchain langchain-community langchain-ollama dashscope chromadb

langchain: 核心包
langchain-community: 社区支持包，提供了更多的第三方模型调用（我们用的阿里云千问模型就需要这个包）
langchain-ollama: Ollama支持包，支持调用Ollama托管部署的本地模型
dashscope: 阿里云通义千问的Python SDK
chromadb: 轻量向量数据库（后续使用）

RAG

RAG介绍

通用的基础大模型存在一些问题：

LLM 的知识不是实时的，模型训练好后不具备自动更新知识的能力，会导致部分信息滞后
LLM 领域知识是缺乏的，大模型的知识来源于训练数据，这些数据主要来自公开的互联网和开源数据集，无法覆盖特定领域或高度专业化的内部知识
幻觉问题，LLM 有时会在回答中生成看似合理但实际上是错误的信息
数据安全性

注：上图均来自于黑马程序员大模型RAG与Agent智能体项目实战教程

简单来说RAG工作分为两条线

离线流程-R（Retrieval检索）：知识库预处理，通过查询各种的方式寻找文档/私有知识并加载，在分割，向量化之后形成向量数据库。
在线流程-A（Augmentation增强）G（Generation生成）：用户提问->检索环节->Prompt融合->大模型回答
同时离线流程中的向量数据库会流向在线流程的检索环节。w

模型本质上就是用户输入，模型给出输出，用户能做的就是在输入上做功夫。

RAG 就是在向模型提问之前基于已有的知识库或文档内容做检索，确保向模型提问的内容更精准以及包含足够的信息量用以提供给模型。

RAG 的核心价值：

解决知识实效性问题：大模型的训练数据有截止时间，RAG 可以接入最新文档（如公司财报、政策文件），让模型输出 “与时俱进”。
降低模型幻觉：模型的回答基于检索到的事实性资料，而非纯靠自身记忆，大幅减少编造信息的概率。
无需重新训练模型：相比微调（Fine-tuning），RAG 只需更新知识库，成本更低、效率更高。

向量的基础概念

在RAG流程中，向量库是一个重要的节点，参考上述图片于RAG工作流程。

那么向量具体是什么

向量化：把一段文字的的语义信息，转换成遗传固定长度的数字列表，让计算机能看懂文字的含义并作相似度计算。

向量嵌入的过程，我们一般选用合适的文本嵌入模型来完成。

在向量匹配的过程中，如何识别 2 段文本是否表述相似的含义，主要可以通过如余弦相似度等算法来完成。

比如（下列案例中向量为示例，仅描述概念，非真实向量）：

A：“如何快速学打篮球” → [0.2, 0.5, 0.8]
B：“打篮球怎么学得快” → [0.18, 0.52, 0.79]
C：“运动后吃什么好呢” → [0.9, 0.1, 0.2]

通过余弦相似度算法可以计算得到：A 和 B 相似度 0.999789，A 和 C 相似度 0.361446

由此可通过精确的数学计算，去匹配 2 段文本是否描述同一个意思，提高语义匹配的效率和精度。

如何更为精准的完成语义匹配，生成向量的维度是一个很重要的指标。

如Text-embedding-v1模型可以生成1536维的向量（1536个数字序列），这1536个数字表示这段文本在1536个主题方向上的得分强度

选择合适的向量维度可以让匹配更精确，但是过大的向量维度会加大计算压力。

余弦相似度

向量的数字序列，共同决定了向量在高维空间中的方向和长度。而余弦相似度主要就是撇除长度的影响，得到方向的夹角。夹角越小越相似，即方向相同。

LangChain

Langchain组件

Models大语言模型的使用

现在市面上的模型多如牛毛，各种各样的模型不断出现，LangChain 模型组件提供了与各种模型的集成，并为所有模型提供一个精简的统一接口。

LangChain 目前支持三种类型的模型：LLMs（大语言模型）、Chat Models（聊天模型）、Embeddings Models（嵌入模型）。

LLMs：是技术范畴的统称，指基于大参数量、海量文本训练的 Transformer 架构模型，核心能力是理解和生成自然语言，主要服务于文本生成场景
聊天模型：是应用范畴的细分，是专为对话场景优化的 LLMs，核心能力是模拟人类对话的轮次交互，主要服务于聊天场景
文本嵌入模型：文本嵌入模型接收文本作为输入，得到文本的向量。

LangChain 支持的三类模型，它们的使用场景不同，输入和输出不同，开发者需要根据项目需要选择相应。

我所用的阿里云通义千问系列主要来自于：langchain_community 包。

同时 LangChain 支持对许多模型的调用，以通义千问为例：

1
2
3
4
5
6
7
8


from langchain_community.llms.tongyi import Tongyi


model= Tongyi(model="qwen-max") # qwen-max是大语言模型才可以使用，即其他模型不可调用

res =model.invoke(input="你是谁")

print(res)

访问Ollama的话改为导入OllamaLLM类即可

Models的流式输出

如果需要流式输出结果，需要将模型的invoke方法改为stream方法即可。

invoke方法：一次型返回完整结果
stream方法：逐段返回结果，流式输出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# langchain_community
from langchain_community.llms.tongyi import Tongyi

# 不用qwen3-max，因为qwen3-max是聊天模型，qwen-max是大语言模型
model = Tongyi(model="qwen-max")

# 调用invoke向模型提问
res = model.stream(input="你是谁呀能做什么？")

for chunk in res:
 print(chunk, end="", flush=True)

Models调用聊天大模型

聊天消息包含下面几种类型，使用时需要按照约定传入合适的值：

AIMessage：就是 AI 输出的消息，可以是针对问题的回答。（对应 OpenAI 库中的assistant角色）
HumanMessage：人类消息，即用户信息，由人给出的发送给 LLMs 的提示信息，比如 “实现一个快速排序方法”。（对应 OpenAI 库中的user角色）
SystemMessage：可以用于指定模型具体所处的环境和背景，如角色扮演等。你可以在这里给出具体的指示，比如 “作为一个代码专家”，或者 “返回 json 格式”。（对应 OpenAI 库中的system角色）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage,AIMessage,SystemMessage

model= ChatTongyi(model="qwen3-max")

messages=[
 SystemMessage(content="你是一个失意诗人"),
 HumanMessage(content="写一首唐诗"),
 AIMessage(content="孤灯照壁夜微凉，冷月窥窗影半墙。残菊犹存三径露，断鸿空唳九回肠。"),
 HumanMessage(content="按照你上一次回复写一首唐诗")
]

res=model.stream(input=messages)

for chunk in res:
 print(chunk.content,end="",flush=True)

同时也可有如下简写方式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage,AIMessage,SystemMessage

model= ChatTongyi(model="qwen3-max")

messages = [
 ("system", "你是一个边塞诗人。"),
 ("human", "写一首唐诗"),
 ("ai", "锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦。"),
 ("human", "按照你上一个回复的格式，再写一首唐诗。")
]

res=model.stream(input=messages)

for chunk in res:
 print(chunk.content,end="",flush=True)

嵌入模型的使用

Embeddings Models(文本嵌入模型)

Embeddings Models嵌入模型的特点：将字符串作为输入，返回一个浮点数的列表（向量）。在NLP中，Embedding的作用就是将数据进行文本向量化。

阿里云千问模型访问方式：

1
2
3
4
5
6
7
8


from langchain_community.embeddings import DashScopeEmbeddings

初始化嵌入模型对象，其默认使用模型是: text-embedding-v1
embed = DashScopeEmbeddings()

测试
print(embed.embed_query("我喜欢你"))# 单词转换
print(embed.embed_documents(['我喜欢你', '我稀饭你', '晚上吃啥']))# 批量转换

ollama导入的话改为导入OllamaEmbeddings即可

通用Prompt

提示词优化在模型应用中非常重要，LangChain 提供了 PromptTemplate 类，用来协助优化提示词。

PromptTemplate 表示提示词模板，可以构建一个自定义的基础提示词模板，支持变量的注入，最终生成所需的提示词。

标准写法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


from langchain_core.prompts import PromptTemplate
from langchain_community.llms.tongyi import Tongyi

prompt_template = PromptTemplate.from_template(
 "我的邻居姓{lastname}, 刚生了{gender}, 帮忙起名字, 请简略回答。"
)

# 变量注入, 生成提示词文本
prompt_text = prompt_template.format(lastname="张", gender="女儿")

model = Tongyi(model="qwen-max") # 创建模型对象
res = model.invoke(input=prompt_text) # 调用模型获取结果
print(res)

基于Chain链的写法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


from langchain_core.prompts import PromptTemplate
from langchain_community.llms.tongyi import Tongyi

prompt_template = PromptTemplate.from_template(
 "我的邻居姓{lastname}, 刚生了{gender}, 帮忙起名字, 请简略回答。"
)

model = Tongyi(model="qwen-max") # 创建模型对象
# 生成链
chain = prompt_template | model
# 基于链, 调用模型获取结果
res = chain.invoke(input={"lastname": "曹", "gender": "女儿"})
print(res)

FewShot写法

 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_core.prompts import PromptTemplate, FewShotPromptTemplate
from langchain_community.llms.tongyi import Tongyi

# 示例的模板
example_template = PromptTemplate.from_template("单词: {word}, 反义词: {antonym}")

# 示例的动态数据注入 要求是list内部套字典
examples_data = [
 {"word": "大", "antonym": "小"},
 {"word": "上", "antonym": "下"}
]

few_shot_template = FewShotPromptTemplate(
 example_prompt=example_template, # 示例数据的模板
 examples=examples_data, # 示例的数据（用来注入动态数据的），list内套字典
 prefix="告知我单词的反义词，我提供如下的示例：", # 示例之前的提示词
 suffix="基于前面的示例告知我，{input_word}的反义词是？", # 示例之后的提示词
 input_variables=['input_word'] # 声明在前缀或后缀中所需要注入的变量名
)

prompt_text = few_shot_template.invoke(input={"input_word": "左"}).to_string()
print(prompt_text)

model = Tongyi(model="qwen-max")
print(model.invoke(input=prompt_text))

Format&invok

ChatPromptTemplate

PromptTemplate: 通用提示词模板，支持动态注入信息。

FewShotPromptTemplate: 支持基于模板注入任意数量的示例信息。

ChatPromptTemplate: 支持注入任意数量的历史会话信息。

通过from_messages方法，从列表中获取多轮次会话作为聊天的基础模板
- PS: 前面PromptTemplate类用的from_template仅能接入一条消息，而from_messages可以接入一个list的消息

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


from langchain_core.prompts import ChatPromptTemplate

ChatPromptTemplate.from_messages(
 [
 ("system", "......."),
 ("ai", "......."),
 ......,
 ("human", ".......")
 ]
)

历史会话信息并不是静态的（固定的），而是随着对话的进行不停地积攒，即动态的。

所以，历史会话信息需要支持动态注入。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


from langchain_core.prompts import ChatPromptTemplate
from langchain_core.prompts import MessagesPlaceholder

chat_template = ChatPromptTemplate.from_messages(
 [
 ("system", "......."),
 ("ai", "......."),
 MessagesPlaceholder("history"),
 ("human", ".......")
 ]
)

history_data = [
 ("human", "..."),
 ("ai", "..."),
 ("human", "..."),
 ("ai", "...")
]

prompt_value = chat_template.invoke({"history": history_data})

 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


from langchain_core.prompts import ChatPromptTemplate,MessagesPlaceholder

from langchain_community.chat_models.tongyi import ChatTongyi

chat_prompt_template = ChatPromptTemplate.from_messages(
 [
 ("system", "你是一个边塞诗人，可以作诗。"),
 MessagesPlaceholder("history"),
 ("human", "请再来一首唐诗"),
 ]
)

history_data = [
 ("human", "你来写一个唐诗"),
 ("ai", "床前明月光，疑是地上霜，举头望明月，低头思故乡"),
 ("human", "好诗再来一个"),
 ("ai", "锄禾日当午，汗滴禾下锄，谁知盘中餐，粒粒皆辛苦"),
]

# StringPromptValue to_string()
prompt_text = chat_prompt_template.invoke({"history": history_data}).to_string()

model = ChatTongyi(model="qwen3-max")

res = model.invoke(prompt_text)

print(res.content)

提示词工程

Fri, 15 May 2026 20:36:39 +0800

大模型prompt工程指南

提示工程（Prompt Engineering），也称为 In-Context Prompting，是指在不更新模型权重的情况下如何与大模型互以引导其行为以获得所需结果的方法。

在人工智能领域，Prompt指的是用户给大型语言模型发出的指令。

例如，“「讲个笑话」”、“「用Python编个贪吃蛇游戏」”、“「写封情书」”等。

虽然看似简单，但实际上，Prompt的设计对于模型的结果影响很大。

因此如何设计prompt，进而与模型更好的交互，是研究人员必备的必不可少的技能（提示工程）。

技巧

详细的描述
让ai扮演某个角色
使用分隔符标注输入的不同部分（强调重点等）
指定任务的步骤
提供例子
使用参考文本（降低模型的幻觉）

如：

根据下文中三重引号引起来的文章来回答问题。
如果在文章中找不到答案，请写“我找不到答案”，
不要自己造答案。

“”"<在此插入文档>""""<在此插入文档>"""" 问题： <在此插入问题>

提示词工程就是更好的向模型提问的技巧。大模型本身是一种很简单的结构，即：用户输入，模型输出。

用更详细、更清晰、有逻辑、有参考的提问，获得期望中的回答效果
不管是 RAG 还是 Agent 智能体亦或是其它围绕模型的各类复杂的开发工作，本质上都可以简单总结为在提示词上下功夫。

Zero-shot思想

Zero-shot学习是指在训练阶段不存在与阶段完全相同的类别，但是模型可以是同训练过的知识来推广到测试集中的新类别上。

这种能力称为”零样本“学习，因为模型在训练是从未见过的测试集中的新类别，在模型训练和提示词优化中均有体现。

在模型训练中：

已知马（四脚兽）、虎（有条纹）、熊猫（黑白色）的特征，但未训练过斑马的数据（不认识）
告知模型：斑马是四脚兽、有黑白色的条纹
模型可以在已知数据中进行推理，从而识别斑马。

在提示词优化中：

Zero-shot 思想用于基于已训练的能力，不提供任何示例，仅通过语言去描述任务的要求、目标和约束，让模型直接生成结果。

简单来说就是 “用语言定义任务，解放（信任）模型的预训练知识”

比如：请判断 "" 包围的用户评论中的情感倾向，输出正面或负面。
“这款代餐鸡胸肉饱腹感很强，吃起来也不柴，很推荐！”

Few-shot思想

Few-shot 学习（Few-shot Learning）是指少样本学习，当模型在学习了一定类别的大量数据后，对于新的类别，只需要少量的样本就能快速学习，对应的有 one-shot learning，单样本学习，也算样本少到为一的情况下的一种 few-shot learning。

在模型训练中（相似度判断方法）：

基于少量企鹅样本并结合相识度判断，推论未知图片内含 “企鹅”

在提示词优化中：

Few-shot 主要用于基于少量示例，让模型参考示例回答。

简单来说就是 “用示例定义任务，在模型的预训练知识的基础上，提升模型回答的对齐精度（比如参考示例的格式）”

比如：请抽取产品名称和核心卖点 2 个字段，格式为 Json，我提供 2 个示例。

示例 1：MacBookPro 高效节能，性能强大，适合牛马工作使用
- 输出: {“产品名称”: “MacBookPro”, “产品卖点”: “高效节能，性能强大”}
示例 2：联想笔记本拥有 RTX4060 独立显卡，畅玩游戏，丝滑流畅
- 输出: {“产品名称”: “联想笔记本”, “产品卖点”: “畅玩游戏，丝滑流畅”} 请处理：华为 MatepadPro，高清大屏，长效续航，你的好帮手。

实例案例

 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


from openai import OpenAI

# 1. 获取client对象，OpenAI类对象
client = OpenAI(
 base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

examples_data = { # 示例数据
 '新闻报道': '今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。',
 '财务报告': '本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康',
 '公司公告': '本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力',
 '分析师报告': '最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资'
}

examples_types = ['新闻报道', '财务报道', '公司公告', '分析师报告']

# 提问数据
questions = [
 "今日，央行发布公告宣布降低利率，以刺激经济增长。这一降息举措将影响贷款利率，并在未来几个季度内对金融市场产生影响。",
 "ABC公司今日发布公告称，已成功完成对XYZ公司股权的收购交易。本次交易是ABC公司在扩大业务范围、加强市场竞争力方面的重要举措。据悉，此次收购将进一步",
 "公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。",
 "最新的分析报告指出，可再生能源行业预计将在未来几年经历持续增长，投资者应该关注这一领域的投资机会",
 "小明喜欢小新哟"
]

"""

[
 {"role": "system", "content": "你是金融专家，将文本分类为['新闻报道', '财务报道', '公司公告', '分析师报告']，不清楚的分类为'不清楚'"},
 {"role": "user", "content": "今日，央行发布公告宣布降............"},
 {"role": "assistant", "content": "新闻报道"},
 {"role": "user", "content": "ABC公司今日发布公告称，已成功完成对XYZ公司股.................."},
 {"role": "assistant", "content": "财务报告"},
 {"role": "user", "content": "公司资产负债表显示，公司偿债能力强劲，现金流充足.................."},
 {"role": "assistant", "content": "公司公告"},
 {"role": "user", "content": "最新的分析报告指出，可再生能源..............."},
 {"role": "assistant", "content": "分析师报告"},
 {"role": "user", "content": "要提问的问题"}
]

"""

messages = [
 {"role": "system", "content": "你是金融专家，将文本分类为['新闻报道', '财务报道', '公司公告', '分析师报告']，不清楚的分类为'不清楚类别'"}
]

for key, value in examples_data.items():
 messages.append({"role": "user", "content": value})
 messages.append({"role": "assistant", "content": key})


# 向模型提问
for q in questions:
 response = client.chat.completions.create(
 model="qwen3-max",
 messages=messages + [{"role": "user", "content": f"按照示例，回答这段文本的分类类别: {q}"}]
 )

 print(response.choices[0].message.content)

Json数据格式

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。

Json 是带有格式的字符串，主要用于数据交换，即程序和程序之间的信息互传，使用 Json 会更加方便，如下示例：

1
2
3
4
5


1 周杰伦11岁是个男孩

2 蔡依临12岁是个女孩

3 小明16岁是一个男孩子

Text文本，非结构化，抓取信息不方便

1
2
3
4
5


1 周杰伦,11,男

2 蔡依临,12,女

3 小明,16,男

CSV（固定分隔符）文本，结构化，抽取信息方便，数据不含schema，有一定风险。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


{
 "name": "周杰伦",
 "age": 11,
 "gender": "男"
}
{
 "name": "蔡依临",
 "age": 12,
 "gender": "女"
}
{
 "name": "小明",
 "age": 16,
 "gender": "男"
}

Json格式文本，结构化，抽取信息方便，每条数据都包含Schema，但空间占用大。

Json有两种结构，Json对象和Json数组

Json对象

1
2
3
4


{
 "key":value，
 "key":value
}

Jaon数组

1

[{},{},{},...]

实例

1
2
3
4
5
6
7


{
[
 {"name": "周杰伦", "age": 11},
 {"name": "蔡依临", "age": 12},
 {"name": "小明", "age": 16}
]
}

Python 中使用 Json

Python 中使用 Json 主要完成：

将 Python 字典、列表转换为 Json 字符串
读取 Json 字符串，转换为 Python 字典或列表

主要使用 Python 内置的 json 库

json.dumps(字典或列表, ensure_ascii=False)：将字典或列表转换为 Json 字符串
- ensure_ascii参数确保中文能正常显示
- 返回值：Json 字符串
json.loads(json字符串)：将 Json 字符串转换为 Python 字典或列表
- 返回值：Python 字典或 Python 列表

 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


import json

d = {
 "name": "周杰伦",
 "age": 11,
 "gender": "男"
}

s = json.dumps(d, ensure_ascii=False)
print(s)

l = [
 {
 "name": "周杰伦",
 "age": 11,
 "gender": "男"
 },
 {
 "name": "蔡依临",
 "age": 12,
 "gender": "女"
 },
 {
 "name": "小明",
 "age": 16,
 "gender": "男"
 }
]
print(json.dumps(l, ensure_ascii=False))

json_str = '{"name": "周杰伦", "age": 11, "gender": "男"}'
json_array_str = '[{"name": "周杰伦", "age": 11, "gender": "男"}, {"name": "蔡依临", "age": 12, "gender": "女"}, {"name": "小明", "age": 16, "gender": "男"}]'

res_dict = json.loads(json_str)
print(res_dict, type(res_dict))

res_list = json.loads(json_array_str)
print(res_list, type(res_list))

提示词优化案例——金融信息文本抽取

prompt

在该任务的 prompt 设计中，我们主要考虑 2 点：

需要向模型解释什么叫作「信息抽取任务」
需要让模型按照我们指定的格式（json）输出为了让模型知道什么叫做「信息抽取」，我们借用 FewShot 的方式，先给模型展示几个正确的例子：

User: ‘2023-01-10，股市震荡。股票古哥 - D [EOOE] 美股今日开盘价 100 美元，一度飙升至 105 美元，随后回落至 98 美元，最终以 102 美元收盘，成交量达到 520000。’。提取上述句子中 “金融” (’ 日期 ‘, ’ 股票名称 ‘, ’ 开盘价 ‘, ’ 收盘价 ‘, ’ 成交量 ‘) 类型的实体，并按照 JSON 格式输出，上述句子中没有的信息用 [’ 原文中未提及 ‘] 来表示，多个值之间用 ‘,’ 分隔。

Bot: {‘日期’: [‘2023-01-10’], ‘股票名称’: [‘古哥-D[EOOE]美股’], ‘开盘价’: [‘100美元’], ‘收盘价’: [‘102美元’], ‘成交量’: [‘520000’]} …

其中，User 代表我们输入给模型的句子，Bot 代表模型的回复内容。

注意：上述例子中 Bot 的部分也是由人工输入的，其目的是希望看到在看到类似 User 中的句子时，模型应当做出类似 Bot 的回答。

示例

 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


from openai import OpenAI
import json

client = OpenAI(
 base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
 # base_url="http://localhost:11434/v1"
)

schema = ['日期', '股票名称', '开盘价', '收盘价', '成交量']

examples_data = [ # 示例数据
 {
 "content": "2023-01-10，股市震荡。股票强大科技A股今日开盘价100人民币，一度飙升至105人民币，随后回落至98人民币，最终以102人民币收盘，成交量达到520000。",
 "answers": {
 "日期": "2023-01-10",
 "股票名称": "强大科技A股",
 "开盘价": "100人民币",
 "收盘价": "102人民币",
 "成交量": "520000"
 }
 },
 {
 "content": "2024-05-16，股市利好。股票英伟达美股今日开盘价105美元，一度飙升至109美元，随后回落至100美元，最终以116美元收盘，成交量达到3560000。",
 "answers": {
 "日期": "2024-05-16",
 "股票名称": "英伟达美股",
 "开盘价": "105美元",
 "收盘价": "116美元",
 "成交量": "3560000"
 }
 }
]

questions = [ # 提问问题
 "2025-06-16，股市利好。股票传智教育A股今日开盘价66人民币，一度飙升至70人民币，随后回落至65人民币，最终以68人民币收盘，成交量达到123000。",
 "2025-06-06，股市利好。股票黑马程序员A股今日开盘价200人民币，一度飙升至211人民币，随后回落至201人民币，最终以206人民币收盘。"
]

"""
[
 {"role": "system",
 "content": f"你帮我完成信息抽取，我给你句子，你抽取{schema}信息，按JSON字符串输出，如果某些信息不存在，用'原文未提及'表示，请参考如下示例："},

 {"role": "user",
 "content": "2023-01-10，股市震荡。股票强大科技A股今日开盘价100人民币，一度飙升至105人民币，随后回落至98人民币，最终以102人民币收盘，成交量达到520000。"},
 {"role": "assistant",
 "content": '{"日期":"2023-01-10","股票名称":"强大科技A股","开盘价":"100人民币","收盘价":"102人民币","成交量":"520000"}'},

 {"role": "user",
 "content": "2024-05-16，股市利好。股票英伟达美股今日开盘价105美元，一度飙升至109美元，随后回落至100美元，最终以116美元收盘，成交量达到3560000。"},
 {"role": "assistant",
 "content": '{"日期":"2024-05-16","股票名称":"英伟达美股","开盘价":"105美元","收盘价":"116美元","成交量":"3560000"}'},

 {"role": "user",
 "content": f"按照上述示例，现在抽取这个句子的信息：{要抽取的句子文本}"}
]
"""

messages = [
 {"role": "system", "content": f"你帮我完成信息抽取，我给你句子，你抽取{schema}信息，按JSON字符串输出，如果某些信息不存在，用'原文未提及'表示，请参考如下示例："}
]

for example in examples_data:
 messages.append(
 {"role": "user", "content": example["content"]}
 )
 messages.append(
 {"role": "assistant", "content": json.dumps(example["answers"], ensure_ascii=False)}
 )

for q in questions:
 response = client.chat.completions.create(
 model="qwen3-max",
 messages=messages + [{"role": "user", "content": f"按照上述的示例，现在抽取这个句子的信息：{q}"}]
 )
 print(response.choices[0].message.content)

LLM信息文本匹配任务介绍

首先我们构造几个短文本对

1
2
3


1. ('股票市场今日大涨，投资者乐观。', '持续上涨的市场让投资者感到满意。'),
2. ('油价大幅下跌，能源公司面临挑战。', '未来智能城市的建设趋势愈发明显。'),
3. ('利率上升，影响房地产市场。', '高利率对房地产有一定冲击。'),

我们期望模型能够帮我们识别出成对的句子中，2 句话是否是有关联的

。我们期望模型输出的结果为：

 ['是', '不是', '是']

Prompt设计

在该任务的 prompt 设计中，我们主要考虑 2 点：

需要向模型解释什么叫作「文本匹配任务」
需要让模型按照我们指定的格式输出

为了让模型知道什么叫做「文本匹配任务」，我们借用 FewShot 的方式，先给模型展示几个正确的例子：

User:

句子一：公司 ABC 发布了季度财报，显示盈利增长。
句子二：财报披露，公司 ABC 利润上升
Bot: 是

User:

句子一：黄金价格下跌，投资者抛售。
句子二：外汇市场交易额创下新高
Bot: 不是 …

其中，User 代表我们输入给模型的句子，Bot 代表模型的回复内容。

注意：上述例子中 Bot 的部分也是由人工输入的，其目的是希望看到在看到类似 User 中的句子时，模型应当做出类似 Bot 的回答。

示例

 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


from openai import OpenAI

client = OpenAI(
 base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
 # base_url="http://localhost:11434/v1"
)

examples_data = {
 "是": [
 ("公司ABC发布了季度财报，显示盈利增长。", "财报披露，公司ABC利润上升。"),
 ("公司ITCAST发布了年度财报，显示盈利大幅度增长。", "财报披露，公司ITCAST更赚钱了。")
 ],
 "不是": [
 ("黄金价格下跌，投资者抛售。", "外汇市场交易额创下新高。"),
 ("央行降息，刺激经济增长。", "新能源技术的创新。")
 ]
}

questions = [
 ("利率上升，影响房地产市场。", "高利率对房地产有一定的冲击。"),
 ("油价大幅度下跌，能源公司面临挑战。", "未来智能城市的建设趋势越加明显。"),
 ("股票市场今日大涨，投资者乐观。", "持续上涨的市场让投资者感到满意。")
]

"""
{
 "role": "system",
 "content": f"你帮我完成文本匹配，我给你2个句子，被[]包围，你判断它们是否匹配，回答是或不是，请参考如下示例："
},
{
 "role": "user",
 "content": "句子1：[公司ABC发布了季度财报，显示盈利增长。]句子2：[财报披露，公司ABC利润上升。]"
},
{
 "role": "assistant",
 "content": "是"
},
{
 "role": "user",
 "content": "句子1：[公司ITCAST发布了年度财报，显示盈利大幅度增长。]句子2：[财报披露，公司ITCAST更赚钱了。]"
},
{
 "role": "assistant",
 "content": "是"
},
{
 "role": "user",
 "content": "句子1：[黄金价格下跌，投资者抛售。]句子2：[外汇市场交易额创下新高。]"
},
{
 "role": "assistant",
 "content": "不是"
},
{
 "role": "user",
 "content": "句子1：[央行降息，刺激经济增长。]句子2：[新能源技术的创新。]"
},
{
 "role": "assistant",
 "content": "不是"
},
{
 "role": "user",
 "content": f"按照上述示例，回答这2个句子的情况。句子1：[...]，句子2：[...]"
}
"""

messages = [
 {"role": "system", "content": f"你帮我完成文本匹配，我给你2个句子，被[]包围，你判断它们是否匹配，回答是或不是，请参考如下示例："},
]

for key, value in examples_data.items():
 for t in value:
 messages.append(
 {"role": "user", "content": f"句子1: [{t[0]}], 句子2: [{t[1]}]"}
 )
 messages.append(
 {"role": "assistant", "content": key}
 )

for q in questions:
 response = client.chat.completions.create(
 model="qwen3-max",
 messages=messages + [{"role": "user", "content": f"句子1: [{q[0]}], 句子2: [{q[1]}]"}]
 )
 print(response.choices[0].message.content)

大模型部署与openAI入门

Thu, 23 Apr 2026 17:16:56 +0800

前期调试

部署

我会通过阿里云百炼平台提供的免费试用额度来进行学习：

首先要通过代码吊桶阿里云百炼平台大模型，主要动作

在阿里云中创建好自己的apikey
在电脑中安装好openai库
复制官网示例代码并执行（可在代码中替换需要调用的模型）

使用环境变量保护APIKEY

代码中api如果是明文显示在代码中的，是有很大安全隐患的。我们可以通过环境变量来隐藏明文APIKEY

我们可以通过openai库来记录APIKEY或者langchain库。

在Windows中进行配置

打开高级系统设置，在系统属性，高级，环境变量中的用户变量下新建变量，变量名为OPENAI_API_KEY和DASHSCOPE_API_KEY,变量值就是自己的APIKEY的值。在配置好之后呢需要重启电脑，打开自己复制来的官网示例代码，删掉或者注释掉APIKEY一行，运行代码观察是否可以在无APIKEY的情况下运行。

在mac系统中配置

打开终端软件，输入命令

1

open .zshrc

在新窗口的空白部分输入

1
2


export OPENAI_API_KEY="修改为你自己的APIKEY"
export DASHSCOPE_API_KEY="修改为你自己的APIKEY"

保存，重启编译器或者重启电脑。将apikey代码行删掉观察能否运行。

ollama简介

为避免阿里云免费到期或者免费活动停止，可以通过ollama在本地部署一个模型供代码调用。

ollama：是一款旨在简化大型语言模型本地不是和运行过程的开源软件。

在ollama官网中可以下载大部分模型，对外提供接口，如命令行和Restful Api接口等。

ollama的部署

Windows系统

在官方网站点击Download按钮下载安装。

安装完成后，通过命令

1

ollama run 模型名称

即可运行对应的模型，并在命令行内做交互。

由于个人电脑的性能不高，所以我们一般选择蒸馏模型（简单理解为瘦身版），可以在网上查找，对比自己的显卡类型来调整参数量。

mac系统

同样在官方文件下载……

代码调用ollama的本地模型

只要在阿里云给自己的示例代码中稍加改动

将base_url改为：http://localhost:11434/v1
将model改为对应本地模型名称，如：qwen3：4b

之后再调试运行即可。

openai库的基础使用

01

什么是OpenAI

openai库是openAI官方推出的Python SDK，核心作用是让开发者能简单，高效地调用OpenAI的各类API，无需手动处理HTTP请求，身份验证等底层细节。

其发布较早且易于使用，现如今很多模型服务商都兼容OpenAI SDK的使用。

对OpenAI库的使用分为三个流程，分别为

获取客户端对象
调用模型
处理结果

获取客户端对象

1
2
3
4
5
6
7


from openai import OpenAI


client:OpenAI = OpenAI{
 api_key=""
 base_url=""
}

主要是用如上两个参数：

api_key：模型服务商提供的APIKEY密钥
base_url：模型服务商的API接入地址
- 主要基于此参数来切换不同的模型服务商（如OpenAI、阿里云、腾讯云等）。

调用模型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


from openai.types.chat.chat_completion import ChatCompletion

response:ChatCompletion - client.chat.completions.create(

 model="qwen3_max",

 messages=[

 {"role":"system","content":"你是一个ai。"},
 {"role":"assistant","content":"我是ai，请问有什么可以帮助你的吗？"},
 {"role":"user","content":"for循环输出1-5的数字"},

 ]
)

client.chat.completions.create 创建ChatCompletion对象

主要参数有两个：

model：选择所用模型
messages：提供给模型的信息
- 类型：list，可以包含多个字典消息
- 每个字典消息包含2个key
  - role：角色
  - content 内容
system角色：设定助手的整体行为、角色和规则，为对话提供上下文框架，是全局的背景设定，影响后续所有交互
assistant角色：代表AI助手的回答，可以在代码中认为设定
user角色: 代表用户有，发送问题、指令或需求

处理结果

response变量就是ChatCompletion对象，其包含信息如下所示

 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


{
 "id":"chatcmpl-xxxx",

 "object":"chat.completion",

 "created":"1735689600",

 "model":"gpt-3.5-turbo-0125",

 "choices":[
 {
 "index": 0,
 "message":{
 "role": "assistant",
 "content":"生成回复的内容"
 },
 "finish_reason": "stop" # stop=正常结束，length=令牌数超限，function_call=触发函数调用
 }
 ],
"usage":{ #令牌消耗统计 
 "prompt_tokens":50,
 "completion_tokens":80,
 "total_tokens":130

 }
}

可以通过print(response.choices[0].message.contene)输出模型给出的回答信息

尝试编写

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


from openai import OpenAI
# 1.获取client对象，openai类对象
client = OpenAI(
 base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
# 2.调用模型
response = client.chat.completions.create(
 model="qwen3-max",
 messages=[
 {"role":"system","content":"你是一个Python专家，并且不说废话简单回答"},
 {"role": "assistant", "content": "好的，我是Python编程专家，并且话不多，你要问什么？"},
 {"role": "user", "content": "输出1-10的数字，使用python代码"},

 ]
)
# 3.输出结果
print(response.choices[0].message.content)

02

openai库的流式输出

可以设定结果输出为Stream（流式输出），以获取更好的使用体验。开启流式输出主要就两步

在client.chat.completions.create()调用模型的时候设定参数：stream=True。
for循环response对象，并在循环内输出内容。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


from openai import OpenAI
# 1.获取client对象，openai类对象
client = OpenAI(
 base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
# 2.调用模型
response = client.chat.completions.create(
 model="qwen3-max",
 messages=[
 {"role":"system","content":"你是一个Python专家，并且话非常多"},
 {"role": "assistant", "content": "好的，我是Python编程专家，并且话不多，你要问什么？"},
 {"role": "user", "content": "输出1-10的数字，使用python代码"},

 ],
 stream = True # 开启流式输出功能
)
# 3.输出结果
for chunk in response:
 if chunk.choices[0].delta.content:
 print(chunk.choices[0].delta.content,
 end=" ",
 flush=True # 立刻刷新缓冲区
 )

03

openai库附带历史消息调用模型

调用模型传入的参数messages，其要求是list对象，即表明其支持非常多的消息在内。

我们可以基于此，将历史消息填入，让模型知晓对话的上下文，更好的回答。

 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


from openai import OpenAI
# 1.获取client对象，openai类对象
client = OpenAI(
 base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
# 2.调用模型
response = client.chat.completions.create(
 model="qwen3-max",
 messages=[
 {"role":"system","content":"你是一个ai助理，且回答很简洁"},
 {"role": "assistant", "content": "好的，我是ai助理，并且话不多，你要问什么？"},
 {"role": "user", "content": "小明有两条宠物狗"},
 {"role": "assistant", "content": "好的"},
 {"role": "user", "content": "小红有三只宠物猫"},
 {"role": "assistant", "content": "好的"},
 {"role": "user", "content": "总共有几个宠物"},

 ],
 stream = True # 开启流式输出功能
)
# 3.输出结果
for chunk in response:
 if chunk.choices[0].delta.content:
 print(chunk.choices[0].delta.content,
 end=" ",
 flush=True # 立刻刷新缓冲区
 )

ps ：当前的历史消息是一次性的，如果是生产系统可以将消息保存到文件，数据库等持久化工具内，需要的时候提取使用

后续学习LangChain库，会学习短期记忆和长期记忆的使用方法。