LangChain BaseChatMemory 详解与子类实战

# 方法 1：直接调用 save_context（推荐，简洁）
memory.save_context(
    {"input": "你好"},       # 用户输入
    {"output": "你好！有什么可以帮您？"} # 模型输出
)
# 方法 2：手动添加消息到 chat_memory
memory.chat_memory.add_user_message("你好")      # 添加用户消息
memory.chat_memory.add_ai_message("你好！有什么可以帮您？") # 添加 AI 消息

（2）load_memory_variables()：加载记忆

作用：把保存的对话历史取出来，默认返回一个字典，key 是'history'，value 是对话字符串。 示例：

# 加载记忆
variables = memory.load_memory_variables({})
# 打印对话历史
print(variables["history"])
# 输出结果：
# Human: 你好
# AI: 你好！有什么可以帮您？

（3）clear()：清空记忆

作用：一键清空 chat_memory 里的所有对话消息，相当于'格式化笔记本'。 示例：

# 清空所有记忆
memory.clear()
# 再加载就是空的了
print(memory.load_memory_variables({}))
# 输出：{"history": ""}

四、BaseChatMemory 的常用子类：不用自己写，直接用！

BaseChatMemory 是基类，不能直接用，LangChain 已经帮我们实现了几个常用子类，覆盖大部分场景，直接拿来用就行～

五、子类实战：3 个案例

案例 1：ConversationBufferMemory——存储完整对话

适合短对话，需要保留每一句聊天内容的场景。

# 1. 导入需要的包
from langchain.memory import ConversationBufferMemory

# 2. 初始化记忆（return_messages=True：返回消息对象列表，False 返回字符串）
memory = ConversationBufferMemory(
    memory_key="chat_history",  # 加载记忆时的 key（默认就是"history"）
    return_messages=True         # 这里设为 True，方便看消息类型
)

# 3. 保存对话上下文
memory.save_context({"input": "你的名字是什么？"}, {"output": "我叫工藤助手"})
memory.save_context({"input": "我叫张三"}, {"output": "你好张三！很高兴认识你"})

# 4. 加载并查看记忆
chat_history = memory.load_memory_variables({})["chat_history"]
print("对话记忆：")
for msg in chat_history:
    print(f"类型：{type(msg).__name__}，内容：{msg.content}")
# 输出结果：
# 对话记忆：
# 类型：HumanMessage，内容：你的名字是什么？
# 类型：AIMessage，内容：我叫工藤助手
# 类型：HumanMessage，内容：我叫张三
# 类型：AIMessage，内容：你好张三！很高兴认识你

# 5. 清空记忆
memory.clear()
print("\n清空后记忆：", memory.load_memory_variables({}))
# 输出：清空后记忆： {'chat_history': []}

案例 2：ConversationBufferWindowMemory——只记最近 k 轮对话

适合长对话，比如聊了 100 轮，只想让模型记住最后 3 轮，避免 token 不够用。

# 1. 导入需要的包
from langchain.memory import ConversationBufferWindowMemory

# 2. 初始化记忆：k=2 表示只保留最近 2 轮对话（一轮用户 + 一轮 AI 为一轮）
memory = ConversationBufferWindowMemory(
    k=2,                      # 窗口大小：最近 2 轮
    memory_key="chat_history",
    return_messages=False     # 返回字符串格式，更直观
)

# 3. 保存 3 轮对话（会自动只留最后 2 轮）
# 第 1 轮
memory.save_context({"input": "今天天气怎么样？"}, {"output": "今天晴天，适合出游"})
# 第 2 轮
memory.save_context({"input": "适合去公园吗？"}, {"output": "适合，公园花开了"})
# 第 3 轮
memory.save_context({"input": "公园要门票吗？"}, {"output": "不需要，免费开放"})

# 4. 加载记忆：只保留最后 2 轮（第 2、3 轮）
chat_history = memory.load_memory_variables({})["chat_history"]
print("窗口内对话记忆：")
print(chat_history)
# 输出结果：
# 窗口内对话记忆：
# Human: 适合去公园吗？
# AI: 适合，公园花开了
# Human: 公园要门票吗？
# AI: 不需要，免费开放

案例 3：ConversationSummaryMemory——用摘要压缩对话

适合超长对话，比如聊了 100 轮，用大模型把历史对话总结成一段话，既省 token 又能保留关键信息。

# 1. 导入需要的包
from langchain.memory import ConversationSummaryMemory
from langchain.chat_models import ChatOpenAI  # 需要大模型来生成摘要

# 2. 初始化大模型（也可以用开源模型，如通义千问、智谱清言）
llm = ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo")

# 3. 初始化记忆：传入大模型用于生成摘要
memory = ConversationSummaryMemory(
    llm=llm,
    memory_key="chat_history",
    return_messages=False
)

# 4. 保存多轮对话
memory.save_context({"input": "我叫张三，想学习微积分"}, {"output": "好的，我会帮你规划学习路径"})
memory.save_context({"input": "微积分先学什么？"}, {"output": "先学极限，这是微积分的基础"})
memory.save_context({"input": "极限怎么学容易？"}, {"output": "多练例题，理解无穷小和无穷大的概念"})

# 5. 加载记忆：返回的是对话摘要，不是原始对话
summary = memory.load_memory_variables({})["chat_history"]
print("对话摘要：")
print(summary)
# 输出结果（大模型生成，简洁保留关键信息）：
# 用户张三表示想学习微积分，助手表示会帮他规划学习路径。用户询问微积分先学什么，助手建议先学极限，因为极限是微积分的基础。用户又问极限怎么学容易，助手建议多练例题，理解无穷小和无穷大的概念。

六、怎么选 BaseChatMemory 子类？一张表搞定！

不知道用哪个子类？看场景选就行，一目了然：

总结

BaseChatMemory 作为 LangChain 聊天记忆的基类，核心是定了'存（save_context）、取（load_memory_variables）、清（clear）'的标准接口，让各种记忆模块有章可循。它的子类不用我们自己写，直接根据场景选：短对话用 ConversationBufferMemory，长对话用窗口记忆，超长对话用摘要记忆。