LangChain 大模型对话记忆模块实战与 Web 应用

LangChain 大模型对话记忆模块实战与 Web 应用

目录

• 前言：为什么需要对话记忆？
• [一、核心认知：原始 API vs LangChain 封装](#一、核心认知：原始 API vs LangChain 封装)
  • [1.1 原生 API 调用的痛点（无记忆）](#1.1 原生 API 调用的痛点无记忆)
  • [1.2 LangChain 的价值：封装记忆与简化调用](#1.2 LangChain 的价值封装记忆与简化调用)
• [二、LangChain 记忆模块核心组件](#二、LangChain 记忆模块核心组件)
  • [2.1 基础款：ConversationBufferMemory（完整记忆）](#2.1 基础款 ConversationBufferMemory 完整记忆)
  • [2.2 进阶款：窗口记忆与总结记忆](#2.2 进阶款窗口记忆与总结记忆)
    • [（1）ConversationBufferWindowMemory（窗口记忆）](#1 ConversationBufferWindowMemory 窗口记忆)
    • [（2）ConversationSummaryMemory（总结记忆）](#2 ConversationSummaryMemory 总结记忆)
• [三、实战 1：LangChain 记忆链（ConversationChain）](#三、实战 1 LangChain 记忆链 ConversationChain)
• [四、实战 2：Streamlit 搭建带记忆的聊天 Web 应用](#四、实战 2 Streamlit 搭建带记忆的聊天 Web 应用)
  • [4.1 项目结构](#4.1 项目结构)
  • [4.2 后端逻辑（scripts.py）](#4.2 后端逻辑 scriptspy)
  • [4.3 前端逻辑（app.py）](#4.3 前端逻辑 apppy)
  • [4.4 运行应用](#4.4 运行应用)
• [五、学习总结 & 避坑指南](#五、学习总结 避坑指南)
  • [5.1 核心知识点总结](#5.1 核心知识点总结)
  • [5.2 避坑指南](#5.2 避坑指南)
• 最后

---

前言：为什么需要对话记忆？

日常使用豆包、ChatGPT 等 AI 应用时，我们习以为常的「上下文记忆」功能（比如问完'林俊杰是谁'再问'他的代表作'，AI 能精准理解），其实并非大模型原生自带。直接调用大模型 API 时，每次请求都是独立的，模型只会基于当前输入的 Token 逐个预测回复，完全没有'记忆'能力，返回的也是包含原始格式的完整响应。

LangChain 作为大模型应用开发的核心框架，已经帮我们封装了对话记忆、Prompt 模板、链式调用等高频功能，无需手动解析原始 API 的复杂输出，也不用自己拼接上下文。

一、核心认知：原始 API vs LangChain 封装

1.1 原生 API 调用的痛点（无记忆）

直接调用大模型 API（即使是通义千问等兼容 OpenAI 接口的模型），每次请求都是'一次性'的，模型无法关联历史对话：

from openai import OpenAI
import os

# 初始化客户端（对接阿里云通义千问）
client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 第一次提问：林俊杰是谁
completion1 = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=[{"role": "user", "content": "林俊杰是谁？"}]
)
print("第一轮回复：", completion1.choices[0].message.content)

# 第二次提问：他有哪些代表作（无上下文，模型无法识别'他'）
completion2 = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=[{"role": "user", "content": "他有哪些代表作？"}]
)
print("第二轮回复：", completion2.choices[0].message.content)

输出结果：第二轮回复会反问'你说的他是谁？'，因为模型没有历史对话的记忆。

1.2 LangChain 的价值：封装记忆与简化调用

LangChain 的核心价值在于：

• 封装对话记忆模块，无需手动拼接上下文；
• 统一不同大模型的调用方式（OpenAI / 通义千问 / 讯飞等）；
• 提供链式调用能力，串联'记忆→Prompt→模型→输出'全流程；
• 自动处理响应格式，直接返回可读的回复内容。

二、LangChain 记忆模块核心组件

LangChain 提供了多种记忆类型，适配不同场景，核心均基于 ConversationBufferMemory 扩展：

记忆类型	核心逻辑	适用场景
ConversationBufferMemory	保存所有对话历史，无长度限制	短对话、需要完整上下文的场景
ConversationBufferWindowMemory	只保存最近 k 轮对话	只需要短期记忆、节省 Token 的场景
ConversationSummaryMemory	将对话历史总结成文本	长对话、需要压缩上下文的场景
ConversationSummaryBufferMemory	短对话保留原文，超长部分总结	兼顾细节和长度的长对话场景
ConversationTokenBufferMemory	按 Token 数限制对话长度	严格控制上下文 Token 消耗的场景

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 应用的交互体验。从手动实现记忆到封装链，再到前端可视化，一套完整的学习路径能帮助我们快速落地实际应用。后续可进一步学习记忆的持久化（保存到数据库）、多轮对话总结优化等进阶内容。