Appearance

LangChain教程 - 7 LangChain调用大模型 ​

下面正式进入 LangChain 的学习，学习 LangChain 提供的各种功能。


7.1 安装LangChain ​

首先创建一个 Python 项目，这个就不说了。

然后就是安装 LangChain，安装很简单，在项目下执行如下指令就可以了：

bash
pip install langchain langchain-community langchain-ollama dashscope chromadb langchain-chroma

各个依赖包的作用：

  • langchain：核心框架包，负责流程组织，比如 Prompt 管理、Chain 执行、Agent 结构等。

  • langchain-community：社区扩展包，用来接入各种第三方模型（比如阿里云通义千问），没有它就没法方便地调用外部模型。

  • langchain-ollama：用于支持 Ollama 本地模型调用，如果你跑本地大模型，需要安装它。

  • dashscope：阿里云通义千问的官方 Python SDK，真正向阿里云发送请求、拿回结果，底层靠它完成。

  • chromadb：一个轻量级向量数据库，用来做知识库存储和相似度检索，后面做 RAG 会用到。

  • langchain-chroma：LangChain 操作 Chroma 向量数据库的独集成包。

现在 LangChain 已经安装好了，下面开始介绍 LangChain 的使用。

7.2 LangChain调用大语言模型 ​

现在市面上的模型越来越多，各种厂商、各种能力。LangChain 为了解决“模型太多不好统一”的问题，提供了统一的模型接口。

目前主要支持三种模型类型：

  • LLMs（大语言模型）

LLM 是“大语言模型”的统称，是一个技术概念。它们通常基于 Transformer 架构，通过海量文本数据训练得到，核心能力是理解和生成自然语言。你可以把它理解为一个“文本生成引擎”：给它一段文本，它会根据上下文继续往下写。写文章、做总结、翻译文本、生成代码，这些都属于它的典型使用场景。

  • Chat Models（聊天模型）

在 LLM 的基础上，又衍生出 Chat Model，也就是聊天模型。聊天模型本质上还是 LLM，是应用范畴的细分，只是专门针对“对话场景”进行了优化。它不再只是单纯接收一段文本，而是接收带有角色结构的对话内容，比如 system、user、assistant。它更擅长处理多轮对话，能够在上下文中持续交流。所以我们平时做 AI 助手、客服机器人，其实用的都是 Chat Model。

  • Embeddings Models（嵌入模型）

最后是 Embedding Model，也就是嵌入模型。它和前两类模型完全不同。它不负责生成文本，而是把文本转换成向量。这个向量可以理解为“文本的数字表示”。有了向量，我们就可以计算相似度、做语义搜索、实现知识库问答。后面讲 RAG 的时候，你会发现嵌入模型是整个流程的核心基础。

简单来说，三类模型的区别在于输出形式不同：

  • LLM 输出的是文本
  • Chat Model 输出的是对话回复
  • Embedding Model 输出的是向量

在实际开发中，根据你要做的是“生成内容”、“对话交互”、“语义检索”，选择对应的模型即可。

1 调用千问模型 ​

先看一下如何调用 qwen3-max 模型。

python
# 需要借助 langchain_community 库，它提供了很多第三方模型的封装
from langchain_community.llms.tongyi import Tongyi

# 初始化 Tongyi 模型，需要注意，模型名称为 qwen-max，不是 qwen3-max，因为qwen3-max是聊天模型
model = Tongyi(model="qwen-max")

# 调用模型，通过 invoke 方法提问
response: str = model.invoke("你是谁")
print(response)
  • 代码非常的简单，直接初始化模型，然后调用 invoke() 方法就可以了，调用后可以直接拿到结果。
  • 这里需要注意，环境变量中需要配置 DASHSCOPE_API_KEY 。


2 调用本地Ollama模型 ​

同样，调用本地 Ollama 部署的模型也是差不多：

python
from langchain_ollama import OllamaLLM

# 初始化 Ollama 模型
model = OllamaLLM(model="qwen3:0.6b")

# 调用模型
response: str = model.invoke("你是谁，简单的回答")
print(response)
  • 同样简单，只是使用了不同的模型类而已，直接运行即可。

3 使用流式访问千问模型 ​

上面的 invoke 方法是一次性返回完整结果，需要等待较久。

下面使用流式返回，分段返回，调用 stream() 方法即可。

python
# 需要借助 langchain_community 库，它提供了很多第三方模型的封装
from langchain_community.llms.tongyi import Tongyi
from typing import Iterator

# 初始化 Tongyi 模型，需要注意，模型名称为 qwen-max，不是 qwen3-max，因为qwen3-max是聊天模型
model = Tongyi(model="qwen-max")

# 调用模型，通过 stream 方法提问
response: Iterator[str] = model.stream("你是谁")
for chunk in response:
    print(chunk, end="", flush=True)  # end="" 避免换行，flush=True 及时刷新输出
  • 通过 stream 拿到 response，然后不停的遍历 chunk 即可。

4 使用流式访问Ollama模型 ​

调用 Ollama 也是一样的，使用 stream 方法，使用方式是一样的：

python
from langchain_ollama import OllamaLLM
from typing import Iterator

# 初始化 Ollama 模型
model = OllamaLLM(model="qwen3:0.6b")

# 调用模型，通过 stream 方法提问，是一样的
response: Iterator[str] = model.stream("你是谁")
for chunk in response:
    print(chunk, end="", flush=True)  # end="" 避免换行，flush=True 及时刷新输出
  • 只是使用的模型类不同，使用 OllamaLLM 类。

7.3 LangChain调用聊天模型 ​

前面调用的是 LLM（文本模型），只有一个字符串输入。

聊天模型（Chat Model）不一样，它是基于角色的对话模型，输入的是一组消息（messages），每条消息都有角色和对应的消息类型。

消息类型有如下几种：

  • SystemMessage：设定大模型规则、身份、行为方式，和之前 OpenAI 库的 system 对应；
  • HumanMessage：表示用户输入的内容，和 OpenAI 库中的 user 对应；
  • AIMessage：表示模型输出的内容，和 OpenAI 库中的 assistant 对应。

1 调用千问聊天模型 ​

下面直接使用 LangChain 调用千问的 qwen3-max 聊天模型（ qwen3-max 是聊天模型）；

python
# 需要借助 langchain_community 库
from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage

# 初始化聊天模型
model = ChatTongyi(model="qwen3-max")

# 构造带角色的消息
messages = [
    SystemMessage(content="你是一个幽默的助手"),
    HumanMessage(content="你是谁")
]

# 调用模型，通过 stream 方法提问，流式返回
response = model.stream(input = messages)
for chunk in response:
    print(chunk.content, end="", flush=True)  # end="" 避免换行，flush=True 及时刷新输出
  • 和 LLM 不同，这里使用的是 ChatTongyi ；
  • 传入的不是字符串，而是一个 messages 列表；返回的是 AIMessage 对象，需要 .content 取内容；
  • 同样需要在环境变量中，提前配置 DASHSCOPE_API_KEY 。

这里调用的是 stream() 方法，使用的是流式返回，如果是一次性返回，可以调用 invoke() 方法，通过 response.content 属性就可以一次性获取到所有的结果。

2 调用本地Ollama聊天模型 ​

调用本地 Ollama 部署的聊天模型也是类似，可以传递历史会话记录：

python
from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage

# 初始化聊天模型
model = ChatOllama(model="qwen3:0.6b")

# 构造消息
messages = [
    SystemMessage(content="请用一句话回答"),
    HumanMessage(content="3加5等于多少？"),
    AIMessage(content="等于8"),
    HumanMessage(content="再加5等于多少？"),
    AIMessage(content="等于13"),
    HumanMessage(content="再加2等于多少？")
]

# 调用模型，通过 stream 方法提问，流式返回
response = model.stream(input = messages)
for chunk in response:
    print(chunk.content, end="", flush=True)  # end="" 避免换行，flush=True 及时刷新输出
  • 和刚才几乎一样，只是模型类换成了 ChatOllama ；
  • 使用方式和 OpenAI 也基本一样。

这也是 LangChain 的优点 —— 统一接口，不同模型同样的调用方式。

7.4 LangChain调用文本嵌入模型 ​

前面的大语言模型和聊天模型都是生成式模型，核心能力是根据输入内容，生成新的文本输出。

而文本嵌入模型（Embedding Model）不生成文本，它的作用是：把一段文本转换成一串数字向量（vector），也就是将文本向量化。

这个向量可以用来做：

  • 语义搜索
  • 相似度计算
  • 向量数据库存储
  • RAG（检索增强生成）

举个简单例子：

"人工智能"

经过嵌入模型后会变成：

[0.0123, -0.9932, 0.8271, ...]

这是一串高维数字（比如 1024 维、1536 维等），向量越接近，语义越相似。

1 调用千问文本嵌入模型 ​

在阿里云百炼平台中，千问提供了嵌入模型，比如：

  • text-embedding-v3

在 LangChain 中可以这样调用：

python
# 需要借助 langchain_community 库
from langchain_community.embeddings import DashScopeEmbeddings

# 初始化嵌入模型，如果不传递模型，默认使用的是text-embedding-v1
embeddings = DashScopeEmbeddings(
    model="text-embedding-v3"
)

# 将文本转换为向量
vector = embeddings.embed_query("人工智能是什么？")

print(len(vector))     # 查看向量维度，1024
print(vector[:10])     # 查看前10个数值
  • 使用的是 DashScopeEmbeddings 类创建模型，返回的是一个 Python 列表（list）。
  • 每个元素是一个浮点数，也需要提前配置环境变量 DASHSCOPE_API_KEY 。

在同一个嵌入模型下，不管输入文本多长，输出向量的维度都是固定的。text-embedding-v3 是1024维度的，所以上面使用 text-embedding-v3 模型计算得到的结果都是 1024。

2 批量嵌入 ​

上面使用的是 embed_query() 转换的是单个文本。还可以使用 embed_documents() 方法进行批量转换：

python
# 需要借助 langchain_community 库
from langchain_community.embeddings import DashScopeEmbeddings

# 初始化嵌入模型，如果不传递模型，默认使用的是text-embedding-v1
embeddings = DashScopeEmbeddings(
    model="text-embedding-v3"
)

# 文本
texts = [
    "人工智能",
    "机器学习",
    "深度学习"
]

# 批量转换
vectors = embeddings.embed_documents(texts)
print(len(vectors))      # 3格文本数量
print(len(vectors[0]))   # 每个向量的维度
print(len(vectors[0][:10]))   # 取第一个向量的前10个数值
  • 得到的结果相当于二维数组。

3 调用本地Ollama嵌入模型 ​

如果你使用本地 Ollama，也可以调用嵌入模型。

我们可以在 Ollama 官网的模型中，搜索一下 Embedding 模型，表示嵌入式模型：

这里我选择 qwen3-embedding 进行部署：

docker exec -it my-ollama ollama run qwen3-embedding:0.6b
  • 还有一些轻量级但效果不错的嵌入模型，例如 nomic-embed-text ，可以尝试一下。

然后使用如下代码调用：

python
from langchain_ollama import OllamaEmbeddings

# 初始化本地嵌入模型
embeddings = OllamaEmbeddings(
    model="qwen3-embedding:0.6b"
)

# 单条嵌入
vector = embeddings.embed_query("人工智能是什么？")

print(len(vector))
print(vector[:10])
  • 调用 Ollama 中部署的嵌入模型，使用 OllamaEmbeddings 。

如果是批量嵌入，也使用 embed_documents() 方法：

python
texts = [
    "人工智能",
    "机器学习",
    "深度学习"
]

vectors = embeddings.embed_documents(texts)
print(len(vectors))      # 3格文本数量
print(len(vectors[0]))   # 每个向量的维度
print(len(vectors[0][:10]))   # 取第一个向量的前10个数值

通过调用嵌入式模型，我们就将文本数据转换为向量数据了，后面我们会学习如何将向量数据保存到数据库，以及从向量数据库检索数据。