LangChain Memory

赤狐尼克

391人浏览 · 2026-04-29 01:08:08

赤狐尼克 · 2026-04-29 01:08:08 发布

一、LangChain Memory 核心概念详解

LangChain 的 Memory（记忆系统） 是让 Agent / 聊天机器人实现多轮对话、上下文理解、经验复用的核心模块，它解决了大模型「单轮对话、上下文窗口有限、跨会话失忆」的三大核心缺陷。

1. 什么是 LangChain Memory？

简单来说，Memory 是 LangChain 中存储和管理对话历史、中间结果、用户偏好的模块，它能把之前的对话内容自动注入到当前的 LLM 上下文中，让 LLM 知道「之前聊了什么」，从而实现连贯的多轮对话。

2. 短期记忆 vs 长期记忆（核心区别）

LangChain 的 Memory 分为两大类，对应人类的记忆模式：

对比维度	短期记忆（Short-term Memory）	长期记忆（Long-term Memory）
核心定义	存储当前会话的对话历史、中间结果，会话结束就清空	存储跨会话的用户偏好、历史经验、知识库，永久保存
存储载体	内存（InMemoryChatMessageHistory）、会话变量	向量数据库（Chroma/Pinecone）、本地文件、数据库
核心作用	实现当前会话的多轮对话，让 LLM 记住「刚才聊了什么」	实现跨会话的经验复用，让 LLM 记住「用户喜欢什么、之前做过什么」
上下文窗口	受 LLM 上下文窗口限制（比如 doubao-pro-32k 是 32k token）	不受上下文窗口限制，通过向量检索召回相关信息
典型应用	日常聊天机器人、多轮问答、当前任务的执行轨迹	个人助理、RAG 知识库、历史任务经验复用

3. LangChain 1.0+ Memory 核心类（必须掌握）

LangChain 1.0+ 对 Memory 进行了全面重构，废弃了旧的 ConversationBufferMemory 等类，现在的核心类都在 langchain_core 包里：

表格

类名	作用	说明
`BaseChatMessageHistory`	记忆的抽象基类	定义了记忆的基本接口（添加消息、获取消息、清空消息）
`InMemoryChatMessageHistory`	短期记忆的默认实现	把对话历史存储在内存里，会话结束就清空，适合当前会话的多轮对话
`RunnableWithMessageHistory`	给 Chain/Agent 加上记忆的核心类	把普通的 Chain/Agent 和记忆管理结合起来，自动处理对话历史的注入和存储

二、实战：给聊天机器人添加短期记忆

下面是一份完全兼容 LangChain 1.0+ 最新版本的代码，实现了一个带短期记忆的聊天机器人，能记住当前会话的所有对话内容，支持多轮连贯对话。

1. 完整可运行代码

# LangChain的 Memory核心类
import os
from dotenv import load_dotenv

# ===================== 1. 需要导入的模块 ================================
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.chat_history import BaseChatMessageHistory, InMemoryChatMessageHistory
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables.history import RunnableWithMessageHistory

from 学习langchain架构.自定义搜索工具super import chain_with_history

load_dotenv()

# ===================== 2. LLM ========================================
llm = ChatOpenAI(
    api_key=os.getenv("QWEN_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    model='qwen3-max', # 必须用 pro模型，支持工具调用
    temperature=0.1
)
# ===================== 3. prompt ====================================
prompt = ChatPromptTemplate([
    ("system", """你是一个友好、耐心、自然的日常聊天助手，擅长倾听用户需求，陪用户轻松聊天。
    核心规则：
    1.  必须记住用户之前提到的所有信息（姓名、喜好、需求），后续对话主动呼应
    2.  语气亲切自然，不使用书面化套话、不生硬、不啰嗦
    3.  不确定的内容，明确说"我不确定哦"，不猜测、不编造
    4.  纯文本回答，不使用特殊格式
    """),
    # ✅️核心：对话历史占位符，名字必须和后面 RunnabelWithMessageHistory 里的一致
    MessagesPlaceholder(variable_name="chat_history"),
    ("user","{input}")
])

# ===================== 4. 短期记忆管理 ===================================
# 用字典存储不同会话的历史（支持多用户隔离）
store = {}

def get_session_history(session_id: str) -> BaseChatMessageHistory:
    """
    根据会话ID获取对应的对话历史
    :param session_id: 会话ID，区分不同用户/不同对话
    :return: 对话历史对象
    """
    if session_id not in store:
        # 如果会话id不存在 创建一个新的短期记忆对象
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

# ===================== 5. 构建带短期记忆的chain ============================
# 第一步： 构建基础链（提示词 -> LLM -> 字符串输出解析器）
base_chain = prompt | llm | StrOutputParser()

# 第二步： 给基础链加上短期记忆（核心类 RunnabelWithMessageHistory）
chain_with_memory = RunnableWithMessageHistory(
    base_chain, # 记忆的基础链
    get_session_history, # 记忆获取函数
    input_messages_key="input",
    history_messages_key="chat_history"
)
# ===================== 6. 聊天主程序 ==================================
def main():
    print("==== LangChain带短期记忆的聊天机器人========")
    print(" 输入 'q' 退出， 输入 'clear' 清空当前会话的记忆")

    # 会话ID 这里固定位user_001, 多用户场景可以用用户id替换
    session_id = "user_001"

    while True:
        user_input = input("你：").strip()

        if user_input.lower() == "q":
            print("🤖 再见！ 下次再聊~")
            break

        if user_input.lower() == "clear":
            if session_id in store:
                store[session_id].clear()
            print("当前会话的记忆已清空！")
            continue

        # 输入空时跳过
        if not user_input:
            continue

        # 调用带记忆的chain
        response = chain_with_memory.invoke(
            {"input": user_input},
            config={"configurable":{"session_id":session_id}}, # 必须传入会话id
        )
        print(f'🤖：{response} \n')


if __name__ == "__main__":
    main()

2. 代码核心部分详解（重点是 Memory）

（1）提示词模板里的 `MessagesPlaceholder`

这是实现短期记忆的第一个关键点，你必须在提示词模板里加一个 MessagesPlaceholder，名字叫 chat_history，它的作用是「把之前的对话历史自动插入到这里」。

prompt = ChatPromptTemplate.from_messages([
    ("system", "..."),
    # ✅ 必须加这个占位符，名字要和后面一致
    MessagesPlaceholder(variable_name="chat_history"),
    ("user", "{input}"),
])

（2）记忆管理函数 `get_session_history`

这是实现短期记忆的第二个关键点，它的作用是「根据会话 ID 返回对应的对话历史对象」，支持多用户隔离。

store = {}  # 用字典存储不同会话的历史

def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()  # 短期记忆存在内存里
    return store[session_id]

（3）给 Chain 加记忆的 `RunnableWithMessageHistory`

这是实现短期记忆的第三个关键点，它把普通的 Chain 和记忆管理结合起来，自动处理「对话历史的存储」和「对话历史的注入」。

chain_with_memory = RunnableWithMessageHistory(
    base_chain,
    get_session_history,
    input_messages_key="input",  # 用户输入的键名
    history_messages_key="chat_history",  # 对话历史的键名（和占位符一致）
)

（4）调用时必须传入 `session_id`

调用带记忆的 Chain 时，必须通过 config 参数传入 session_id，它的作用是「告诉 Memory 系统，当前是哪个会话」。

response = chain_with_memory.invoke(
    {"input": user_input},
    config={"configurable": {"session_id": session_id}}  # 必须传
)

三、运行效果演示

==== LangChain带短期记忆的聊天机器人========
 输入 'q' 退出， 输入 'clear' 清空当前会话的记忆
你：你好，我叫小明，我喜欢打篮球
🤖：嗨，小明！很高兴认识你～听说你喜欢打篮球，太棒啦！我也超爱看大家打球的。你平时是喜欢自己练还是和朋友一起打呀？ 

你：我喜欢什么？
🤖：你喜欢打篮球呀！刚刚你告诉我的，记得吗？😄 

你：我叫什么名字？
🤖：你叫小明！我可记着呢～ 

你：clear
当前会话的记忆已清空！
你：我叫什么名字？我喜欢什么？
🤖：哎呀，我还不知道你的名字呢！也还没听你说过你喜欢什么～  
不过没关系，现在告诉我就好啦！你叫什么名字？平时喜欢做些什么？ 

你：q
🤖 再见！ 下次再聊~