LangChain 1.0 记忆系统：会话管理与长期记忆存储

玄同 765

大语言模型 (LLM) 开发工程师 | 中国传媒大学 · 数字媒体技术（智能交互与游戏设计）

优快云 · 个人主页 | GitHub · Follow

---

关于作者

• 深耕领域：大语言模型开发 / RAG 知识库 / AI Agent 落地 / 模型微调
• 技术栈：Python | RAG (LangChain / Dify + Milvus) | FastAPI + Docker
• 工程能力：专注模型工程化部署、知识库构建与优化，擅长全流程解决方案

「让 AI 交互更智能，让技术落地更高效」
欢迎技术探讨与项目合作，解锁大模型与智能交互的无限可能！

---

一、记忆系统概述

1.1 记忆系统核心概念

记忆层提供统一 State 管理、对话记录、长期检索、多模态 Memory 等能力，支持持久化与复杂工作流状态流转。记忆系统是智能体的核心组成部分，使智能体能够记住过去的交互，提供更连贯的用户体验。

核心组件：

• 短期记忆：消息历史自动管理
• 长期记忆：向量数据库存储（Chroma, Pinecone）
• 存储接口：Store（跨会话持久化）

1.2 记忆类型对比

记忆类型	存储方式	保留时间	适用场景	实现方式	特点
短期记忆	内存/会话	单次对话	上下文理解	InMemoryChatMessageHistory	速度快，易丢失
长期记忆	向量数据库	永久	知识检索	Chroma, Pinecone	语义检索，容量大
会话记忆	数据库	跨会话	用户偏好	Redis, SQL数据库	持久化，跨会话
多模态记忆	混合存储	永久	图像、音频检索	向量数据库 + 文件存储	支持多种数据类型

1.3 记忆系统架构

1.4 记忆系统的重要性

应用场景	记忆需求	记忆类型	优势
客服机器人	记住用户历史问题	短期+会话记忆	提供连贯的服务
个人助手	存储用户偏好	会话+长期记忆	个性化服务
知识管理	检索企业知识	长期记忆	知识复用
教育应用	跟踪学习进度	会话+长期记忆	个性化学习路径
医疗助手	记录患者病史	长期记忆	连续的医疗建议

二、短期记忆与会话管理

2.1 消息历史管理

LangChain 提供了多种消息历史管理方式，最常用的是 ChatMessageHistory：

from langchain_core.messages import AIMessage, HumanMessage
from langchain_core.chat_history import InMemoryChatMessageHistory

# 1. 创建消息历史
chat_history = InMemoryChatMessageHistory()

# 2. 添加消息
chat_history.add_user_message("你好，请你介绍一下你自己。")
chat_history.add_ai_message("你好！我是一个人工智能助手，很高兴为你服务。")

# 3. 获取消息历史
messages = chat_history.messages
print(messages)

# 4. 清除历史
chat_history.clear()

2.2 消息裁剪

对于长对话，可以使用消息裁剪功能，只保留最近的几条消息：

from langchain.messages import trim_messages
from langchain_core.messages import AIMessage, HumanMessage

# 创建一条长对话历史
messages = [
    HumanMessage(content="你好"),
    AIMessage(content="你好！"),
    HumanMessage(content="今天天气怎么样？"),
    AIMessage(content="今天天气很好！"),
    HumanMessage(content="你叫什么名字？"),
    AIMessage(content="我是一个AI助手。"),
    HumanMessage(content="你能做什么？"),
    AIMessage(content="我能回答问题、聊天等。"),
]

# 裁剪消息，只保留最近的2轮
trimmed = trim_messages(
    messages,
    max_tokens=100,
    strategy="last",
    token_counter=lambda x: len(x.content.split())
)

print([msg.content for msg in trimmed])

2.3 会话记忆集成

在链中集成会话记忆：

from langchain_core.runnables import RunnablePassthrough
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# 1. 存储消息历史的函数
session_store = {}

def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in session_store:
        session_store[session_id] = InMemoryChatMessageHistory()
    return session_store[session_id]

# 2. 创建 prompt
prompt = ChatPromptTemplate.from_template(
    "你是一个助手，根据对话历史回答问题。\n"
    "对话历史：{chat_history}\n"
    "问题：{question}"
)

# 3. 创建模型
model = ChatOpenAI(model="gpt-4o-mini")

# 4. 创建链
chain = RunnablePassthrough.assign(
    chat_history=lambda x: get_session_history(x["session_id"]).messages
) | prompt | model

# 5. 添加消息历史
chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="question",
    history_messages_key="chat_history",
    output_messages_key="output"
)

# 6. 执行对话
result = chain_with_history.invoke(
    {"question": "你好，请你介绍一下你自己。", "session_id": "1"}
)
print(result.content)

# 7. 继续对话
result = chain_with_history.invoke(
    {"question": "你刚才说了什么？", "session_id": "1"}
)
print(result.content)

三、长期记忆与向量存储

3.1 向量存储基础

长期记忆通常使用向量数据库存储，支持语义检索：

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_core.documents import Document

# 1. 创建文档
documents = [
    Document(
        page_content="LangChain 是一个构建 LLM 应用的框架",
        metadata={"source": "doc1"}
    ),
    Document(
        page_content="LangChain 1.0 版本引入了统一智能体抽象",
        metadata={"source": "doc2"}
    ),
    Document(
        page_content="LangGraph 是 LangChain 的工作流框架",
        metadata={"source": "doc3"}
    )
]

# 2. 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 3. 创建向量存储
vectorstore = Chroma.from_documents(
    documents=documents,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# 4. 相似性搜索
results = vectorstore.similarity_search("LangChain 1.0 有什么新特性？")
for doc in results:
    print(doc.page_content)

3.2 长期记忆集成

将长期记忆集成到智能体中：

from langchain_core.retrievers import BaseRetriever
from langchain_core.runnables import RunnableLambda

# 1. 创建检索器
retriever = vectorstore.as_retriever()

# 2. 创建一个检索链
def retrieve_and_generate(inputs):
    # 检索相关文档
    docs = retriever.get_relevant_documents(inputs["question"])
    # 构建上下文
    context = "\n".join([doc.page_content for doc in docs])
    # 生成回答
    result = model.invoke(
        f"根据上下文回答问题：\n上下文：{context}\n问题：{inputs['question']}"
    )
    return result

# 3. 创建链
retrieval_chain = RunnableLambda(retrieve_and_generate)

# 4. 执行
result = retrieval_chain.invoke({"question": "LangChain 1.0 有什么新特性？"})
print(result.content)

四、存储接口与持久化

4.1 Store 接口

Store 接口提供了统一的存储抽象，支持多种后端：

from langchain_core.stores import InMemoryStore

# 1. 创建内存存储
store = InMemoryStore()

# 2. 存储数据
store.mset([("key1", "value1"), ("key2", "value2")])

# 3. 获取数据
value = store.mget(["key1"])
print(value)

# 4. 删除数据
store.mdelete(["key1"])

4.2 持久化存储

对于生产环境，可以使用持久化存储：

from langchain.storage import LocalFileStore

# 1. 创建文件存储
store = LocalFileStore("./store")

# 2. 存储数据
store.mset([("user1", "{\"name\": \"张三\", \"preferences\": \"喜欢科技\"}")])

# 3. 获取数据
user_data = store.mget(["user1"])
print(user_data)

五、多模态记忆

5.1 多模态数据存储

LangChain 支持存储和检索多模态数据：

from langchain_core.documents import Document

# 创建包含多模态信息的文档
documents = [
    Document(
        page_content="这是一张猫的图片",
        metadata={"source": "image", "image_path": "cat.jpg"}
    ),
    Document(
        page_content="这是一段关于狗的音频",
        metadata={"source": "audio", "audio_path": "dog.mp3"}
    )
]

# 存储到向量数据库
vectorstore = Chroma.from_documents(
    documents=documents,
    embedding=embeddings
)

# 检索
results = vectorstore.similarity_search("动物图片")
for doc in results:
    print(f"内容: {doc.page_content}")
    print(f"元数据: {doc.metadata}")

六、记忆系统优化

6.1 记忆压缩

对于长文档，可以使用记忆压缩技术：

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor

# 1. 创建压缩器
compressor = LLMChainExtractor.from_llm(model)

# 2. 创建压缩检索器
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=retriever
)

# 3. 使用
results = compression_retriever.get_relevant_documents("LangChain 1.0 新特性")
for doc in results:
    print(doc.page_content)
    print("=" * 50)

6.2 记忆检索优化

优化记忆检索的方法：

优化方法	效果	实现方式
元数据过滤	提高相关性	filter 参数
Top-K 调整	平衡精度和速度	k 参数
相似度阈值	过滤低质量结果	score_threshold
多检索器融合	综合多源信息	EnsembleRetriever

七、实战案例

7.1 构建一个具备长期记忆的对话系统

from langchain_core.runnables import RunnablePassthrough
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document

# 1. 创建知识库
documents = [
    Document(page_content="公司名称：ABC科技\n成立时间：2020年\n主营业务：人工智能开发", metadata={"source": "company"}),
    Document(page_content="产品名称：智能助手\n功能：对话、问答、任务执行", metadata={"source": "product"}),
    Document(page_content="团队成员：张三（CEO）、李四（CTO）、王五（产品经理）", metadata={"source": "team"}),
]

# 2. 创建向量存储
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documents, embeddings)
retriever = vectorstore.as_retriever()

# 3. 创建 prompt
prompt = ChatPromptTemplate.from_template(
    "你是ABC科技的智能助手，根据公司知识和对话历史回答问题。\n"
    "公司知识：{context}\n"
    "对话历史：{history}\n"
    "问题：{question}"
)

# 4. 创建模型
model = ChatOpenAI(model="gpt-4o-mini")

# 5. 创建消息历史
chat_history = InMemoryChatMessageHistory()

# 6. 构建链
chain = RunnablePassthrough.assign(
    context=lambda x: "\n".join([doc.page_content for doc in retriever.get_relevant_documents(x["question"])]),
    history=lambda x: "\n".join([f"{msg.type}: {msg.content}" for msg in chat_history.messages])
) | prompt | model

# 7. 对话循环
while True:
    question = input("用户: ")
    if question.lower() == "exit":
        break
  
    result = chain.invoke({"question": question})
    print(f"助手: {result.content}")
  
    # 更新消息历史
    chat_history.add_user_message(question)
    chat_history.add_ai_message(result.content)

7.2 构建一个用户偏好记忆系统

from langchain.storage import LocalFileStore
import json

# 1. 创建用户偏好存储
preference_store = LocalFileStore("./user_preferences")

# 2. 存储用户偏好
def save_preference(user_id, preference):
    existing = preference_store.mget([user_id])[0]
    if existing:
        data = json.loads(existing)
        data.update(preference)
    else:
        data = preference
    preference_store.mset([(user_id, json.dumps(data))])

# 3. 获取用户偏好
def get_preference(user_id):
    data = preference_store.mget([user_id])[0]
    return json.loads(data) if data else {}

# 4. 使用示例
save_preference("user1", {"favorite_topic": "人工智能", "language": "中文"})
save_preference("user1", {"notification": "email"})

preferences = get_preference("user1")
print(preferences)

# 5. 在对话中使用用户偏好
def create_personalized_response(user_id, question):
    preferences = get_preference(user_id)
    context = f"用户偏好：{json.dumps(preferences)}"
    result = model.invoke(
        f"根据用户偏好回答问题：\n{context}\n问题：{question}"
    )
    return result.content

response = create_personalized_response("user1", "你能推荐一些人工智能相关的内容吗？")
print(response)

八、应用场景分析

8.1 适合使用记忆系统的场景

• 客服机器人：记住用户历史问题
• 个人助手：存储用户偏好和习惯
• 知识管理：检索企业知识库
• 教育应用：跟踪学习进度
• 医疗助手：记录患者病史

8.2 记忆系统的挑战

• 存储成本：长期记忆需要向量数据库
• 检索精度：相似性搜索可能不够准确
• 隐私保护：用户数据需要安全存储
• 性能优化：大规模记忆检索的速度

九、总结

LangChain 1.0 的记忆系统通过统一的抽象和丰富的功能，为开发者提供了构建具备记忆能力的智能体应用的强大工具。通过本文的介绍，开发者可以掌握短期记忆与会话管理、长期记忆与向量存储、存储接口与持久化等核心功能，实现智能体的持续学习和知识积累。

在后续的博客中，我们将介绍如何利用这些记忆能力构建完整的智能体应用，以及如何通过 LangGraph 实现更复杂的工作流。