企业官网建设流程全解析

前言

对于LangChain，它是一个用于开发由LLM驱动的应用程序的框架。
LangChain框架是通过将自然语言处理流程拆解为标准化组件，让开发者能够自由组合并高效定制工作流。

接下来演示如何使用LangChain接入大模型组件，以及与大模型进行简单对话的能力。

步骤1：申请 API key 并配置环境变量

1.1申请api

以 OpenAI 为例，官⽹地址：https://platform.openai.com/

点击 “Create new secret key” 按钮，新增 API key：

将APIKey在自己本地保存好，后续接入ChatGPT时需要使用

1.2 配置环境变量

将API key配置在环境变量中，主要是为了保证其隐私性。为避免在程序中暴露，可提前将各个配置在环境变量中，这样在程序中就可以通过获取对应环境变量拿到API key，保证了API key的隐私。

步骤2：定义大模型

2.1 装 OpenAI 包

pip install -U langchain-openai

langchain-openai这个包，是 LangChain 和 OpenAI（兼容 OpenAI 接口）大模型之间的适配器，没有它，LangChain 不知道怎么调用 ChatOpenAI。

这个包里面封装了：

1. ChatOpenAI聊天模型类（就是代码里导入的）
2. 底层对接 OpenAI 官方 SDK（openai 包）的逻辑
3. 适配 LangChain 标准消息格式（HumanMessage、SystemMessage）
4. 适配 LCEL 管道语法（model | parser这种写法）

注意

1、 旧版 LangChain 是把 ChatOpenAI 放在 langchain 主包里，新版拆分出来，必须单独装 langchain-openai，否则from langchain_openai import ChatOpenAI会报ModuleNotFoundError。

2、在 anaconda 环境下，要先激活环境，再执行 pip：

# 激活你的环境 conda activate li_3_8 # 再执行安装 pip install -U langchain-openai

3、只要平台提供OpenAI 兼容接口，就继续用ChatOpenAI，只改base_url、api_key、model：

• 阿里通义千问 DashScope
• DeepSeek 深度求索
• 智谱 GLM（兼容模式）
• 月之暗面 Kimi（兼容接口）
• 各类中转 API

如果厂商不兼容 OpenAI 接口，有自己独立协议，需要安装对应 langchain 适配器包，例如

1、Anthropic Claude pip install langchain-anthropic 2、阿里原生接口（非兼容模式，langchain-aliyun） pip install langchain-aliyun 3、Google Gemini pip install langchain-google-genai

2.2 导入ChatOpenAI这个类

from langchain_openai import ChatOpenAI

ChatOpenAI：类（Class）用来创建聊天大模型实例的模板。

这个类封装好了：网络请求、消息格式转换、和大模型 API 通信的全套逻辑。

导入之后：Python 认识ChatOpenAI这个模板，你就可以实例化模型。你才能写这一句：

model = ChatOpenAI(...)

model就是根据ChatOpenAI这个模板，新建出来的大模型对象。

init_chat_model () 工厂函数

ChatOpenAI是固定厂商的具体类；

init_chat_model是工厂函数，一套代码，切换多家大模型。

工厂函数提供统一入口，只需要传入模型名、厂商名称，就能自动创建对应聊天模型实例（可以是 OpenAI、Anthropic、DeepSeek、Ollama 等），不用手动 import 每个模型的类，只修改model和model_provider，业务代码完全不变

# 导入方式 from langchain.chat_models import init_chat_model #参数 model = init_chat_model( model="gpt-4o-mini", # 模型名称，如gpt-4o-mini、deepseek-chat model_provider="openai", # 模型厂商：openai / anthropic / deepseek / ollama api_key="sk-xxx", base_url="", temperature=0.7 configurable_fields=None, config_prefix=None, )

# 返回 langchain_openai.ChatOpenAI 实例 gpt_model = init_chat_model("gpt-5-mini", model_provider="openai",temperature=0) # 返回 langchain_deepseek.ChatDeepSeek 实例 deepseek_model = init_chat_model("deepseek-chat", model_provider="deepseek",temperature=0)

可配置模型（init_chat_model+configurable_fields）

通过configurable_fields和config_prefix，可以在调用invoke()时，通过config参数动态覆盖模型配置，实现同一模型实例，每次请求使用不同参数。

# 可配置模型模拟器 configurable_model = init_chat_model( model="gpt-5-mini", model_provider="openai", temperature=0, configurable_fields=("model", "model_provider", "temperature", "max_tokens"), config_prefix="first", #前缀first ) # 动态修改配置，invoke时临时覆盖参数 configurable_result = configurable_model.invoke( "what's your name?", config={ "configurable": { "first_model": "deepseek-chat", "first_temperature": 0.5, "first_max_tokens": 100, } }, ) print("configurable2: " + configurable_result.content + "\n")

1. configurable_fields 声明哪些参数允许在 invoke 时动态修改。 这里写了：model、model_provider、temperature、max_tokens 只有写在这个元组里的字段，才能在config中动态覆盖。
2. config_prefix="first" 设置参数前缀。所以 config 里面 key 必须写成 first_model，而不是直接写model

执行逻辑：

1、创建configurable_model，默认是 gpt-5-mini，temperature=0

2、调用.invoke(..., config={...}) ，LangChain 读取configurable里的first_xxx，临时替换：

model → deepseek-chat

temperature →0.5

max_tokens →100

使用新参数执行本次请求

2.3实例化大模型

# 调用 `ChatOpenAI` 这个类（模板），创建一个模型实例对象，变量名叫 `model`。 model = ChatOpenAI(model="gpt-4o-mini", api_key="sk-xxx", base_url="xxx")

参数解释

1. model="gpt-4o-mini"， model参数指定要调用的模型名称。
2. api_key="sk-xxx"， API 密钥，用来身份认证。
3. base_url="xxx"，API 接口地址，告诉代码往哪个网址发送请求。
4. timeout ，请求超时时间，超过该时间则终止本次请求
5. max_retries ，最大重试次数，请求失败时自动重试多少次
6. max_tokens ，要生成的最大令牌数，限制模型输出 token 上限
7. temperature ，采样温度，温度值越高，AI 回答越天马行空；温度越低，回答越保守靠谱。取值范围一般 0~2
8. organization ，OpenAI 组织 ID。如果未传入，将从环境变量OPENAI_ORG_ID读取

• OpenAI 官方：默认不用写，base_url自动是https://api.openai.com/v1
• 通义 DashScope 必须写：base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"

DeepSeek（兼容 OpenAI 接口）ChatOpenAI 定义写法

import os OPENAI_API_KEY = os.getenv('OPENAI_API_KEY') from langchain_openai import ChatOpenAI model = ChatOpenAI( base_url="https://api.deepseek.com/v1", openai_api_key=OPENAI_API_KEY, model="deepseek-chat", # ... )

步骤3：定义消息列表

3.1 导入消息对象类

from langchain_core.messages import HumanMessage, SystemMessage

从langchain_core核心包，导入两种消息对象类：

• SystemMessage：系统消息，用来给大模型设定角色、任务、规则。
• HumanMessage：用户消息，代表人类用户的提问 / 输入内容。

大模型接口要求输入是消息数组，不是单纯字符串，所以要用这两个类封装内容。

3.2 编写 messages 消息列表

messages = [ SystemMessage(content="Translate the following from English into Chinese"), HumanMessage(content="hi!"), ]

• SystemMessage(content="Translate the following from English into Chinese")系统指令：把后面英文翻译成中文。 模型读到这条，就知道接下来要执行翻译任务。
• HumanMessage(content="hi!")用户输入内容：hi!，也就是需要翻译的原文。

关键点

✅ 消息是一个列表，可以放多条消息，做多轮对话

✅ SystemMessage 写在列表最前面，优先被模型读取

✅content是消息里面存放文本内容的参数

编写好messages之后，我们会把这个messages直接交给模型调用

步骤4：调用大模型

要简单地调用模型，我们可以将消息列表传递给.invoke方法
使用model的.invoke方法进行大模型调用

result = model.invoke(messages) print(result)

4.1 model.invoke(messages)

• model：前面创建好的大模型实例对象
• .invoke()：LangChain 里执行调用的方法，把消息发给大模型 API，等待模型返回结果
• messages：准备好的消息列表（SystemMessage + HumanMessage）

result是什么？

result不是普通字符串，是一个AIMessage对象（模型返回的消息对象），里面包含很多信息：

• content：模型输出的文本（我们最关心的回答内容）
• response_metadata：元数据（token 消耗、模型名称、请求耗时等）
• id、usage等附加字段

print (result) 会输出完整 AIMessage 对象

content='你好!' additional_kwargs={'refusal': None} response_metadata= {'token_usage': {'completion_tokens': 2, 'prompt_tokens': 20, 'total_tokens': 22, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-5-mini-2024-07-18', 'system_fingerprint': 'fp_560af6e559', 'id': 'chatcmpl-C5l29mi6KkQSFO3qaElDJD5Lj9nBn', 'service_tier': 'default', 'finish_reason': 'stop', 'logprobs': None} id='run--777ef0be-55c2-411a-a4ab- 104a45c22f20-0' usage_metadata={'input_tokens': 20, 'output_tokens': 2,'total_tokens': 22, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}}

可以看到除了回答文字，还有一大堆额外信息。

如果你只想拿到纯文本回答，用.content属性，只提取回答文本：

print(result.content) # 输出：你好！

4.2 AIMessage对象

AIMessage：大模型返回的消息对象，里面打包了回答文本 + 各类附加信息。

一句话快速区分 content：✅ AI 说的文字答案（日常开发 90% 只需要这个） additional_kwargs：🛠️ 工具调用参数（只有用到函数调用时才有内容） response_metadata：📋 请求的日志信息（查请求 id、排错用） usage_metadata：💰 token 消耗账单（统计用量、计费）

步骤5：解析器 输出解析

5.1 导入StrOutputParser这个类

# 从 langchain 核心包导入字符串输出解析器。 from langchain_core.output_parsers import StrOutputParser

5.2 实例化解析器

StrOutputParser 作用：接收 AIMessage，提取 content，输出纯字符串

# 实例化解析器对象 parser = StrOutputParser()

5.3 调用解析器

# result是前面返回的 **AIMessage 对象** # .invoke() 执行解析逻辑：接收 AIMessage 对象，取出.content，返回纯字符串。 print(parser.invoke(result))

print(parser.invoke(result)) 和 print(result.content) 打印结果完全一样。

步骤6：链式执行

通过上述步骤，无论是调用大模型，还是输出解析，我们发现，每次都调用了一个invoke()方法，最终才会得到我们想要的结果。

对于 LangChain，它给我们提供了链式执行的能力，即我们只需要定义各个 “组件”，将它们 “链起来”，一次性执行即可得到最终效果。

Runnable 接口：Runnable 是 LangChain 所有组件的统一标准接口，是 LCEL 链式编程的基础。

由Runnable 定义的 5 大能力

1. Invoke（单次调用）：单个输入 → 转换得到输出
2. Batch（批处理）：一次性传入多组输入，批量计算输出
3. Stream（流式传输）：边生成结果，边一段一段返回（打字机效果）
4. Inspect（检查）：查看组件的输入、输出、配置信息，用于调试
5. Composed（组合）：多个 Runnable 可以用 |（LCEL）拼接组合，形成流水线链

LangChain 里所有可执行组件（Runnable，可运行对象）都拥有 .invoke() 方法。

• ChatOpenAI 模型对象是 Runnable → model.invoke(messages)
• StrOutputParser 解析器是 Runnable → parser.invoke(ai_message)
• 用|拼接成的整条链chain = model | parser，整条链本身也还是一个 Runnable → chain.invoke(messages)

核心：只要是 Runnable，就用.invoke(输入)触发执行。

6.1 LCEL 链式（只调用 1 次 invoke）

# 把两个组件链起来 chain = model | parser # 只调用一次invoke，整条流水线自动跑完 result = chain.invoke(messages)

LCEL 作用：用声明式写法，基于已有的Runnable对象，构建出新的Runnable对象。

| 就是把多个 Runnable 组件串联，组成一条新的 Runnable 链。

输入传给第一个组件；前一个组件的输出，自动作为后一个组件的输入，不用手动传变量。

组件 + 链式执行 的含义

• 组件：模型、消息解析器、提示模板等独立单元，每个组件只负责一件事。
  • ChatOpenAI组件：负责调用大模型 API
  • StrOutputParser组件：负责提取文本
• 链起来（LCEL 管道|）：把多个独立组件拼接成流水线。
• 一次性执行：只需要调用一次chain.invoke()，自动按顺序走完所有组件。

RunnableSequence（可运行序列）

使用 | 管道符把多个 Runnable 拼接，生成的新对象叫做 RunnableSequence，也就是我们说的链（chain）。

RunnableSequence 本身也是 Runnable 接口的实例，它继承了 Runnable 全部能力（invoke /batch/stream/inspect/compose），因此，使用方式和普通 Runnable 完全一样。

6.2 完整代码参考

from langchain_openai import ChatOpenAI from langchain_core.messages import HumanMessage, SystemMessage from langchain_core.output_parsers import StrOutputParser # 定义大模型 model = ChatOpenAI(model="gpt-4o-mini") # 定义消息列表 messages = [ SystemMessage(content="Translate the following from English into Chinese"), HumanMessage(content="hi!"), ] # 定义输出解析器 parser = StrOutputParser() # 定义链 chain = model | parser # 执行链 result = chain.invoke(messages) print(result)

通过本地部署的 LLM 定义聊天模型

# 若想使⽤ ChatOllama，需要先安装 Ollama 包： pip install -U langchain_ollama

from langchain_ollama import ChatOllama # 初始化Ollama模型实例 ollama_model = ChatOllama( model="deepseek-r1:70b", base_url='http://192.168.100.220:11434' ) # 调用模型，传入用户提问 result = ollama_model.invoke("what's your name?") print(result)