【LangChain专栏】LangChain Memory 核心解析

在大模型应用开发中，多轮对话的上下文感知能力是衡量应用智能性的关键指标。但原生大模型本身并不具备记忆能力，每一次交互都是独立的请求，无法记住用户上一轮说了什么。而LangChain中的Memory组件，正是为解决这一问题而生的核心模块，它能让大模型实现对话历史的存储、管理与利用，构建真正具备上下文理解能力的链式对话系统。

本文将基于LangChain Memory的核心设计与使用逻辑，从基础概念到实际应用，从简单记忆组件到高级混合记忆机制，全方位解析LangChain Memory的使用方法与设计思路，帮助开发者快速掌握让大模型拥有“记忆”的核心技巧。

一、为什么需要Memory？大模型的记忆困境

大多数大模型应用都以会话接口为载体，用户期望与模型的对话能像和人交流一样，具备上下文连贯性。比如当你告诉模型“我叫小明”，后续再问“我是谁”时，期望得到准确的回答，但原生大模型本身不会记忆任何上下文，它只能根据当前的输入生成输出，对过往的对话毫无感知。

要解决这一问题，就需要额外的模块来保存用户与模型的对话历史，并在下一次请求时，将历史信息与当前问题一起输入给模型，让模型基于完整的上下文生成输出。而LangChain中的Memory组件，就是专门承担这一功能的核心模块，为多轮对话的上下文感知提供了底层支撑。

二、LangChain Memory 核心基础认知

2.1 什么是Memory？

Memory是LangChain中用于多轮对话中保存和管理上下文信息（文本、图像、音频等）的组件，它能让应用记住用户之前的交互内容，实现对话的上下文感知，是构建智能链式对话系统的基础。

2.2 Memory的核心设计理念

LangChain Memory的工作流程遵循“读取-构建-处理-写入”的闭环逻辑，与链（Chain）的交互分为两次核心操作：读取历史和写入新内容，具体步骤如下：

1. 输入问题：用户提交当前的问题请求；
2. 读取历史消息：从Memory中读取过往的对话历史信息；
3. 构建提示：将历史消息与当前问题合并，生成新的Prompt；
4. 模型处理：将构建好的Prompt传递给大模型，生成输出结果；
5. 解析输出：通过输出解析器处理模型结果，返回给用户可理解的回答；
6. 写入Memory：将当前的问题与模型的回答一起写入Memory，更新对话历史，为后续对话提供上下文。

简单来说，当链接入Memory模块后，收到用户输入时会先从Memory中查询历史，拼接后传给大模型；返回响应前，会自动将新的问答对写入Memory，完成记忆更新。

2.3 不用Memory模块，如何实现记忆？

在不借助LangChain Memory组件的情况下，也能通过基础的代码逻辑让大模型具备简单的记忆能力：通过变量不断追加历史对话信息到消息列表中，将完整的对话历史作为输入传给大模型。

核心思路是利用HumanMessage（用户消息）和AIMessage（模型消息）类，将每一轮的问答对追加到消息列表，每次调用模型时都传入完整的列表。这种方式是大模型记忆的基础，任何记忆机制的底层都是对聊天交互历史的存储，只是不同的Memory组件会对历史信息做不同的处理与优化。

但这种原生方式的弊端也很明显：需要开发者手动管理消息列表，无法灵活控制历史信息的规模，长对话下会导致输入Token过多，超出大模型的输入限制，同时也会增加Token消耗。而LangChain的各类Memory组件，正是为了解决这些问题而设计的。

import os

from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
from langchain_openai import ChatOpenAI

"""
代码示例：原生方式实现大模型记忆
"""

# 初始化大模型
llm = ChatOpenAI(model="qwen-plus",
                        api_key=os.getenv("DASHSCOPE_API_KEY"),
                        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                        )

# 初始化对话消息列表，存储历史问答
chat_messages = [SystemMessage(content="你是一位友好的人工智能小助手")]

def chat_with_llm(question):
    # 添加当前用户问题到消息列表
    chat_messages.append(HumanMessage(content=question))
    # 调用模型，传入完整的历史消息
    response = llm.invoke(chat_messages)
    # 添加模型回答到消息列表，更新历史
    chat_messages.append(AIMessage(content=response.content))
    return response.content

# 多轮对话测试
print(chat_with_llm("你好，我叫小明"))
print(chat_with_llm("我是谁？"))
print(chat_with_llm("帮我介绍一下李白"))
print(chat_with_llm("我刚才让你介绍的是谁？"))

三、LangChain 基础Memory模块使用

LangChain针对不同的对话场景，设计了多层级的Memory解决方案，从最基础的完整历史存储，到按窗口截取最近对话，再到智能摘要、实体提取，形成了一套完整的记忆体系。而基础Memory模块的核心是ChatMessageHistory和ConversationBufferMemory，是所有高级Memory组件的底层基础。

3.1 ChatMessageHistory：记忆的底层存储工具

ChatMessageHistory是LangChain中用于存储和管理对话消息的基础类，也有别名InMemoryChatMessageHistory，它直接操作HumanMessage、AIMessage等消息对象，是其他所有记忆组件的底层存储支撑。

核心特点

1. 纯粹的消息“存储器”，仅负责消息的添加、存储和读取，与任何记忆策略（如缓冲、窗口、摘要）无关；
2. 不涉及消息的格式化处理，不会将消息转化为纯文本字符串，保持消息的原始对象格式；
3. 直接返回List[BaseMessage]类型的消息列表，可直接对接大模型的invoke方法。

典型使用场景

场景1：基础记忆存储

from langchain.memory import ChatMessageHistory

# 实例化对象
history = ChatMessageHistory()
# 添加用户消息和AI消息
history.add_user_message("hi!")
history.add_ai_message("whats up?")
# 读取所有消息
print(history.messages)

场景2：直接对接LLM
将ChatMessageHistory存储的消息列表直接传给大模型，模型会基于完整的历史上下文生成回答：

from langchain.memory import ChatMessageHistory
from langchain_openai import ChatOpenAI

# 实例化并添加历史消息
history = ChatMessageHistory()
history.add_user_message("你好,我叫小明,请介绍一下你自己")
history.add_user_message("我是谁呢?")

# 初始化大模型并调用
llm = ChatOpenAI(model_name='gpt-4o-mini')
response = llm.invoke(history.messages)
print(response.content) # 模型会回答：你好，小明！我是一个人工智能助手...

3.2 ConversationBufferMemory：基础的完整对话记忆

ConversationBufferMemory是最常用的基础记忆组件，专门用于按原始顺序存储完整的对话历史，是对ChatMessageHistory的上层封装，可直接与LangChain的Chain、Model无缝集成，无需开发者手动管理消息列表。

核心特点

1. 完整存储：按问答顺序保存所有的对话历史，无裁剪、无压缩；
2. 格式灵活：通过return_messages参数控制输出格式，True返回消息对象列表，False（默认）返回拼接的纯文本字符串；
3. 键可自定义：默认以history为键返回记忆内容，可通过memory_key参数修改键名，适配不同的Prompt模板；
4. 无缝集成：直接与LLMChain、ConversationChain等集成，自动完成历史的读取与写入。

典型使用场景

场景1：入门使用，存储与读取对话

from langchain.memory import ConversationBufferMemory

# 实例化对象（默认返回纯文本）
memory = ConversationBufferMemory()
# 保存问答对
memory.save_context(inputs={"input": "你好,我是人类"}, outputs={"output": "你好,我是AI助手"})
memory.save_context(inputs={"input": "很开心认识你"}, outputs={"output": "我也是"})
# 读取记忆
print(memory.load_memory_variables({}))
# 输出：{'history': 'Human: 你好,我是人类\nAI: 你好,我是AI助手\nHuman: 很开心认识你\nAI: 我也是'}

# 实例化对象（返回消息对象列表）
memory_msg = ConversationBufferMemory(return_messages=True)
memory_msg.save_context({"input": "hi"}, {"output": "whats up"})
print(memory_msg.load_memory_variables({}))
# 输出：{'history': [HumanMessage(content='hi'), AIMessage(content='whats up')]}

场景2：与LLMChain结合，实现多轮对话记忆
这是实际开发中最常用的场景，将ConversationBufferMemory与LLMChain集成，让链具备自动的记忆能力，核心是保证Prompt模板的变量名与Memory的键名匹配：

from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains.llm import LLMChain
from langchain_core.prompts import PromptTemplate

# 初始化大模型
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
# 定义Prompt模板，包含history和question两个变量
template = """你可以与人类对话。
当前对话: {history}
人类问题: {question}
回复:
"""
prompt = PromptTemplate.from_template(template)
# 初始化Memory
memory = ConversationBufferMemory()
# 初始化LLMChain，集成Memory
chain = LLMChain(llm=llm, prompt=prompt, memory=memory)

# 多轮对话
res1 = chain.invoke({"question": "我的名字叫Tom"})
res2 = chain.invoke({"question": "我的名字是什么?"})
print(res2["text"]) # 输出：你的名字是Tom。

若需要修改Memory的键名，只需通过memory_key参数配置，并同步修改Prompt模板中的变量名即可。

3.3 ConversationChain：Memory与Chain的封装神器

ConversationChain是LangChain对ConversationBufferMemory和LLMChain的高层封装，内置了默认的Prompt模板，无需开发者手动定义模板和初始化Memory，极大简化了具备基础记忆能力的对话链的开发流程。

核心特点

1. 内置默认Prompt模板，包含history和input两个核心变量，适配基础多轮对话；
2. 无需手动初始化Memory，底层自动集成ConversationBufferMemory；
3. 调用时只需传入input键的参数，无需额外处理历史信息。

典型使用场景

场景1：使用内置默认模板

from langchain_openai import ChatOpenAI
from langchain.chains.conversation.base import ConversationChain

# 初始化大模型
llm = ChatOpenAI(model="gpt-4o-mini")
# 初始化ConversationChain，自动集成记忆
conv_chain = ConversationChain(llm=llm)

# 多轮对话
conv_chain.invoke(input="小明有1只猫")
conv_chain.invoke(input="小刚有2只狗")
res = conv_chain.invoke(input="小明和小刚一共有几只宠物?")
print(res["response"]) # 输出：小明有一只猫，小刚有两只狗，所以他们一共有三只宠物。

场景2：自定义Prompt模板
若内置模板无法满足需求，也可自定义Prompt模板，传递给ConversationChain：

from langchain_openai import ChatOpenAI
from langchain.chains.conversation.base import ConversationChain
from langchain_core.prompts import PromptTemplate

llm = ChatOpenAI(model="gpt-4o-mini")
# 自定义模板
template = """以下是人类与AI的友好对话，AI健谈且注重细节。
当前对话: {history}
Human: {input}
AI:"""
prompt = PromptTemplate.from_template(template)
# 初始化对话链，传入自定义模板
chain = ConversationChain(llm=llm, prompt=prompt, verbose=True)
# 调用
chain.invoke({"input": "你好,你的名字叫小智"})
chain.invoke({"input": "你叫什么名字?"}) # 模型会回答：我叫小智。

3.4 ConversationBufferWindowMemory：长对话的窗口记忆策略

ConversationBufferMemory会完整存储所有对话历史，长对话场景下会导致内存占用过大、Token消耗过高，甚至超出大模型的输入Token限制。而ConversationBufferWindowMemory正是为解决这一问题设计的，它会仅保存最近K个交互的问答对，形成一个“记忆窗口”，截断较早的对话历史，避免信息过载。

核心特点

1. 窗口限制：通过k参数设置记忆窗口大小，仅保留最近k轮对话；
2. 格式兼容：与ConversationBufferMemory完全兼容，支持return_messages和memory_key参数；
3. 长对话友好：有效控制输入Token数量，适配大模型的输入限制，降低Token消耗。

典型使用场景

场景1：基础窗口记忆存储

from langchain.memory import ConversationBufferWindowMemory

# 实例化对象，设置窗口k=2，仅保留最近2轮对话
memory = ConversationBufferWindowMemory(k=2)
# 保存3轮对话
memory.save_context({"input": "你好"}, {"output": "怎么了"})
memory.save_context({"input": "你是谁"}, {"output": "我是AI助手"})
memory.save_context({"input": "你的生日是哪天?"}, {"output": "我不清楚"})
# 读取记忆，仅返回后2轮
print(memory.load_memory_variables({}))
# 输出：{'history': 'Human: 你是谁\nAI: 我是AI助手\nHuman: 你的生日是哪天?\nAI: 我不清楚'}

场景2：与Chain结合，长对话记忆控制

from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferWindowMemory
from langchain.chains.llm import LLMChain
from langchain_core.prompts import PromptTemplate

llm = ChatOpenAI(model="gpt-4o-mini")
template = """以下是人类与AI的友好对话，AI会准确回答问题。
当前对话: {history}
Human: {question}
AI:"""
prompt = PromptTemplate.from_template(template)
# 初始化窗口记忆，k=1，仅保留最近1轮
memory = ConversationBufferWindowMemory(k=1)
# 集成到链
chain = LLMChain(llm=llm, prompt=prompt, memory=memory)

# 多轮对话
chain.invoke({"question": "你好,我是孙小空"})
chain.invoke({"question": "我有两个师弟,猪小戒和沙小僧"})
chain.invoke({"question": "我今年考上了一本"})
res = chain.invoke({"question": "我叫什么?"})
print(res["text"]) # 输出：抱歉,我不知道你的名字。（因k=1，仅保留上一轮对话，丢失名字信息）

# 若将k改为3，模型会准确回答：你叫孙小空。

这一特性让开发者可以根据实际场景灵活控制记忆的范围，平衡上下文连贯性和Token消耗。

四、LangChain 高级Memory模块：适配复杂对话场景

基础Memory模块能解决简单的对话记忆问题，但面对超长篇对话、需要保留核心信息、需要结构化存储实体等复杂场景，就需要使用LangChain的高级Memory模块。这些模块在基础记忆的基础上，增加了Token控制、智能摘要、实体提取、知识图谱、向量检索等功能，适配不同的复杂业务场景。

4.1 ConversationTokenBufferMemory：基于Token的精准记忆控制

ConversationTokenBufferMemory是基于Token数量的记忆控制机制，与按轮次控制的窗口记忆不同，它会根据Token数量来截断对话历史：当总Token数超出指定的max_token_limit时，自动移除最早的消息，确保输入的Token数始终在限制范围内，实现更精准的记忆规模控制。

核心特点

1. Token精准控制：基于大模型的Token计算规则，而非简单的轮次，控制更精准；
2. 保留原始对话：截断时仅移除最早的消息，剩余消息保持原始格式，不做任何压缩或摘要；
3. 需绑定LLM：初始化时必须传入大模型实例，用于计算Token数量。

典型使用

from langchain.memory import ConversationTokenBufferMemory
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")
# 初始化，设置max_token_limit=50
memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=50)
# 保存对话
memory.save_context({"input": "你好吗?"}, {"output": "我很好,谢谢!"})
memory.save_context({"input": "今天天气如何?"}, {"output": "晴天,25度"})
# 读取记忆，Token未超限，返回完整对话
print(memory.load_memory_variables({}))
# 若将max_token_limit改为10，Token超限，返回空的history

4.2 ConversationSummaryMemory：智能摘要的压缩记忆

无论是窗口记忆还是Token记忆，都是通过截断历史来控制规模，可能会丢失一些关键信息。而ConversationSummaryMemory则采用智能摘要的方式，通过大模型对对话历史进行精简总结，将冗长的原始对话转化为简短的摘要，既减少了Token消耗，又保留了核心上下文信息，是长对话场景的优选方案。

核心特点

1. 智能摘要：利用大模型生成对话历史的精简摘要，替代原始对话存储；
2. 动态更新：每新增一轮对话，都会将旧摘要与新对话合并，生成新的摘要，保持摘要的时效性；
3. 上下文优化：保留核心信息，避免因截断导致的关键信息丢失。

典型使用场景

场景1：无历史消息，直接初始化

from langchain.memory import ConversationSummaryMemory
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")
# 初始化摘要记忆
memory = ConversationSummaryMemory(llm=llm)
# 保存多轮对话
memory.save_context({"input": "你好"}, {"output": "怎么了"})
memory.save_context({"input": "你是谁"}, {"output": "我是AI助手小智"})
# 读取记忆，返回对话摘要
print(memory.load_memory_variables({}))
# 输出：{'history': 'The human greets the AI by saying hello, and the AI responds by asking what's wrong. The human then asks who the AI is, and the AI replies that it is AI assistant Xiao Zhi.'}

场景2：已有历史消息，基于历史生成摘要

from langchain.memory import ConversationSummaryMemory, ChatMessageHistory
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")
# 已有历史消息
history = ChatMessageHistory()
history.add_user_message("你好,你是谁?")
history.add_ai_message("我是AI助手小智")
# 基于历史消息初始化摘要记忆
memory = ConversationSummaryMemory.from_messages(llm=llm, chat_memory=history)
# 新增对话并更新摘要
memory.save_context({"input": "我的名字叫小明"}, {"output": "很高兴认识你"})
print(memory.load_memory_variables({}))
# 输出包含新对话的完整摘要

4.3 ConversationSummaryBufferMemory：混合记忆的最优解

ConversationSummaryBufferMemory是ConversationBufferMemory和ConversationSummaryMemory的混合体，结合了两者的优点：对最近的对话保留原始格式，确保最新交互的完整上下文；对超出Token限制的较早对话生成摘要，避免信息过载。这种混合机制既保证了对话的连贯性，又有效控制了Token消耗，是大多数复杂长对话场景的最优选择。

核心特点

1. 混合策略：近对话存原始，远对话存摘要，平衡细节与效率；
2. Token阈值控制：通过max_token_limit设置Token上限，超出时自动对较早对话生成摘要；
3. 格式灵活：支持return_messages参数，可返回消息对象列表或纯文本。

典型使用：电商客服场景（实际业务高频场景）

from langchain.memory import ConversationSummaryBufferMemory
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.chains.llm import LLMChain

# 初始化大模型
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.5)
# 定义电商客服Prompt模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是电商客服助手,用中文友好回复用户问题,保持专业亲切。"),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}")
])
# 初始化混合记忆，max_token_limit=400
memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=400,
    memory_key="chat_history",
    return_messages=True
)
# 集成到链
chain = LLMChain(llm=llm, prompt=prompt, memory=memory)

# 模拟电商客服多轮对话
dialogues = [
    "你好,我想查询订单12345的状态",
    "这个订单是上周五下的",
    "我现在急着用,能加急处理吗",
    "我记错订单号了,应该是12346",
    "你们的退货政策是怎样的"
]
# 执行对话
for msg in dialogues:
    res = chain.invoke({"input": msg})
    print(f"用户：{msg}\n客服：{res['text']}\n")

# 查看记忆状态：较早的订单查询对话生成摘要，最新的退货政策对话保留原始
print(memory.load_memory_variables({}))

该场景中，用户的多轮对话既有订单查询的寒暄与细节，也有退货政策的核心问题，混合记忆会自动对较早的订单查询生成摘要，保留最新的退货政策对话原始信息，既保证了客服能准确理解用户需求，又控制了Token消耗。

4.4 专业场景记忆模块：实体、知识图谱、向量检索

除了上述常用的高级记忆模块，LangChain还针对需要结构化存储、语义检索、复杂关系分析的专业场景，设计了专属的Memory模块，这类模块虽不常用，但在医疗、金融、智能客服等高端场景中能发挥重要作用。

4.4.1 ConversationEntityMemory：基于实体的结构化记忆

该模块能智能识别对话中的实体信息（人名、地点、产品、症状等），并以结构化字典的形式存储实体及其属性/关系，而非自然语言摘要。核心优势是避免关键信息丢失，可通过代码强制检查实体信息，适合医疗、金融等对关键信息准确性要求极高的场景。

比如医疗场景中，模型能精准提取患者的症状、血压、用药、过敏史等实体信息，结构化存储后，后续推荐药物时可直接通过代码检查过敏史，避免推荐过敏药物，而普通的摘要记忆则可能因模型注意力问题忽略过敏信息。

4.4.2 ConversationKGMemory：基于知识图谱的关系记忆

在实体记忆的基础上，进一步捕捉实体之间的复杂关系，将对话内容转化为**(头实体, 关系, 尾实体)** 的三元组形式，构建结构化的知识网络。比如“山姆是我的朋友”会被转化为(山姆, 是, 我的朋友)，“山姆最喜欢的颜色是红色”转化为(山姆, 最喜欢的颜色是, 红色)，能实现更复杂的关系推理与上下文理解。

4.4.3 VectorStoreRetrieverMemory：基于向量检索的语义记忆

将对话历史存储在向量数据库中，通过语义相似度检索替代传统的线性记忆读取。每次用户提问时，会将问题向量化，在向量数据库中检索与问题语义最相关的历史对话，仅将相关历史传入模型，适合超长篇对话、长期记忆、需要语义理解的复杂场景，比如智能助手、知识库问答等。

五、LangChain Memory 模块选型指南

LangChain提供了丰富的Memory模块，不同模块适用于不同的场景，开发者在实际开发中需根据对话长度、Token消耗、业务需求、信息准确性要求等因素选择合适的模块，以下是核心选型参考：

记忆模块	核心特点	适用场景	优点	缺点
ConversationBufferMemory	完整存储原始对话	短对话、依赖完整上下文的简单场景	简单、无信息丢失	长对话Token消耗高、易超限
ConversationBufferWindowMemory	保留最近k轮对话	中短对话、需控制轮次的场景	轻量、控制简单	可能丢失关键历史信息
ConversationTokenBufferMemory	基于Token精准控制	对Token消耗敏感的中短对话	Token控制精准、保留原始	截断可能丢失关键信息
ConversationSummaryMemory	智能摘要压缩历史	长对话、无需保留原始细节的场景	大幅减少Token、保留核心	摘要可能丢失细微信息
ConversationSummaryBufferMemory	近对话存原始、远对话存摘要	大多数长对话场景（电商客服、智能助手）	平衡细节与效率、Token友好	略复杂、需绑定LLM
ConversationEntityMemory	结构化存储实体信息	医疗、金融等关键信息精准要求高的场景	信息结构化、可强制检查	配置复杂、仅关注实体
ConversationKGMemory	知识图谱存储实体关系	需复杂关系推理的专业场景	关系结构化、推理能力强	配置复杂、Token消耗较高
VectorStoreRetrieverMemory	向量检索语义记忆	超长篇对话、长期记忆、语义问答场景	语义检索、长期记忆	依赖向量数据库、配置复杂

通用选型建议：

1. 简单短对话：直接使用ConversationBufferMemory或ConversationChain；
2. 中长对话常规场景：优先选择ConversationSummaryBufferMemory（混合记忆，最优解）；
3. 对Token消耗极致控制：使用ConversationTokenBufferMemory；
4. 专业精准场景（医疗/金融）：使用ConversationEntityMemory；
5. 超长篇/语义理解场景：使用VectorStoreRetrieverMemory。

六、总结

LangChain的Memory组件是解决大模型记忆困境的核心方案，它通过一套完整的记忆体系，实现了对话历史的存储、管理、优化与利用，让大模型从“无记忆的单次交互”升级为“有记忆的连续对话”，是构建智能大模型应用的必备模块。