LangChain聊天模型详解-优快云博客

LangChain聊天模型详解

在这里插入图片描述

概述

聊天模型是使用消息序列作为输入并返回聊天消息作为输出的语言模型（与使用纯文本的传统模型相对）。这些通常是较新的模型（较旧的模型通常是LLM）。聊天模型支持为对话消息分配不同的角色，有助于区分来自AI、用户和系统消息等指令的消息。

虽然底层模型是消息输入、消息输出，但LangChain包装器也允许这些模型接受字符串作为输入。这意味着您可以轻松地使用聊天模型来替代LLM。

当传入字符串作为输入时，它会被转换为HumanMessage，然后传递给底层模型。

核心功能

1. 消息处理 💬

支持多种消息类型（用户、助手、系统、工具消息）
自动处理消息格式转换
保持对话上下文和历史

2. 工具调用 🔧

支持函数/工具调用功能
结构化输出生成
与外部API和服务集成

3. 多模态支持 🎨

处理文本、图像、音频等多种数据类型
跨模态理解和生成
丰富的交互体验

4. 流式响应 ⚡

实时流式输出
降低响应延迟
改善用户体验

集成支持

LangChain支持众多聊天模型提供商的集成，包括：

OpenAI - GPT系列模型
Anthropic - Claude系列模型
Google - Gemini和PaLM模型
AWS - Bedrock平台模型
Azure - Azure OpenAI服务
Cohere - Command系列模型
Hugging Face - 开源模型
Ollama - 本地部署模型

更多集成信息请参考聊天模型集成文档。

接口规范

核心方法

所有聊天模型都实现了标准的Runnable接口，提供以下核心方法：

1. invoke() - 单次调用

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-3.5-turbo")
response = model.invoke("你好，世界！")
print(response.content)

2. batch() - 批量处理

messages_list = [
    "翻译这句话：Hello",
    "解释量子计算",
    "写一首关于春天的诗"
]
responses = model.batch(messages_list)
for response in responses:
    print(response.content)

3. stream() - 流式输出

for chunk in model.stream("请详细解释人工智能"):
    print(chunk.content, end="", flush=True)

4. astream() - 异步流式输出

import asyncio

async def async_stream_example():
    async for chunk in model.astream("解释机器学习"):
        print(chunk.content, end="", flush=True)

asyncio.run(async_stream_example())

输入和输出

输入类型

聊天模型可以接受以下输入类型：

字符串 - 自动转换为HumanMessage
消息列表 - 包含不同角色的消息序列
PromptValue - 来自提示模板的结构化输入

输出类型

聊天模型返回：

AIMessage - 包含模型响应的消息对象
工具调用 - 当模型决定调用工具时
结构化数据 - 使用结构化输出功能时

标准参数

LangChain为聊天模型定义了一组标准参数，以提供一致的接口：

参数	描述	示例值
`model`	要使用的特定AI模型的名称或标识符	“gpt-3.5-turbo”, “gpt-4”
`temperature`	控制模型输出的随机性。较高值（如1.0）使响应更有创意，较低值（如0.0）使其更确定和专注	0.0-1.0
`timeout`	等待模型响应的最大时间（秒），超时后取消请求	30, 60
`max_tokens`	限制响应中的总令牌数（单词和标点符号），控制输出长度	100, 1000
`stop`	指定停止序列，指示模型何时应停止生成令牌	[“\n”, “END”]
`max_retries`	由于网络超时或速率限制等问题导致请求失败时，系统重新发送请求的最大尝试次数	3, 5
`api_key`	与模型提供商进行身份验证所需的API密钥	“sk-…”
`base_url`	发送请求的API端点URL	“https://api.openai.com/v1”
`rate_limiter`	可选的速率限制器，用于控制请求频率以避免超出速率限制	BaseRateLimiter实例

重要说明：

标准参数仅适用于公开具有预期功能的参数的模型提供商
标准参数目前仅在具有自己集成包的集成上强制执行（如langchain-openai、langchain-anthropic等）
langchain-community中的模型不强制执行标准参数

使用示例

from langchain_openai import ChatOpenAI

# 基础配置
model = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.7,
    max_tokens=1000,
    timeout=30,
    max_retries=3
)

# 简单对话
response = model.invoke("解释什么是机器学习")
print(response.content)

# 使用消息列表
from langchain_core.messages import HumanMessage, SystemMessage

messages = [
    SystemMessage(content="你是一个有用的AI助手"),
    HumanMessage(content="请解释量子计算的基本概念")
]
response = model.invoke(messages)
print(response.content)

高级功能

1. 工具调用 🛠️

聊天模型可以调用工具来执行任务，如从数据库获取数据、发出API请求或运行自定义代码。

from langchain_core.tools import tool

@tool
def get_weather(city: str) -> str:
    """获取指定城市的天气信息"""
    # 这里是获取天气的逻辑
    return f"{city}的天气是晴天，温度25°C"

# 绑定工具到模型
model_with_tools = model.bind_tools([get_weather])

# 使用工具
response = model_with_tools.invoke("北京的天气怎么样？")
if response.tool_calls:
    tool_call = response.tool_calls[0]
    result = get_weather.invoke(tool_call["args"])
    print(result)

工具调用的优势：

扩展模型能力
访问实时数据
执行复杂操作
与外部系统集成

2. 结构化输出 📊

聊天模型可以被要求以特定格式（如JSON或匹配特定模式）响应。

from pydantic import BaseModel
from typing import List

class Person(BaseModel):
    name: str
    age: int
    occupation: str

class People(BaseModel):
    people: List[Person]

# 配置结构化输出
structured_model = model.with_structured_output(People)

response = structured_model.invoke(
    "请提供3个虚构人物的信息，包括姓名、年龄和职业"
)
print(response.people)

结构化输出的应用：

信息提取任务
数据标准化
API响应格式化
数据库存储准备

3. 多模态处理 🎭

大型语言模型不仅限于处理文本，还可以处理图像、音频和视频等其他类型的数据。

from langchain_core.messages import HumanMessage

# 处理图像输入
message = HumanMessage(
    content=[
        {"type": "text", "text": "这张图片中有什么？"},
        {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
    ]
)

response = model.invoke([message])
print(response.content)

多模态能力：

图像理解和描述
音频转录和分析
视频内容理解
跨模态推理

4. 上下文窗口管理 📏

聊天模型的上下文窗口是指模型一次可以处理的输入序列的最大大小。

上下文窗口的重要性：

决定模型能"记住"多少信息
影响对话的连贯性
需要合理管理以避免超出限制

管理策略：

from langchain.memory import ConversationBufferWindowMemory

# 使用窗口记忆管理上下文
memory = ConversationBufferWindowMemory(k=5)  # 保留最近5轮对话

# 在对话中使用
memory.save_context(
    {"input": "你好"},
    {"output": "你好！我是AI助手，有什么可以帮助你的吗？"}
)

高级主题

1. 速率限制处理 ⏱️

许多聊天模型提供商对给定时间段内可以发出的请求数量施加限制。

处理策略：

1. 避免触发速率限制

from langchain_core.rate_limiters import InMemoryRateLimiter

# 配置速率限制器
rate_limiter = InMemoryRateLimiter(
    requests_per_second=1,  # 每秒1个请求
    check_every_n_seconds=0.1,  # 每0.1秒检查一次
    max_bucket_size=10,  # 最大桶大小
)

model = ChatOpenAI(
    model="gpt-3.5-turbo",
    rate_limiter=rate_limiter
)

2. 从速率限制错误中恢复

model = ChatOpenAI(
    model="gpt-3.5-turbo",
    max_retries=5,  # 最大重试次数
    timeout=60  # 超时时间
)

3. 回退到其他模型

from langchain_core.runnables import RunnableLambda

def fallback_model(input_data):
    try:
        return primary_model.invoke(input_data)
    except Exception:
        return backup_model.invoke(input_data)

model_with_fallback = RunnableLambda(fallback_model)

2. 缓存机制 💾

聊天模型API可能很慢，因此一个自然的问题是是否缓存先前对话的结果。

缓存考虑因素：

挑战：

精确输入匹配的缓存命中率低
对话的动态性使缓存效果有限
语义缓存的复杂性

适用场景：

常见问题回答
静态内容生成
重复性任务处理

from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache

# 设置内存缓存
set_llm_cache(InMemoryCache())

# 使用缓存的模型
response1 = model.invoke("什么是人工智能？")  # 第一次调用API
response2 = model.invoke("什么是人工智能？")  # 从缓存返回

语义缓存示例：

from langchain.cache import SemanticCache
from langchain_openai import OpenAIEmbeddings

# 配置语义缓存
embeddings = OpenAIEmbeddings()
semantic_cache = SemanticCache(
    embedding=embeddings,
    similarity_threshold=0.8
)
set_llm_cache(semantic_cache)

最佳实践

1. 模型选择 🎯

# 根据任务选择合适的模型
simple_tasks_model = ChatOpenAI(model="gpt-3.5-turbo")  # 简单任务
complex_tasks_model = ChatOpenAI(model="gpt-4")  # 复杂推理
cost_effective_model = ChatOpenAI(model="gpt-3.5-turbo-instruct")  # 成本敏感

2. 参数调优 ⚙️

# 创意任务
creative_model = ChatOpenAI(
    model="gpt-4",
    temperature=0.9,  # 高创意性
    max_tokens=2000
)

# 分析任务
analytical_model = ChatOpenAI(
    model="gpt-4",
    temperature=0.1,  # 低随机性
    max_tokens=1000
)

3. 错误处理 🛡️

import time
from langchain_core.exceptions import LangChainException

def robust_invoke(model, message, max_retries=3):
    for attempt in range(max_retries):
        try:
            return model.invoke(message)
        except LangChainException as e:
            if attempt == max_retries - 1:
                raise e
            time.sleep(2 ** attempt)  # 指数退避
    return None

4. 成本优化 💰

# 使用较小模型进行预处理
def cost_optimized_pipeline(query):
    # 首先用小模型判断复杂度
    simple_model = ChatOpenAI(model="gpt-3.5-turbo")
    complexity_check = simple_model.invoke(
        f"这个问题复杂吗？只回答是或否：{query}"
    )
    
    if "是" in complexity_check.content:
        # 复杂问题使用大模型
        complex_model = ChatOpenAI(model="gpt-4")
        return complex_model.invoke(query)
    else:
        # 简单问题继续使用小模型
        return simple_model.invoke(query)