LangChain 实战：大模型对话记忆模块

2.1 基础款：ConversationBufferMemory（完整记忆）

最核心的记忆组件，保存所有对话历史，是其他记忆类型的基础：

from langchain.memory import ConversationBufferMemory

# 初始化记忆（return_messages=True：以消息对象存储，更易复用）
memory = ConversationBufferMemory(return_messages=True)

# 保存第一轮对话
memory.save_context({"input": "我的名字是陆天宇"}, {"output": "你好，陆天宇！"})

# 保存第二轮对话
memory.save_context({"input": "我是 AI 开发者"}, {"output": "太酷了！我们是同行～"})

# 加载记忆（查看历史对话）
print("记忆中的历史对话：")
print(memory.load_memory_variables({}))

输出结果：

记忆中的历史对话： {'history': [HumanMessage(content='我的名字是陆天宇'), AIMessage(content='你好，陆天宇！'), HumanMessage(content='我是 AI 开发者'), AIMessage(content='太酷了！我们是同行～')]} 

2.2 进阶款：窗口记忆与总结记忆

（1）ConversationBufferWindowMemory（窗口记忆）

只保留最近 k 轮对话，避免上下文过长：

from langchain.memory import ConversationBufferWindowMemory

# k=1：只保留最近 1 轮对话
memory = ConversationBufferWindowMemory(k=1, return_messages=True)
memory.save_context({"input": "名字是陆天宇"}, {"output": "你好"})
memory.save_context({"input": "是 AI 开发者"}, {"output": "同行"})

# 加载记忆（仅保留最后 1 轮）
print(memory.load_memory_variables({}))
# 输出：{'history': [HumanMessage(content='是 AI 开发者'), AIMessage(content='同行')]}

（2）ConversationSummaryMemory（总结记忆）

将长对话总结为文本，大幅节省 Token：

from langchain.memory import ConversationSummaryMemory
from langchain_openai import ChatOpenAI
import os

# 初始化模型（用于总结对话）
model = ChatOpenAI(
    model="qwen3.5-plus",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    openai_api_base="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# 初始化总结记忆
memory = ConversationSummaryMemory(llm=model, return_messages=True)
memory.save_context({"input": "名字是陆天宇，是 AI 开发者，专注 NLP 方向"}, {"output": "记住了你的信息～"})

# 加载记忆（已自动总结）
print(memory.load_memory_variables({}))
# 输出：{'history': [SystemMessage(content='陆天宇介绍自己是专注 NLP 方向的 AI 开发者，AI 表示记住了相关信息。')]}

三、实战 1：LangChain 记忆链（ConversationChain）

ConversationChain 是 LangChain 封装的'记忆 + 模型'组合链，无需手动保存 / 加载记忆，自动处理上下文：

from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
import os

# 1. 初始化模型
model = ChatOpenAI(
    model="qwen3.5-plus",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    openai_api_base="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# 2. 初始化记忆
memory = ConversationBufferMemory(return_messages=True)

# 3. 创建记忆链（自动关联模型和记忆）
chain = ConversationChain(llm=model, memory=memory)

# 4. 第一轮对话
resp1 = chain.invoke({"input": "我的名字是陆天宇"})
print("AI 回复 1：", resp1["response"])

# 5. 第二轮对话（带上下文）
resp2 = chain.invoke({"input": "你知道我的名字吗？"})
print("AI 回复 2：", resp2["response"])

输出结果：

AI 回复 1： 你好，陆天宇！很高兴认识你～
AI 回复 2： 当然知道啦，你的名字是陆天宇呀 😊 

四、实战 2：Streamlit 搭建带记忆的聊天 Web 应用

基于 Streamlit 快速实现带记忆的聊天界面，模仿 ChatGPT 交互：

4.1 项目结构

chat-app/
├── app.py # 前端页面逻辑
└── scripts.py # 后端模型调用逻辑

4.2 后端逻辑（scripts.py）

from langchain.chains import ConversationChain
from langchain_openai import ChatOpenAI

def get_chat_response(prompt, memory, api_key):
    # 初始化模型
    model = ChatOpenAI(
        model="qwen3.5-plus",
        openai_api_key=api_key,
        openai_api_base="https://dashscope.aliyuncs.com/compatible-mode/v1"
    )
    # 创建记忆链
    chain = ConversationChain(llm=model, memory=memory)
    # 调用模型
    response = chain.invoke({"input": prompt})
    return response["response"]

4.3 前端逻辑（app.py）

import streamlit as st
from langchain.memory import ConversationBufferMemory
from scripts import get_chat_response

# 页面配置
st.title("💬 带记忆的 AI 聊天助手")
st.sidebar.title("配置")
api_key = st.sidebar.text_input("阿里云 API Key", type="password")

# 初始化会话状态（保存记忆和消息）
if "memory" not in st.session_state:
    st.session_state["memory"] = ConversationBufferMemory(return_messages=True)
    st.session_state["messages"] = [{"role": "ai", "content": "你好，我是你的 AI 助手～"}]

# 渲染历史消息
for msg in st.session_state["messages"]:
    st.chat_message(msg["role"]).write(msg["content"])

# 处理用户输入
prompt = st.chat_input("请输入你的问题...")
if prompt:
    if not api_key:
        st.warning("请先输入 API Key！")
        st.stop()
    
    # 添加用户消息
    st.session_state["messages"].append({"role": "human", "content": prompt})
    st.chat_message("human").write(prompt)
    
    # 调用 AI 回复
    with st.spinner("AI 思考中..."):
        response = get_chat_response(prompt, st.session_state["memory"], api_key)
        
    # 添加 AI 消息
    st.session_state["messages"].append({"role": "ai", "content": response})
    st.chat_message("ai").write(response)

4.4 运行应用

# 安装依赖
pip install streamlit langchain langchain-openai

# 运行应用
streamlit run app.py

运行后访问 http://localhost:8501，即可体验带上下文记忆的聊天界面。

五、学习总结 & 避坑指南

5.1 核心知识点总结

1. 记忆本质：LangChain 的记忆模块本质是'保存对话历史→拼接上下文→传给模型'的封装，核心解决大模型'无状态'的问题；
2. 核心组件：ConversationBufferMemory 是基础，其他记忆类型均为其优化（窗口、总结、Token 限制）；
3. 链式调用：ConversationChain 自动关联'记忆 + 模型'，无需手动保存 / 加载记忆，是最常用的简化方式；
4. 工程化：结合 Streamlit 可快速实现可视化应用，会话状态（st.session_state）是保存跨刷新数据的核心。

5.2 避坑指南

1. API Key 问题：避免硬编码 API Key，优先使用环境变量（os.getenv）或前端输入；
2. 模型兼容问题：调用通义千问等非 OpenAI 模型时，需指定 openai_api_base，且模型名称要准确（如 qwen3.5-plus）；
3. Token 计数报错：使用 ConversationSummaryBufferMemory/ConversationTokenBufferMemory 时，需自定义 get_num_tokens_from_messages 函数（解决 NotImplementedError）；
4. 会话状态丢失：Streamlit 应用中，记忆和消息必须存在 st.session_state 中，否则刷新页面会丢失历史。

最后

LangChain 的记忆模块是大模型应用开发的核心基础，掌握不同记忆类型的适用场景，能大幅提升 AI 应用的交互体验。从手动实现记忆到封装链，再到前端可视化，一套完整的学习路径能帮助我们快速落地实际应用。后续可进一步学习记忆的持久化（保存到数据库）、多轮对话总结优化等进阶内容。