ChatGLM3-6B多轮对话实战教程：上下文记忆保持与追问逻辑设计

1. 引言：为什么我们需要一个“记性好”的本地助手？

想象一下，你正在和一个助手讨论一个复杂的编程问题。你刚花了五分钟解释完项目的背景和遇到的第一个错误，当你接着问“那第二个错误该怎么解决？”时，它却一脸茫然地反问你：“什么第二个错误？我们刚才在聊什么？”

这就是传统对话模型常犯的“健忘症”。对于需要连续思考、层层递进的深度对话来说，上下文记忆的缺失是致命的。

今天，我们要动手搭建的，就是一个能彻底解决这个问题的智能助手。它基于智谱AI开源的 ChatGLM3-6B-32k 模型，拥有处理长达32000个token（约2.4万汉字）上下文的能力。这意味着，它可以记住一整场长达数小时的深度对话，或者一次性分析一篇万字长文。

更重要的是，我们将它完全部署在你的本地电脑上，利用 Streamlit 打造一个零延迟、高稳定的交互界面。你的所有对话、代码、文档，都只在你的显卡和内存中流转，无需担心隐私泄露。无论你是想进行多轮技术探讨、分析长文档，还是单纯想要一个永不遗忘的聊天伙伴，这个项目都能满足你。

本教程将手把手带你完成部署，并深入剖析其实现多轮对话与上下文记忆的核心逻辑。你会发现，让AI“记住”并“理解”连续的对话，并没有想象中那么复杂。

2. 环境准备与一键式部署

我们的目标是快速跑起来，而不是在环境配置上耗费半天。得益于项目的深度重构，部署过程变得异常简单。

2.1 核心装备检查

在开始之前，请确保你的电脑满足以下条件：

• 操作系统：Linux (Ubuntu 20.04+ 推荐) 或 Windows (WSL2 推荐)。
• 显卡：至少拥有 16GB 显存的 NVIDIA GPU（如 RTX 4090D, RTX 3090, A100 等）。ChatGLM3-6B 模型本身对显存要求约为 13GB，32k长上下文版本需要更多显存用于存储历史记录。
• 内存：建议 32GB 或以上。
• Python：版本 3.8 到 3.10。

2.2 三步完成部署

项目已经锁定了所有关键依赖的完美版本，避免了令人头疼的兼容性问题。你只需要按顺序执行以下命令：

# 1. 克隆项目代码到本地
git clone https://github.com/your-repo/ChatGLM3-6B-Streamlit.git
cd ChatGLM3-6B-Streamlit

# 2. 创建Python虚拟环境（强烈推荐，避免污染系统环境）
python -m venv venv
# Linux/Mac
source venv/bin/activate
# Windows
venv\Scripts\activate

# 3. 安装精准锁定的依赖包（这是稳定性的关键！）
pip install -r requirements.txt

这个 requirements.txt 文件是项目的“定海神针”，里面明确锁定了：

• transformers==4.40.2：这是与 ChatGLM3-6B-32k 模型配合最佳的版本，新版反而可能有bug。
• torch + CUDA 版本：匹配你的显卡驱动。
• streamlit：我们的轻量级Web框架。
• 其他必要库如 sentencepiece, cpm_kernels 等。

安装过程如果遇到网络问题，可以考虑使用国内镜像源，例如在 pip 命令后加上 -i https://pypi.tuna.tsinghua.edu.cn/simple。

3. 核心概念：对话上下文是如何被“记住”的？

在写代码之前，我们先用人话搞清楚两个核心概念：Token 和 上下文窗口。这是理解多轮对话的基础。

3.1 Token：模型眼中的“文字碎片”

模型不是直接读汉字或英文单词的。它会先把你的句子切分成更小的单元，叫做 Token。

• 对于英文，一个单词可能被切成一个或多个Token（例如，“chatting” 可能被切成 “chat” 和 “ting”）。
• 对于中文，一个字通常就是一个Token，但复杂的词或标点也可能被单独处理。

“32k上下文”是什么意思？ 这里的“32k”指的就是 32,000个Token。你可以把它想象成模型短期记忆的“容量槽”。每一次对话，模型都会把：

1. 你本次的提问（Prompt）
2. 它自己之前的所有回复（History）
3. 以及可能的系统指令（System Instruction）

所有这些内容转换成Token后，一起塞进这个容量槽里进行处理。槽满了（超过32k），最早的一些记忆就会被“挤出去”，模型就开始“遗忘”了。

3.2 对话历史（History）的格式

模型是如何区分“你一句话，我一句话”的呢？它依靠一个结构化的列表来记录对话历史。通常的格式是这样的：

# 这是一段对话历史的示例，每个回合都是一条字典记录
conversation_history = [
    {"role": "user", "content": "Python里怎么读取CSV文件？"},
    {"role": "assistant", "content": "你可以使用pandas库的read_csv函数，非常方便。"},
    {"role": "user", "content": "如果我想只要前10行数据呢？"}, # 模型看到这里时，它也能看到上面的历史
]

当用户提出第三个问题（“如果我想只要前10行数据呢？”）时，模型接收到的输入不仅仅是这一个问题，而是整个 conversation_history 列表。这样，它就知道“前10行数据”指的是CSV文件的前10行，而不是别的什么东西。

这就是多轮对话的核心：将完整的历史记录，而不仅仅是当前问题，作为每次生成回答的输入。

4. 实战：构建带记忆的Streamlit对话应用

现在，我们进入最激动人心的部分——写代码。我们将用Streamlit构建一个Web界面，并实现上下文记忆功能。

4.1 应用骨架与模型加载

首先，我们创建主程序文件 app.py。

# app.py
import streamlit as st
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 设置页面标题和图标
st.set_page_config(page_title="ChatGLM3-6B 智能助手", page_icon="", layout="wide")

# 在侧边栏添加标题和说明
with st.sidebar:
    st.title("🧠 ChatGLM3-6B 本地助手")
    st.markdown("""
    **特性说明：**
    - 💾 100% 本地运行，隐私无忧
    - 🧵 支持长达32k上下文的多轮对话
    - ⚡ 基于Streamlit，响应迅速
    """)
    st.divider()
    if st.button("清空对话历史"):
        st.session_state.messages = [] # 清空历史
        st.rerun()

# 使用Streamlit的缓存机制，模型只加载一次，永久驻留内存
@st.cache_resource
def load_model():
    """加载ChatGLM3-6B模型和分词器"""
    model_name = "THUDM/chatglm3-6b-32k" # 使用32k长上下文版本
    st.info(f"正在加载模型 {model_name}，首次加载需要几分钟，请耐心等待...")
    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        trust_remote_code=True,
        torch_dtype=torch.float16, # 半精度加载，节省显存
        device_map="auto" # 自动分配模型层到GPU/CPU
    ).eval() # 设置为评估模式，关闭dropout等训练层
    st.success("模型加载成功！")
    return tokenizer, model

# 加载模型
tokenizer, model = load_model()

关键点解析：

1. @st.cache_resource：这是Streamlit的魔法装饰器。它让 load_model() 函数的结果（即模型和分词器）在应用运行期间只执行一次并缓存起来。即使你刷新浏览器页面，也无需重新加载几个GB的模型，实现“即开即聊”。
2. device_map=”auto”：让 transformers 库自动决定将模型的每一层放在GPU还是CPU上，对于大模型非常友好。
3. torch.float16：半精度浮点数，能在几乎不损失精度的情况下将显存占用和计算量减半。

4.2 实现对话历史管理与流式输出

接下来，我们初始化对话历史，并创建主要的聊天界面。

# 初始化对话历史，存储在st.session_state中（Streamlit的会话状态）
if "messages" not in st.session_state:
    st.session_state.messages = [] # 这里将存储我们之前提到的 {role, content} 字典列表

# 显示历史聊天记录
for message in st.session_state.messages:
    with st.chat_message(message["role"]): # 根据角色（user/assistant）显示不同头像
        st.markdown(message["content"])

# 接收用户当前输入
if prompt := st.chat_input("请输入您的问题..."):
    # 1. 将用户输入添加到历史记录并显示
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)

    # 2. 准备生成助理的回复
    with st.chat_message("assistant"):
        message_placeholder = st.empty() # 创建一个占位符，用于流式输出
        full_response = ""

        # 3. 构建模型所需的输入格式：将整个历史记录拼接成一段文本
        # ChatGLM3有特定的对话模板，例如： “[Round 1]\n问：{用户问题1}\n答：{助理回答1}\n[Round 2]\n问：{用户问题2}”
        # 这里我们使用tokenizer提供的build_chat_input方法来自动构建
        history_text_for_model = tokenizer.build_chat_input(prompt, history=st.session_state.messages[:-1]) # 注意传入的是当前轮次之前的历史

        # 4. 流式生成回复
        # 将处理好的输入传给模型，并设置生成参数
        inputs = history_text_for_model.to(model.device)
        with torch.no_grad(): # 推理时不计算梯度，节省内存
            for response in model.stream_generate(**inputs, max_length=32000, temperature=0.8):
                # stream_generate 会逐步生成token
                decoded_text = tokenizer.decode(response[0], skip_special_tokens=True)
                # 只提取本轮新生成的部分（避免重复显示历史）
                current_response = decoded_text.split(“答：”)[-1] if “答：” in decoded_text else decoded_text
                # 更新占位符，实现打字机效果
                message_placeholder.markdown(current_response + "▌")
                full_response = current_response

        # 生成完毕，移除光标，显示最终文本
        message_placeholder.markdown(full_response)

    # 5. 将助理的完整回复添加到历史记录中
    st.session_state.messages.append({"role": "assistant", "content": full_response})

关键点解析：

1. st.session_state：这是Streamlit用于在页面重载间保持数据的“记忆体”。我们把 messages 列表存在这里，保证了对话历史的持续性。
2. tokenizer.build_chat_input：这是ChatGLM3 tokenizer的一个便捷方法，它帮我们自动把 [ {role:”user”, content:…}, {role:”assistant”, content:…} ] 这样的历史列表，转换成模型能理解的、带有 [Round N] 标记的文本格式。这是上下文记忆功能得以实现的关键桥梁。
3. model.stream_generate：这个方法允许我们逐Token地获取模型的输出，而不是等全部生成完再返回。我们将每个中间结果实时更新到前端的 message_placeholder，就实现了类似打字机的“流式输出”体验，大大提升了交互感。
4. 记忆的传递：注意看第3步，我们构建输入时传入的 history 参数是 st.session_state.messages[:-1]。这意味着，模型在生成当前回答时，能看到除了本轮用户提问之外的所有历史对话。本轮的用户提问（prompt）则作为新的问题被单独加入模板。这样，每一轮对话，历史都在增长。

4.3 运行你的智能助手

保存好 app.py 文件后，在终端运行以下命令：

streamlit run app.py

Streamlit会自动在本地启动一个Web服务器（通常是 http://localhost:8501），并打开你的浏览器。现在，你就可以开始和你的私人智能助手进行多轮对话了！试试问它一个复杂的问题，并在后续提问中引用之前的答案，看看它是否真的“记得”。

5. 追问逻辑设计与高级技巧

基本的记忆功能已经实现，但一个优秀的对话系统还需要更智能的追问和上下文管理能力。

5.1 设计高效的上下文窗口管理

32k的容量很大，但并非无限。在长时间对话后，历史记录可能会超出限制。我们需要一个“滑动窗口”策略。

def manage_context_window(messages, tokenizer, max_tokens=30000):
    """
    管理上下文窗口，当历史Token数接近上限时，从最旧的消息开始删除。
    保留最新的系统指令和足够多的最近对话。
    """
    total_tokens = 0
    # 从最新消息开始反向计算Token数
    for i in range(len(messages)-1, -1, -1):
        msg_tokens = len(tokenizer.encode(messages[i]["content"]))
        total_tokens += msg_tokens
        if total_tokens > max_tokens:
            # 如果超出，则删除当前及更早的消息（保留索引i之后的消息）
            return messages[i+1:]
    return messages

# 在每次构建模型输入前，可以调用此函数进行修剪
# processed_history = manage_context_window(st.session_state.messages, tokenizer)
# history_text_for_model = tokenizer.build_chat_input(prompt, history=processed_history)

这个函数确保对话始终在模型的处理能力范围内，优先丢弃最久远的、可能已不相关的对话片段。

5.2 实现指代消解与追问增强

用户常说“它”、“这个方法”、“上面那个错误”。好的对话系统应该能理解这些指代。

虽然ChatGLM3本身具备一定的指代消解能力，但我们可以通过在系统指令中明确要求来强化它。修改模型加载部分的输入构建：

# 定义一个系统指令，引导模型更好地利用上下文
SYSTEM_PROMPT = """你是一个有帮助的AI助手。请仔细阅读整个对话历史，再回答用户的最新问题。
特别注意用户问题中的代词（如“它”、“他”、“这个”、“上面提到的”）所指代的内容，确保你的回答与对话历史连贯一致。"""

# 在构建输入时，将系统指令放在最前面
# 注意：ChatGLM3的对话模板可能已包含系统角色，请根据其具体格式调整
# 一种常见方式是将系统提示作为第一条“user”或“system”消息
if len(st.session_state.messages) == 0: # 只在对话开始时插入一次系统指令
    st.session_state.messages.insert(0, {"role": "system", "content": SYSTEM_PROMPT})

5.3 实用调试技巧

如果对话出现逻辑断裂或遗忘，可以打印出实际发送给模型的文本，检查历史是否被正确传递。

# 在构建输入后，解码一下看看模型“看到”了什么
debug_input_ids = history_text_for_model[‘input_ids’]
debug_text = tokenizer.decode(debug_input_ids[0], skip_special_tokens=False)
print(“=== 发送给模型的完整上下文 ===”)
print(debug_text[:1000]) # 打印前1000个字符
print(“=== 结束 ===”)

6. 总结

通过本教程，我们完成了一个功能完整的本地化ChatGLM3-6B多轮对话助手的搭建。我们来回顾一下核心收获：

1. 上下文记忆的本质：多轮对话并非魔法，其核心在于将结构化的对话历史列表，作为每次生成回答的输入。ChatGLM3等现代模型通过其分词器和预定义的对话模板，能够理解并利用这些历史信息。

2. Streamlit的优雅实践：利用 @st.cache_resource 实现模型的单次加载与持久化，利用 st.session_state 保持对话状态，结合 stream_generate 实现流式输出，我们以极少的代码构建了一个高性能、体验佳的Web应用。

3. 工程化考量：我们探讨了上下文窗口管理的重要性，以避免因Token超限导致的“遗忘”，也提到了通过系统指令来增强模型的指代消解和逻辑连贯性能力。

4. 隐私与稳定：整个系统运行于本地，数据不出域，结合锁定的依赖版本，实现了商业级应用所需的隐私安全和运行稳定。

这个项目只是一个起点。你可以在此基础上，增加文件上传（让AI分析你的文档）、代码执行、联网搜索等功能，打造一个真正属于你个人的超级生产力工具。记住，让AI“记住”对话，是开启深度、有效人机协作的第一步。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。