第2章: 记忆管理：让聊天助手多轮不失忆

🤔 为什么需要记忆？

❌ 没有记忆的问题

LLM本身是无状态的！每次调用都是独立的，不记得之前说过什么。

# 没有记忆的对话
llm.invoke("我叫张三")  # AI: 你好张三！
llm.invoke("我叫什么名字？")  # AI: 抱歉，我不知道你的名字
# 👉 AI完全忘记了刚才的对话！

✅ 有记忆的效果

记忆机制让AI记住对话历史，实现真正的多轮对话。

# 有记忆的对话
conversation.predict(input="我叫张三")  # AI: 你好张三！
conversation.predict(input="我叫什么名字？")  # AI: 你叫张三
# 👉 AI记住了之前的对话！

💡 记忆的核心作用

维护上下文：让AI理解对话的来龙去脉
个性化体验：记住用户信息和偏好
连贯对话：实现自然的多轮交互
提升体验：避免重复询问相同问题

📚 记忆类型详解

LangChain提供了多种记忆类型，适应不同的使用场景。

✅ 环境准备 & 如何运行本页代码（强烈建议先看）

本页所有示例代码都可以复制到 memory_x.py 里运行。最常见的问题不是代码写错，而是： IDE 选的 Python 解释器 ≠ 你安装依赖的 Python 环境。

1) 创建并激活虚拟环境（推荐）

# 在你的项目根目录执行
python3 -m venv .venv

# macOS / Linux
source .venv/bin/activate

# Windows PowerShell
# .venv\Scripts\Activate.ps1

2) 安装依赖（用同一个解释器的 pip）

# 关键点：永远用 "python -m pip"，避免 pip 装到另一个 Python 上
python -m pip install -U pip setuptools wheel

# LangChain + Tongyi 依赖（本页示例用到）
python -m pip install langchain langchain-community langchain-core

3) 验证导入是否正常（先验证再跑示例）

python -c "from langchain.chains import ConversationChain; from langchain.memory import ConversationBufferMemory; print('import OK')"

4) 运行示例（建议统一用 python3）

# 例如：运行窗口记忆示例
python3 memory_window.py

5) IDE 里怎么选解释器（非常关键）

在 VS Code / PyCharm 里把 Python Interpreter 切到你刚创建的 .venv。如果你看到 from langchain... 下面有红线，通常就是解释器没选对。

6) Python 3.12 + pcapy 安装报错怎么办？（不降版本）

如果你遇到 Failed to build pcapy / distutils 相关错误，这是 pcapy 自身不兼容 Python 3.12。 不降 Python 版本的做法是换成维护分支 pcapy-ng：

python -m pip install pcapy-ng

如果你的代码里原来写的是 import pcapy，安装 pcapy-ng 后大多数场景仍然可以继续用；若遇到导入差异，再根据项目实际把 import 调整为对应模块名。

1. MessagesPlaceholder + RunnableWithMessageHistory（LCEL 正统做法）💾

特点：把对话历史作为消息列表自动注入到 Prompt 中，适合 LCEL / Runnable 风格的链式调用。

📖 工作原理

通过 RunnableWithMessageHistory 按 session_id 取出历史消息列表，并填充到 MessagesPlaceholder("history") 这个占位符位置。

优点：“历史注入”逻辑清晰，和 LCEL 链天然契合
缺点：历史越长 token 越多（需要配合 window/summary 等策略）
适用：你在用 prompt | llm 这种 Runnable 风格写链

🧩 一句话理解（BufferMemory）

把所有历史原封不动塞进 prompt。好处是“信息不丢”，代价是“越聊越贵、越聊越慢”。

✅ 适用场景

用户咨询流程短（<10轮），但需要完整回看所有细节：例如客服工单、一次性需求澄清、面试模拟。

⚠️ 不适用场景

长对话、长文本输入（例如复盘会议记录、长期陪聊）。这类场景容易出现： Token 爆炸 / 延迟上升 / 成本失控。

🖼️ 图示：所有历史都进入 prompt

import os

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory

# ⚠️ 注意：请使用 python3 运行（macOS 上 /usr/bin/python 可能不是你的 pip 环境）
# python3 memory_placeholder.py

os.environ["DASHSCOPE_API_KEY"] = "your-api-key"

llm = ChatTongyi(model="qwen-turbo", temperature=0.7)

# 关键点1：Prompt 里用 MessagesPlaceholder 预留“消息列表”位置
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个有帮助的助手。"),
        MessagesPlaceholder("history"),
        ("human", "{input}"),
    ]
)

chain = prompt | llm

# 关键点2：用一个 store 存不同 session 的 ChatMessageHistory
store = {}


def get_history(session_id: str) -> ChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]


conversation = RunnableWithMessageHistory(
    chain,
    get_history,
    input_messages_key="input",
    history_messages_key="history",
)

session_id = "user_1"

print("=== 第1轮 ===")
r1 = conversation.invoke(
    {"input": "我叫张三，是一名Python开发者"},
    config={"configurable": {"session_id": session_id}},
)
print("AI:", r1.content, "\n")

print("=== 第2轮 ===")
r2 = conversation.invoke(
    {"input": "我的职业是什么？"},
    config={"configurable": {"session_id": session_id}},
)
print("AI:", r2.content, "\n")

print("=== 第3轮 ===")
r3 = conversation.invoke(
    {"input": "我叫什么名字？"},
    config={"configurable": {"session_id": session_id}},
)
print("AI:", r3.content, "\n")

print("=== 当前 history messages ===")
print(store[session_id].messages)

🔍 MessagesPlaceholder 和 "history" 深度解析

🤔 为什么要用 MessagesPlaceholder？

核心问题：LLM 每次调用都是独立的，不记得之前说过什么。我们需要把历史对话塞进 Prompt 里。

                        # 没有 MessagesPlaceholder 的写法（错误❌）

                        prompt = "你是有帮助的助手。历史对话：[这里要手动塞历史] 用户说：{input}"

                        # 有 MessagesPlaceholder 的写法（正确✅）

                        MessagesPlaceholder("history")  ← 自动处理格式和位置

MessagesPlaceholder 的作用：专门用来插入消息列表，确保格式正确。

🔑 "history" 这个名字是随便起的吗？

不是随便起的！"history" 必须在三个地方保持一致：

❌ 错误示例（名字不一致）

                                # Prompt 中用 "history"

                                MessagesPlaceholder("history")

                                # 配置中用 "chat_history"

                                history_messages_key="chat_history"

                                # 🚨 结果：找不到数据！

✅ 正确示例（名字一致）

                                # Prompt 中用 "history"

                                MessagesPlaceholder("history")

                                # 配置中用 "history"

                                history_messages_key="history"

                                # ✅ 结果：数据正确注入！

� 三处统一的 "history"

第1处：Prompt 模板声明

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是有帮助的助手"),
    MessagesPlaceholder("history"),  ← 第1处：占位符名称
    ("human", "{input}"),
])
                        

第2处：RunnableWithMessageHistory 配置

conversation = RunnableWithMessageHistory(
    chain, get_history,
    history_messages_key="history",  ← 第2处：配置键名
)
                        

第3处：运行时数据传递

# RunnableWithMessageHistory 自动生成：
{
    "history": [HumanMessage(...), AIMessage(...)],  ← 第3处：实际数据
    "input": "我叫什么名字？"
}
                        

🔄 实际运行过程演示

用户调用：

conversation.invoke(
    {"input": "我叫什么名字？"},
    config={"configurable": {"session_id": "user_1"}}
)
                        

RunnableWithMessageHistory 内部处理：

# 1. 根据 session_id="user_1" 获取历史
history = get_history("user_1")  # 返回 ChatMessageHistory

# 2. 构建 prompt 数据
prompt_data = {
    "history": history.messages,  ← 这里填入实际消息列表
    "input": "我叫什么名字？"
}

# 3. 调用 prompt 模板
# MessagesPlaceholder("history") 被替换为 history.messages
                        

最终 Prompt：

System: 你是有帮助的助手
History: Human: 我叫张三\nAI: 你好张三！\nHuman: 我是Python开发者\nAI: 很棒！
Human: 我叫什么名字？
                        

💡 可以换成其他名字吗？

可以！但必须三处统一。比如换成 "chat_history"：

                        # 三处都改成 "chat_history"

                        MessagesPlaceholder("chat_history")

                        history_messages_key="chat_history"

                        # 运行时数据变成：{"chat_history": [消息列表]}

总结：MessagesPlaceholder 就是预留位置，"history" 是数据键名，两者配合实现动态历史注入。

📦 ConversationBufferMemory 是什么？

ConversationBufferMemory 是 LangChain 早期/传统（Chain API）里的记忆组件：它会把所有历史对话拼成一段文本（memory.buffer），并在每次调用 ConversationChain 时自动把这段历史注入到 prompt 里。

什么时候用它？ 如果你在写 ConversationChain（而不是 prompt | llm 这种 LCEL），用 BufferMemory 最省事。但它也有代价：对话越长，token 越多（需要时可换 Window/Summary）。

import os

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
from langchain_community.chat_models import ChatTongyi

# ⚠️ 注意：请使用 python3 运行
# python3 memory_buffer.py

os.environ["DASHSCOPE_API_KEY"] = "your-api-key"

llm = ChatTongyi(model="qwen-turbo", temperature=0.7)

# BufferMemory：完整保存所有对话历史（对话越长，token 越多）
memory = ConversationBufferMemory()

conversation = ConversationChain(llm=llm, memory=memory, verbose=True)

print(conversation.predict(input="我叫张三，是一名Python开发者"))
print(conversation.predict(input="我的职业是什么？"))
print(conversation.predict(input="我叫什么名字？"))

print("\n=== memory.buffer ===")
print(memory.buffer)

✅ 运行结果

=== 第1轮 ===
> Prompt after formatting:
Current conversation:

Human: 我叫张三，是一名Python开发者
AI: 你好张三！很高兴认识你。作为Python开发者，你一定对编程很有热情...

=== 第2轮 ===
> Prompt after formatting:
Current conversation:
Human: 我叫张三，是一名Python开发者
AI: 你好张三！很高兴认识你...
Human: 我的职业是什么？
AI: 你是一名Python开发者。

=== 第3轮 ===
AI: 你叫张三。

=== 记忆内容 ===
{'history': 'Human: 我叫张三，是一名Python开发者\nAI: 你好张三！...\nHuman: 我的职业是什么？\nAI: 你是一名Python开发者。\nHuman: 我叫什么名字？\nAI: 你叫张三。'}
👉 所有对话都被完整保存！

2. ConversationBufferWindowMemory - 滑动窗口记忆 🪟

特点：只保留最近K轮对话，节省Token。

📖 工作原理

只保留最近的K轮对话，旧的对话会被自动丢弃。

优点：Token消耗可控，不会无限增长
缺点：会丢失较早的对话信息
适用：长对话、只需要近期上下文的场景

🧩 一句话理解（WindowMemory）

只记住最近 K 轮。像聊天窗口一样“只看最近消息”，能把成本控制住，但早期信息可能被忘。

✅ 适用场景

用户和你聊很久，但你只需要关心最近几轮：例如问答助手、代码修改协作、实时咨询。

⚠️ 不适用场景

用户在前面说过的身份/约束/偏好必须一直有效：例如长期陪伴、个性化助手、医疗/法律等强约束场景。

🖼️ 图示：窗口滑动，旧消息被丢弃

import os

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferWindowMemory
from langchain.prompts import PromptTemplate
from langchain_community.chat_models import ChatTongyi

# ⚠️ 注意：请使用 python3 运行
# python3 memory_window.py

os.environ["DASHSCOPE_API_KEY"] = "your-api-key"

llm = ChatTongyi(model="qwen-turbo", temperature=0.7)

# WindowMemory：只保留最近 k 轮（约 2k 条 message：user+ai）
memory = ConversationBufferWindowMemory(k=2)

# 关键点：用一个“更严格”的 prompt，避免模型凭常识乱猜
# 只允许基于 {history} 回答；如果历史里没有，就说不知道。
prompt = PromptTemplate(
    input_variables=["history", "input"],
    template=(
        "你是一个严谨的助手。\n"
        "规则：只能根据【对话历史】回答；不要猜测、不要脑补。\n"
        "如果【对话历史】里没有答案，必须回答：\"我不知道\"。\n"
        "并且：除非用户明确提问，否则不要在回复里重复用户的姓名/职业等身份信息。\n\n"
        "【对话历史】\n{history}\n\n"
        "【用户问题】\n{input}"
    ),
)

conversation = ConversationChain(llm=llm, memory=memory, prompt=prompt, verbose=True)

print("第1轮:")
print(conversation.predict(input="我叫张三，是一名Python开发者"))

print("\n第2轮:")
print(conversation.predict(input="我今年30岁"))

print("\n第3轮:")
print(conversation.predict(input="我住在北京"))

print("\n第4轮:")
print(conversation.predict(input="我喜欢跑步"))

print("\n第5轮 - 测试记忆:")
print(conversation.predict(input="我叫什么名字？我的职业是什么？"))

print("\n=== memory.buffer（窗口内当前历史）===")
print(memory.buffer)

✅ 运行结果

第5轮 - 测试记忆:
AI: 我不知道。

=== 当前记忆 ===
Human: 我住在北京
AI: （确认收到）
Human: 我喜欢跑步
AI: （确认收到）
👉 只保留了最近2轮对话（第3、4轮），第1轮里的“张三/Python开发者”已经不在窗口里，所以第5轮必须回答“不知道”。

💡 使用官方类的优势

自动管理：不需要手动实现 trim_window 逻辑
内置优化：官方类已经优化了性能和内存使用
标准化：使用 LangChain 标准接口，易于维护
功能完整：支持 save_context、load_memory、clear 等方法

3. ConversationSummaryMemory - 摘要记忆 📝

特点：使用LLM总结历史对话，压缩信息。

📖 工作原理

随着对话进行，使用LLM将历史对话总结成简短的摘要，保留关键信息。

优点：保留关键信息，Token消耗可控
缺点：需要额外调用LLM，可能丢失细节
适用：长对话、需要保留关键信息的场景

🧩 一句话理解（SummaryMemory）

把“很长的历史”压缩成一段摘要。模型每次只读“摘要 + 当前输入”，从而把 Token 控制住。

✅ 适用场景

长期对话里只需要记住“事实”：姓名、职业、偏好、长期目标。例如长期助手、学习教练、用户画像。

⚠️ 风险点

摘要是“二次创作”，可能把细节总结错。生产中要配合：摘要可追溯（保留原文）、摘要版本、以及抽样回放。

🖼️ 图示：历史被压缩成 summary

import os

from langchain.chains import ConversationChain
from langchain.memory import ConversationSummaryMemory
from langchain_community.chat_models import ChatTongyi

# ⚠️ 注意：请使用 python3 运行
# python3 memory_summary.py

os.environ["DASHSCOPE_API_KEY"] = "your-api-key"

llm = ChatTongyi(model="qwen-turbo", temperature=0.7)

# SummaryMemory：用 LLM 把历史压缩成一段摘要文本
memory = ConversationSummaryMemory(llm=llm)

conversation = ConversationChain(llm=llm, memory=memory, verbose=True)

print(conversation.predict(input="我叫张三，是一名Python开发者，今年30岁"))
print(conversation.predict(input="我住在北京，喜欢看科幻电影"))
print(conversation.predict(input="我最近在学习LangChain框架"))

print("\n第4轮 - 测试记忆:")
print(conversation.predict(input="总结一下我的基本信息"))

print("\n=== memory.buffer ===")
print(memory.buffer)

✅ 运行结果

第4轮 - 测试记忆:
AI: 根据我们的对话，你的基本信息如下：
- 姓名：张三
- 职业：Python开发者
- 年龄：30岁
- 居住地：北京
- 爱好：看科幻电影
- 当前学习：LangChain框架

=== 对话摘要 ===
{'history': '用户张三是一名30岁的Python开发者，居住在北京，喜欢科幻电影，目前正在学习LangChain框架。'}
👉 历史对话被总结成简短的摘要，保留了所有关键信息！

4. ConversationSummaryBufferMemory - 混合记忆 🔄

特点：结合完整记忆和摘要记忆的优点。

📖 工作原理

保留最近的完整对话 + 较早对话的摘要，平衡信息完整性和Token消耗。

优点：近期信息完整，历史信息有摘要
缺点：实现较复杂，需要调用LLM
适用：需要平衡完整性和效率的场景

🧩 一句话理解（SummaryBufferMemory）

“最近消息保真 + 早期消息摘要”。既能保证最近几轮的细节不丢，又能把很早的历史压缩。

✅ 适用场景

你需要“长期记住用户关键信息”，同时又要“对最近几轮细节敏感”。例如：个人助理、项目协作、长期学习规划。

⚙️ 实战建议

设定阈值（消息条数/Token），超过阈值再摘要；同时保留： 摘要 + 最近 N 条消息，并给摘要加入“可回放”的追踪 ID。

🖼️ 图示：summary + 最近消息一起进 prompt

import os

from langchain.chains import ConversationChain
from langchain.memory import ConversationSummaryBufferMemory
from langchain_community.chat_models import ChatTongyi

# ⚠️ 注意：请使用 python3 运行
# python3 memory_summary_buffer.py

os.environ["DASHSCOPE_API_KEY"] = "your-api-key"

llm = ChatTongyi(model="qwen-turbo", temperature=0.7)

# SummaryBufferMemory：超过 max_token_limit 后，把早期历史压成 summary，并保留最近消息原文
memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=100,
)

conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True,
)

print("第1轮:")
print(conversation.predict(input="我叫张三，是一名Python开发者"))

print("\n第2轮:")
print(conversation.predict(input="我今年30岁，住在北京"))

print("\n第3轮:")
print(conversation.predict(input="我喜欢看科幻电影，最近在学习LangChain"))

print("\n第4轮:")
print(conversation.predict(input="我的职业是什么？我住哪里？"))

print("\n=== memory.buffer ===")
print(memory.buffer)

✅ 运行结果

=== 记忆内容 ===
{'history': 'System: 前3轮对话的摘要...\nHuman: 这是第4轮对话\nAI: ...\nHuman: 这是第5轮对话\nAI: ...'}
👉 较早的对话被总结，最近的对话保持完整！

📊 记忆类型对比

记忆类型	保存方式	Token消耗	适用场景
BufferMemory	完整保存所有对话	高（随对话增长）	短对话
WindowMemory	只保留最近K轮	低（固定大小）	长对话，只需近期上下文
SummaryMemory	LLM总结历史	中（需要总结）	长对话，需保留关键信息
SummaryBufferMemory	近期完整+历史摘要	中（平衡）	需要平衡的场景

💡 实战技巧

1. 手动管理记忆

from langchain_community.chat_message_histories import ChatMessageHistory

history = ChatMessageHistory()

# 手动添加消息
history.add_user_message("你好")
history.add_ai_message("你好！有什么可以帮你的？")

# 查看消息
print(history.messages)

# 清空记忆
history.clear()

2. 持久化记忆（保存到文件）

import os

from dotenv import load_dotenv
from langchain_community.chat_message_histories import FileChatMessageHistory
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory

# 加载环境变量（从 .env 中读取 DASHSCOPE_API_KEY）
load_dotenv()

api_key = os.getenv("DASHSCOPE_API_KEY")
if not api_key:
    raise ValueError("请先在 .env 中配置 DASHSCOPE_API_KEY")

llm = ChatTongyi(model="qwen-turbo", temperature=0.7)

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个有帮助的助手。"),
        MessagesPlaceholder("history"),
        ("human", "{input}"),
    ]
)

chain = prompt | llm

def get_file_history(session_id: str) -> FileChatMessageHistory:
    # 每个 session_id 绑定一个历史文件
    return FileChatMessageHistory(f"{session_id}_history.json")

conversation = RunnableWithMessageHistory(
    chain,
    get_file_history,
    input_messages_key="input",
    history_messages_key="history",
)

session_id = "demo_user"

print("=== 第1次运行：写入对话并持久化到文件 ===")
conversation.invoke(
    {"input": "我叫李雷，今年28岁，在杭州做前端工程师"},
    config={"configurable": {"session_id": session_id}},
)
conversation.invoke(
    {"input": "我喜欢跑步和看电影"},
    config={"configurable": {"session_id": session_id}},
)

print("\n=== 模拟下次启动：重新加载同一个文件 ===")
r = conversation.invoke(
    {"input": "请总结一下我的基本信息"},
    config={"configurable": {"session_id": session_id}},
)
print("AI:", r.content)

3. 获取记忆变量

import os

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_community.chat_models import ChatTongyi
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

os.environ["DASHSCOPE_API_KEY"] = "your-api-key"

llm = ChatTongyi(model="qwen-turbo", temperature=0.7)
history = ChatMessageHistory()

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个有帮助的助手。"),
        MessagesPlaceholder("history"),
        ("human", "{input}"),
    ]
)

def invoke(user_input: str) -> str:
    messages = prompt.format_messages(history=history.messages, input=user_input)
    ai = llm.invoke(messages)
    history.add_user_message(user_input)
    history.add_ai_message(ai.content)
    return ai.content

invoke("我叫韩梅梅，是一名数据分析师")
invoke("我擅长用Python做数据可视化")

print("=== 字符串形式的 history（自己拼接）===")
history_str = "\n".join([f"[{m.type}] {m.content}" for m in history.messages])
print(type(history_str))
print(history_str)

print("\n=== 消息列表形式的 history ===")
print(type(history.messages))
for msg in history.messages:
    print(f"[{msg.type}] {msg.content}")

✅ 课后习题与常见面试题

这章的目标不是“记住名字”，而是让你能在真实业务里选对记忆方案，并能把记忆做成可控、可观测、可扩展的工程能力。

📌 基础练习题（概念 + 选型）

1. Buffer / Window / Summary / SummaryBuffer 的核心差异是什么？

请从“信息完整性、成本、风险（遗忘/误总结）”三方面对比，并举 1 个你项目里的典型场景选择其一。

2. 为什么“多用户/多会话”必须引入 session_id？

如果不区分 session，会出现什么线上事故？你如何在后端接口里设计它（例如 header/cookie/body）？

💻 代码题（复制即可运行）

建议：在一个不包含本项目 static/langchain 的路径下运行示例，避免目录名遮蔽 pip 安装的包。

C1. 【编程题】实现“多会话隔离”：同一个服务进程里同时维护 2 个用户的记忆

要求：用 RunnableWithMessageHistory；user_a 记住“张三/开发者”，user_b 记住“李四/产品经理”；互相提问时不能串台。

C2. 【编程题】实现“窗口记忆”：只保留最近 K 轮（并证明它会遗忘）

要求：写一个 trim_window()，每轮对话后裁剪 history.messages；让模型在第 5 轮问“我叫什么名字？”时答不出来。

C3. 【编程题】实现“文件持久化记忆”：重启程序后还能记得之前信息

要求：用 FileChatMessageHistory；第一次运行写入两轮消息；第二次运行用同一个 session_id 继续提问并能回答。

💼 常见面试题（偏工程）

1.【工程题】你如何评估“记忆”带来的成本，并让它可观测？

请覆盖：token 使用、延迟、失败率、session 维度统计、采样回放。

2.【架构题】如果要把记忆存到 Redis / 数据库，你会怎么设计？

请覆盖：数据结构、过期策略（TTL）、并发写入、合规（隐私/脱敏）。

📝 本章小结

🎓 你学到了什么？

记忆的重要性：LLM无状态，需要记忆维护上下文
BufferMemory：保存完整历史，适合短对话
WindowMemory：滑动窗口，只保留最近K轮
SummaryMemory：LLM总结历史，节省Token
SummaryBufferMemory：混合方案，平衡效率和完整性
实战技巧：手动管理、持久化、获取记忆变量

🚀 下一步学习

掌握了记忆管理后，下一章我们将学习Prompt模板，让提示词更加灵活和可复用！