【LangChain】langchain_community.chat_message_histories.RedisChatMessageHistory 类：将聊天消息历史存储到 Redis 数据库

langchain_community.chat_message_histories.RedisChatMessageHistory 类是 LangChain 社区库中用于将聊天消息历史存储到 Redis 数据库的工具类，适合高并发、持久化的多轮对话上下文管理。
本文基于 LangChain 0.3.x ，全程使用中文，详细介绍 RedisChatMessageHistory 的定义、参数、方法和典型场景，并提供一个独立示例，展示如何使用 RedisChatMessageHistory 结合 ChatOpenAI 和 Redis 实现人工智能主题的多轮对话，示例突出消息历史的持久化存储和高并发支持。

---

langchain_community.chat_message_histories.RedisChatMessageHistory 简介

RedisChatMessageHistory 是 LangChain 社区库中的消息历史存储类，通过 Redis 数据库（一个高性能的键值存储）持久化存储对话消息（HumanMessage、AIMessage 等）。它适合需要高并发访问、快速读写和持久化对话历史的场景，特别适用于生产级聊天机器人或多用户应用。相比内存存储的 ChatMessageHistory 或 SQLChatMessageHistory，Redis 提供更高的吞吐量和分布式支持。

核心功能：

• 将对话消息存储到 Redis，支持持久化和高并发。
• 按会话 ID（session_id）组织消息，支持多用户或多会话。
• 支持添加、获取、清除消息。
• 集成到对话链，实现上下文感知的多轮对话。

适用场景：

• 构建高并发聊天机器人，需快速读写对话历史。
• 多用户应用，跟踪每个用户的会话。
• 分布式系统，需跨实例共享对话历史。
• 与 LLM 链结合，提供长期上下文支持。

与其他消息历史类对比：

• ChatMessageHistory：内存存储，临时使用，非持久化。
• SQLChatMessageHistory：基于 SQL 数据库，持久化但并发性能较低。
• RedisChatMessageHistory：基于 Redis，高并发、持久化，适合生产环境。

---

类定义和初始化

以下是 RedisChatMessageHistory 的定义，基于 LangChain 社区库源码（langchain_community/chat_message_histories/redis.py）和官方文档（RedisChatMessageHistory)。

类签名

class RedisChatMessageHistory(BaseChatMessageHistory):
    def __init__(
        self,
        session_id: str,
        redis_url: str = "redis://localhost:6379/0",
        key_prefix: str = "message_store:",
        ttl: Optional[int] = None
    ) -> None

• 参数：
  • session_id（str）：会话标识符，区分不同对话。
  • redis_url（str，默认 "redis://localhost:6379/0"）：Redis 连接 URL。
  • key_prefix（str，默认 "message_store:"）：Redis 键前缀，用于命名空间。
  • ttl（Optional[int]，默认 None）：消息的生存时间（秒），过期自动删除。
• 功能：
  • 使用 Redis 列表存储消息，按 session_id 组织。
  • 键格式：{key_prefix}{session_id}（如 message_store:ai_chat_001）。
  • 支持高并发读写和可选的自动过期。

初始化示例

from langchain_community.chat_message_histories import RedisChatMessageHistory
history = RedisChatMessageHistory(
    session_id="ai_chat_001",
    redis_url="redis://localhost:6379/0",
    key_prefix="message_store:",
    ttl=3600  # 消息保留 1 小时
)

---

Redis 存储结构

RedisChatMessageHistory 使用 Redis 列表（List）存储消息：

• 键：{key_prefix}{session_id}（如 message_store:ai_chat_001）。
• 值：消息序列化的 JSON 列表，按时间顺序存储。
• 示例（Redis CLI）：

  LRANGE message_store:ai_chat_001 0 -1
  # 输出：
  # ["{\"type\": \"human\", \"content\": \"什么是人工智能？\"}", 
  #  "{\"type\": \"ai\", \"content\": \"人工智能是计算机科学的一个分支。\"}"]
  

---

常用方法

RedisChatMessageHistory 继承自 langchain_core.chat_history.BaseChatMessageHistory，提供以下核心方法。

1. add_message

def add_message(self, message: BaseMessage) -> None

• 功能：添加单条消息到 Redis 列表。
• 输入：message（BaseMessage），如 HumanMessage 或 AIMessage。
• 示例：

  from langchain_core.messages import HumanMessage, AIMessage
  history.add_message(HumanMessage(content="什么是人工智能？"))
  history.add_message(AIMessage(content="人工智能是计算机科学的一个分支。"))
  

2. add_user_message

def add_user_message(self, message: str) -> None

• 功能：添加用户消息（HumanMessage）。
• 输入：message（str），用户输入文本。
• 示例：

  history.add_user_message("AI 有哪些应用？")
  

3. add_ai_message

def add_ai_message(self, message: str) -> None

• 功能：添加 AI 消息（AIMessage）。
• 输入：message（str），模型响应文本。
• 示例：

  history.add_ai_message("AI 应用于医疗、自动驾驶等领域。")
  

4. clear

def clear(self) -> None

• 功能：删除当前 session_id 的所有消息。
• 示例：

  history.clear()
  print(len(history.messages))  # 0
  

5. messages 属性

• 功能：从 Redis 查询当前 session_id 的消息列表。
• 输出：List[BaseMessage]，所有消息。
• 示例：

  for msg in history.messages:
      print(f"{msg.__class__.__name__}: {msg.content}")
  

6. 异步方法

• 功能：异步版本方法（如 aclear、aadd_message）。
• 使用场景：高并发场景。
• 示例：

  import asyncio
  await history.aclear()
  

---

使用方式

以下是使用 RedisChatMessageHistory 的步骤。

1. 安装依赖和 Redis

pip install --upgrade langchain langchain-openai langchain-community redis

安装 Redis 服务器：

• Ubuntu：

  sudo apt update
  sudo apt install redis-server
  

• macOS：

  brew install redis
  

启动 Redis：

redis-server

2. 设置 OpenAI API 密钥

export OPENAI_API_KEY="your-api-key"

或在代码中：

import os
os.environ["OPENAI_API_KEY"] = "your-api-key"

3. 初始化 RedisChatMessageHistory

from langchain_community.chat_message_histories import RedisChatMessageHistory
history = RedisChatMessageHistory(
    session_id="ai_chat_001",
    redis_url="redis://localhost:6379/0"
)

4. 构建对话链

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
llm = ChatOpenAI(model="gpt-3.5-turbo")
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个人工智能专家，回答用户问题。"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])
chain = prompt | llm

5. 调用链并存储历史

from langchain_core.runnables.history import RunnableWithMessageHistory
chain_with_history = RunnableWithMessageHistory(
    runnable=chain,
    get_session_history=lambda session_id: RedisChatMessageHistory(
        session_id=session_id,
        redis_url="redis://localhost:6379/0"
    ),
    input_messages_key="input",
    history_messages_key="history"
)
response = chain_with_history.invoke(
    {"input": "什么是人工智能？"},
    config={"configurable": {"session_id": "ai_chat_001"}}
)

---

使用 RedisChatMessageHistory 的示例

以下是一个独立示例，展示如何使用 RedisChatMessageHistory 结合 ChatOpenAI 和 Redis 实现人工智能主题的多轮对话，持久化存储消息历史并支持高并发。示例使用 RunnableWithMessageHistory 简化对话管理。

准备环境：

• 获取 OpenAI API 密钥：OpenAI Platform。
• 设置环境变量：

  export OPENAI_API_KEY="your-api-key"
  

• 安装依赖：

  pip install --upgrade langchain langchain-openai langchain-community redis
  

• 启动 Redis 服务器：

  redis-server
  

• 验证 Redis 连接：

  redis-cli ping
  # 输出: PONG
  

代码：

from langchain_community.chat_message_histories import RedisChatMessageHistory
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables.history import RunnableWithMessageHistory

# 初始化 ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)

# 定义提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个人工智能专家，回答用户问题。"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

# 定义输出解析器
parser = StrOutputParser()

# 创建对话链
chain = prompt | llm | parser

# 包装链以支持消息历史
chain_with_history = RunnableWithMessageHistory(
    runnable=chain,
    get_session_history=lambda session_id: RedisChatMessageHistory(
        session_id=session_id,
        redis_url="redis://localhost:6379/0",
        ttl=3600  # 消息保留 1 小时
    ),
    input_messages_key="input",
    history_messages_key="history"
)

# 测试 RedisChatMessageHistory 和对话链
print("测试 RedisChatMessageHistory 和对话链：")
try:
    session_id = "ai_chat_001"
    
    # 第一轮对话
    question1 = "什么是人工智能？"
    result1 = chain_with_history.invoke(
        {"input": question1},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"问题 1: {question1}")
    print(f"回答 1: {result1}")
    
    # 第二轮对话（依赖上下文）
    question2 = "它有哪些应用？"
    result2 = chain_with_history.invoke(
        {"input": question2},
        config={"configurable": {"session_id": session_id}}
    )
    print(f"\n问题 2: {question2}")
    print(f"回答 2: {result2}")
    
    # 显示消息历史
    history = RedisChatMessageHistory(session_id=session_id, redis_url="redis://localhost:6379/0")
    print("\n消息历史：")
    for i, msg in enumerate(history.messages):
        print(f"消息 {i+1} ({msg.__class__.__name__}): {msg.content}")
except Exception as e:
    print(f"错误: {e}")

输出示例（实际输出取决于模型和 API 响应）：

测试 RedisChatMessageHistory 和对话链：
问题 1: 什么是人工智能？
回答 1: 人工智能（AI）是计算机科学的一个分支，旨在模拟人类智能，如学习、推理和问题解决。

问题 2: 它有哪些应用？
回答 2: 人工智能的应用包括医疗诊断、自动驾驶、语音识别、推荐系统和金融分析等领域。

消息历史：
消息 1 (HumanMessage): 什么是人工智能？
消息 2 (AIMessage): 人工智能（AI）是计算机科学的一个分支，旨在模拟人类智能，如学习、推理和问题解决。
消息 3 (HumanMessage): 它有哪些应用？
消息 4 (AIMessage): 人工智能的应用包括医疗诊断、自动驾驶、语音识别、推荐系统和金融分析等领域。

代码说明

1. RedisChatMessageHistory：
   • 使用 Redis（redis://localhost:6379/0）存储消息。
   • 设置 session_id="ai_chat_001" 区分会话，ttl=3600 限制消息保留 1 小时。
2. LLM 初始化：
   • 使用 ChatOpenAI 调用 gpt-3.5-turbo，设置 temperature=0.7。
3. 提示模板：
   • ChatPromptTemplate 包含系统消息、历史占位符和用户输入。
   • MessagesPlaceholder 注入历史消息。
4. 对话链：
   • 使用 LCEL 组合 prompt、llm 和 parser。
   • RunnableWithMessageHistory 包装链，动态加载 RedisChatMessageHistory。
5. 测试：
   • 进行两轮对话：定义 AI 和询问应用。
   • 使用 session_id 确保上下文一致。
   • 显示 Redis 中的消息历史。
6. 错误处理：
   • 使用 try-except 捕获 API 或 Redis 错误。

运行要求：

• 有效的 OpenAI API 密钥：

  export OPENAI_API_KEY="your-api-key"
  

• 安装依赖：

  pip install --upgrade langchain langchain-openai langchain-community redis
  

• 运行 Redis 服务器：

  redis-server
  

• 网络连接：访问 https://api.openai.com 和本地 Redis（localhost:6379）。

---

注意事项

1. API 密钥：
   • 确保 OPENAI_API_KEY 已设置：

     echo $OPENAI_API_KEY
     

   • 或在代码中设置：

     llm = ChatOpenAI(api_key="your-api-key")
     

2. Redis 配置：
   • 确保 Redis 服务器运行：

     redis-cli ping
     # 输出: PONG
     

   • 配置 Redis 连接：

     redis_url="redis://username:password@host:port/db"
     

   • 测试连接：

     import redis
     r = redis.Redis.from_url("redis://localhost:6379/0")
     r.ping()
     

3. 会话 ID：
   • 唯一 session_id 区分对话：

     session_id="ai_chat_001"
     

   • 重复使用 session_id 加载历史：

     history = RedisChatMessageHistory(session_id="ai_chat_001", redis_url="redis://localhost:6379/0")
     

4. TTL 设置：
   • 设置消息过期时间：

     history = RedisChatMessageHistory(ttl=86400)  # 1 天
     

   • 验证 TTL：

     redis-cli TTL message_store:ai_chat_001
     

5. 性能优化：
   • 限制历史长度：避免上下文过长：

     max_messages = 10
     history.messages = history.messages[-max_messages:]
     

   • 异步调用：使用 ainvoke：

     result = await chain_with_history.ainvoke(input, config)
     

   • Redis 连接池：提高并发性能：

     import redis
     pool = redis.ConnectionPool.from_url("redis://localhost:6379/0")
     history = RedisChatMessageHistory(session_id="ai_chat_001", redis_url="redis://localhost:6379/0")
     

6. 错误调试：
   • Redis 连接错误：
     • 检查连接：

       import redis
       r = redis.Redis.from_url("redis://localhost:6379/0")
       r.ping()
       

     • 验证键：

       redis-cli KEYS message_store:*
       

   • API 错误：
     • 检查密钥：

       print(os.environ.get("OPENAI_API_KEY"))
       

     • 增加超时：

       llm = ChatOpenAI(timeout=30)
       

   • 消息丢失：
     • 检查历史：

       print(history.messages)
       

     • 验证 session_id：

       print(session_id)
       

---

常见问题

Q1：如何配置远程 Redis？
A：修改 redis_url：

history = RedisChatMessageHistory(
    session_id="ai_chat_001",
    redis_url="redis://username:password@remote_host:6379/0"
)

Q2：如何清理特定会话历史？
A：调用 clear：

history.clear()

或直接删除 Redis 键：

redis-cli DEL message_store:ai_chat_001

Q3：如何与 RAG 结合？
A：添加检索上下文：

from langchain.vectorstores import FAISS
vectorstore = FAISS.from_documents(docs, OpenAIEmbeddings())
retriever = vectorstore.as_retriever()
prompt = ChatPromptTemplate.from_messages([
    ("system", "根据上下文和历史回答：\n{context}"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])
chain = {"context": retriever, "history": lambda x: history.messages, "input": lambda x: x["input"]} | prompt | llm

Q4：如何支持开源模型？
A：使用 ChatOllama：

from langchain_ollama import ChatOllama
llm = ChatOllama(model="llama3")
chain = prompt | llm | parser
chain_with_history = RunnableWithMessageHistory(
    runnable=chain,
    get_session_history=lambda session_id: RedisChatMessageHistory(
        session_id=session_id,
        redis_url="redis://localhost:6379/0"
    ),
    input_messages_key="input",
    history_messages_key="history"
)

---

总结

langchain_community.chat_message_histories.RedisChatMessageHistory 是 LangChain 中高性能、持久化对话历史的工具，核心功能包括：

• 定义：通过 Redis 存储消息历史。
• 初始化：配置 session_id 和 redis_url。
• 常用方法：add_message、add_user_message、add_ai_message、clear。
• 适用场景：高并发对话、持久化存储、生产级应用。