模型（Models） #
模型是 LangChain 应用的核心组件，负责与各种大语言模型交互。LangChain 提供了统一的接口，让你可以轻松切换不同的模型提供商。
模型类型概览 #
text
┌─────────────────────────────────────────────────────────────┐
│ LangChain 模型类型 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Chat Models（聊天模型） │ │
│ │ │ │
│ │ - 多轮对话支持 │ │
│ │ - 系统提示、用户消息、AI 消息 │ │
│ │ - 支持多模态（图像、音频） │ │
│ │ - 例：GPT-4, Claude, Gemini │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ LLMs（文本补全模型） │ │
│ │ │ │
│ │ - 单轮文本生成 │ │
│ │ - 字符串输入输出 │ │
│ │ - 传统补全任务 │ │
│ │ - 例：GPT-3, LLaMA │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Embeddings（嵌入模型） │ │
│ │ │ │
│ │ - 文本向量化 │ │
│ │ - 语义相似度计算 │ │
│ │ - 用于检索、聚类 │ │
│ │ - 例：text-embedding-3-small │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
聊天模型（Chat Models） #
聊天模型是现代 LLM 应用中最常用的模型类型，支持结构化的多轮对话。
基本使用 #
python
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
# 创建模型实例
model = ChatOpenAI(
model="gpt-4o-mini",
temperature=0.7
)
# 单轮对话
response = model.invoke([HumanMessage(content="你好！")])
print(response.content)
消息类型 #
python
from langchain_core.messages import (
SystemMessage, # 系统消息：设定 AI 的行为
HumanMessage, # 用户消息：用户的输入
AIMessage, # AI 消息：AI 的回复
ChatMessage, # 自定义角色消息
FunctionMessage, # 函数调用结果
ToolMessage, # 工具调用结果
)
messages = [
SystemMessage(content="你是一个 Python 专家"),
HumanMessage(content="什么是装饰器？"),
AIMessage(content="装饰器是 Python 的一种语法糖..."),
HumanMessage(content="能举个例子吗？"),
]
response = model.invoke(messages)
text
┌─────────────────────────────────────────────────────────────┐
│ 消息类型说明 │
├─────────────────────────────────────────────────────────────┤
│ │
│ SystemMessage │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 设定 AI 的角色和行为 │ │
│ │ 例："你是一个专业的技术顾问" │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ HumanMessage │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 用户的输入 │ │
│ │ 例："如何优化 SQL 查询？" │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ AIMessage │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ AI 的回复 │ │
│ │ 例："优化 SQL 查询可以从以下几个方面入手..." │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
模型参数 #
python
model = ChatOpenAI(
model="gpt-4o-mini",
temperature=0.7,
# 控制输出的随机性
# 0: 确定性输出，每次相同
# 1: 高随机性，更有创造性
# 推荐：代码生成 0.2，创意写作 0.7-1.0
max_tokens=1000,
# 最大输出 token 数
top_p=0.9,
# 核采样参数
frequency_penalty=0.0,
# 频率惩罚，减少重复
presence_penalty=0.0,
# 存在惩罚，鼓励多样性
timeout=30,
# 请求超时时间（秒）
max_retries=2,
# 失败重试次数
api_key="your-key",
# API Key（可选，默认从环境变量读取）
base_url="https://api.openai.com/v1",
# API 端点（可选，用于自定义端点）
)
流式输出 #
python
# 同步流式
for chunk in model.stream("讲一个故事"):
print(chunk.content, end="", flush=True)
# 异步流式
async for chunk in model.astream("讲一个故事"):
print(chunk.content, end="", flush=True)
批量处理 #
python
# 批量调用
responses = model.batch([
[HumanMessage(content="什么是 Python？")],
[HumanMessage(content="什么是 JavaScript？")],
[HumanMessage(content="什么是 Go？")],
])
for response in responses:
print(response.content)
print("-" * 40)
异步调用 #
python
import asyncio
async def main():
# 异步调用
response = await model.ainvoke([HumanMessage(content="Hello")])
print(response.content)
# 异步批量
responses = await model.abatch([
[HumanMessage(content="Hi")],
[HumanMessage(content="Hey")],
])
asyncio.run(main())
多模态支持 #
现代聊天模型支持图像、音频等多种输入类型。
图像输入 #
python
from langchain_core.messages import HumanMessage
import base64
# 方式一：使用 URL
message = HumanMessage(
content=[
{"type": "text", "text": "这张图片里有什么？"},
{"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
]
)
# 方式二：使用 Base64
with open("image.png", "rb") as f:
image_data = base64.b64encode(f.read()).decode()
message = HumanMessage(
content=[
{"type": "text", "text": "描述这张图片"},
{"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_data}"}}
]
)
response = model.invoke([message])
text
┌─────────────────────────────────────────────────────────────┐
│ 多模态消息结构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ HumanMessage( │
│ content=[ │
│ { │
│ "type": "text", │
│ "text": "这张图片里有什么？" │
│ }, │
│ { │
│ "type": "image_url", │
│ "image_url": { │
│ "url": "https://..." │
│ } │
│ } │
│ ] │
│ ) │
│ │
└─────────────────────────────────────────────────────────────┘
不同模型提供商 #
OpenAI #
python
from langchain_openai import ChatOpenAI
model = ChatOpenAI(
model="gpt-4o", # 或 gpt-4o-mini, gpt-4-turbo
temperature=0.7
)
# 可用模型：
# - gpt-4o: 最新多模态模型
# - gpt-4o-mini: 轻量级版本
# - gpt-4-turbo: GPT-4 增强版
# - gpt-3.5-turbo: 经济选择
Anthropic Claude #
python
from langchain_anthropic import ChatAnthropic
model = ChatAnthropic(
model="claude-sonnet-4-20250514",
temperature=0.7
)
# 可用模型：
# - claude-opus-4-20250514: 最强能力
# - claude-sonnet-4-20250514: 平衡性能
# - claude-3-5-haiku-20241022: 快速响应
Google Gemini #
python
from langchain_google_genai import ChatGoogleGenerativeAI
model = ChatGoogleGenerativeAI(
model="gemini-1.5-pro",
temperature=0.7
)
# 可用模型：
# - gemini-1.5-pro: 高级模型
# - gemini-1.5-flash: 快速模型
# - gemini-pro: 标准模型
本地模型（Ollama） #
python
from langchain_ollama import ChatOllama
model = ChatOllama(
model="llama3",
temperature=0.7
)
# 常用本地模型：
# - llama3: Meta Llama 3
# - mistral: Mistral AI
# - qwen2: 通义千问
# - deepseek-coder: 代码专用
Azure OpenAI #
python
from langchain_openai import AzureChatOpenAI
model = AzureChatOpenAI(
azure_deployment="your-deployment-name",
azure_endpoint="https://your-resource.openai.azure.com/",
api_version="2024-02-15-preview",
temperature=0.7
)
嵌入模型（Embeddings） #
嵌入模型将文本转换为向量，用于语义搜索、聚类等任务。
基本使用 #
python
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(
model="text-embedding-3-small"
)
# 单个文本
vector = embeddings.embed_query("Hello, world!")
print(f"向量维度: {len(vector)}") # 1536
# 多个文本
texts = ["Hello", "World", "LangChain"]
vectors = embeddings.embed_documents(texts)
print(f"生成了 {len(vectors)} 个向量")
相似度计算 #
python
import numpy as np
def cosine_similarity(v1, v2):
return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
# 计算相似度
text1 = "机器学习是人工智能的一个分支"
text2 = "深度学习是机器学习的一个分支"
text3 = "今天天气很好"
v1 = embeddings.embed_query(text1)
v2 = embeddings.embed_query(text2)
v3 = embeddings.embed_query(text3)
print(f"text1 vs text2: {cosine_similarity(v1, v2):.4f}") # 高相似度
print(f"text1 vs text3: {cosine_similarity(v1, v3):.4f}") # 低相似度
text
┌─────────────────────────────────────────────────────────────┐
│ 嵌入向量应用 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 文本 ───> Embeddings ───> 向量 [0.1, 0.2, ..., 0.9] │
│ │
│ 应用场景： │
│ │
│ 1. 语义搜索 │
│ 查询向量与文档向量比较，找到最相关内容 │
│ │
│ 2. 聚类分析 │
│ 将相似文本分组 │
│ │
│ 3. 推荐系统 │
│ 基于内容相似度推荐 │
│ │
│ 4. 异常检测 │
│ 找出与其他内容差异大的文本 │
│ │
└─────────────────────────────────────────────────────────────┘
不同嵌入模型 #
python
# OpenAI
from langchain_openai import OpenAIEmbeddings
openai_embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
# HuggingFace（本地）
from langchain_huggingface import HuggingFaceEmbeddings
hf_embeddings = HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2"
)
# Ollama（本地）
from langchain_ollama import OllamaEmbeddings
ollama_embeddings = OllamaEmbeddings(model="nomic-embed-text")
# Cohere
from langchain_cohere import CohereEmbeddings
cohere_embeddings = CohereEmbeddings(model="embed-english-v3.0")
函数调用 #
现代模型支持结构化输出和函数调用。
结构化输出 #
python
from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field
class Person(BaseModel):
name: str = Field(description="姓名")
age: int = Field(description="年龄")
hobbies: list[str] = Field(description="爱好")
model = ChatOpenAI(model="gpt-4o-mini")
# 使用 with_structured_output
structured_model = model.with_structured_output(Person)
result = structured_model.invoke("介绍一个虚构的人物")
print(result)
# Person(name='张三', age=25, hobbies=['编程', '阅读', '游泳'])
工具绑定 #
python
from langchain_core.tools import tool
@tool
def get_weather(city: str) -> str:
"""获取指定城市的天气"""
return f"{city}今天晴，温度 25°C"
@tool
def calculate(expression: str) -> float:
"""计算数学表达式"""
return eval(expression)
model = ChatOpenAI(model="gpt-4o-mini")
# 绑定工具
model_with_tools = model.bind_tools([get_weather, calculate])
# 调用
response = model_with_tools.invoke("北京今天天气怎么样？")
print(response.tool_calls)
# [{'name': 'get_weather', 'args': {'city': '北京'}, 'id': '...'}]
模型选择指南 #
text
┌─────────────────────────────────────────────────────────────┐
│ 模型选择建议 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 复杂推理任务： │
│ ✅ GPT-4o / Claude Opus │
│ - 数学推理 │
│ - 复杂分析 │
│ - 代码生成 │
│ │
│ 日常对话任务： │
│ ✅ GPT-4o-mini / Claude Sonnet │
│ - 客服对话 │
│ - 内容生成 │
│ - 信息提取 │
│ │
│ 高频简单任务： │
│ ✅ GPT-3.5-turbo / Claude Haiku │
│ - 简单问答 │
│ - 文本分类 │
│ - 格式转换 │
│ │
│ 隐私敏感场景： │
│ ✅ 本地模型 (Ollama) │
│ - 数据不外传 │
│ - 完全控制 │
│ │
└─────────────────────────────────────────────────────────────┘
最佳实践 #
1. 合理设置温度 #
python
# 代码生成 - 低温度
code_model = ChatOpenAI(model="gpt-4o-mini", temperature=0.2)
# 创意写作 - 高温度
creative_model = ChatOpenAI(model="gpt-4o-mini", temperature=0.8)
# 数据分析 - 零温度
analysis_model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
2. 控制输出长度 #
python
# 简短回复
brief_model = ChatOpenAI(model="gpt-4o-mini", max_tokens=100)
# 详细回复
detailed_model = ChatOpenAI(model="gpt-4o-mini", max_tokens=2000)
3. 错误处理 #
python
from openai import RateLimitError, APIError
try:
response = model.invoke("Hello")
except RateLimitError:
print("API 速率限制，请稍后重试")
except APIError as e:
print(f"API 错误: {e}")
4. 使用重试机制 #
python
# 自动重试
model = ChatOpenAI(
model="gpt-4o-mini",
max_retries=3,
timeout=60
)
# 或使用 with_retry
chain = model.with_retry(
stop_after_attempt=3,
wait_exponential_jitter=True
)
下一步 #
- 提示（Prompts） - 学习提示工程
- 链（Chains） - 构建复杂工作流
- 嵌入与向量存储 - 深入了解嵌入模型
最后更新：2026-03-30