高级记忆解决方案
探索摘要记忆、实体记忆等更高级的记忆类型，以及如何持久化保存对话历史
高级记忆解决方案 是 CoddyKit 上的免费 AI Agents with LangChain & Autonomous Workflows 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 AI Agents with LangChain & Autonomous Workflows 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 AI Agents with LangChain & Autonomous Workflows 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Deeper Agent Memory
In previous lessons, we learned about basic conversational memory. But what if conversations get very long or involve many specific details?
Advanced memory solutions help agents manage complex interactions by summarizing or tracking entities.
Introducing Summary Memory
Summary Memory condenses past conversations into a concise summary.
- It prevents context windows from overflowing.
- The agent still "remembers" the gist without storing every single message.
- Useful for long-running chats where initial details become less important.
Summary Memory in Action
LangChain's ConversationSummaryBufferMemory uses an LLM to create summaries. It keeps a buffer of recent messages, then summarizes older ones as needed.
Try this example:
from langchain.memory import ConversationSummaryBufferMemory
from langchain_openai import OpenAI
# For demonstration, we'll use a mock LLM
# In a real scenario, you'd use your actual LLM (e.g., OpenAI, HuggingFace)
# from langchain.llms import OpenAI
# llm = OpenAI(temperature=0)
class MockLLM:
def __init__(self):
pass
def invoke(self, prompt):
if "summarize" in prompt.lower():
return "A short summary of the conversation."
return "Mock LLM response to: " + prompt
llm = MockLLM()
# max_token_limit ensures summary happens before context window is full
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100)
def run_interaction(user_input, ai_output):
memory.save_context({"input": user_input}, {"output": ai_output})
print(f"Memory buffer: {memory.load_memory_variables({})['history']}")
if __name__ == "__main__":
print("--- Summary Buffer Memory Demo ---")
run_interaction("Hi there!", "Hello! How can I help?")
run_interaction("My name is Alice.", "Nice to meet you, Alice.")
run_interaction("I want to discuss project Alpha.", "Okay, tell me more.")
run_interaction("Project Alpha is about AI agents.", "Interesting! What aspects?")
# After more interactions, older messages would be summarized
print("\nFinal memory (after potential summarization):")
print(memory.load_memory_variables({})['history'])
Tracking Specific Entities
Entity Memory is designed to remember specific "entities" (like people, places, or topics) and facts about them throughout a conversation.
- It maintains a knowledge base of entities.
- Useful when an agent needs to recall specific details about named things.
- Example: "Alice likes coffee" -> agent remembers "Alice" and "likes coffee".
Using ConversationEntityMemory
ConversationEntityMemory uses an LLM to extract entities and their attributes from messages. It builds up a profile for each entity.
Let's see it work:
from langchain.memory import ConversationEntityMemory
from langchain_openai import OpenAI
# Using the same MockLLM for consistency
class MockLLM:
def __init__(self):
pass
def invoke(self, prompt):
if "extract entities" in prompt.lower():
if "Alice" in prompt:
return "{'Alice': 'Alice is a person. She likes coffee and project Alpha.'}"
return "{}"
if "summarize" in prompt.lower():
return "A short summary of the conversation."
return "Mock LLM response to: " + prompt
llm = MockLLM()
memory = ConversationEntityMemory(llm=llm)
def run_entity_interaction(user_input, ai_output):
memory.save_context({"input": user_input}, {"output": ai_output})
print(f"Entities: {memory.load_memory_variables({})['entities']}")
if __name__ == "__main__":
print("--- Entity Memory Demo ---")
run_entity_interaction("My name is Alice and I like coffee.", "Nice to meet you, Alice!")
run_entity_interaction("I am working on project Alpha.", "That sounds interesting.")
run_entity_interaction("My colleague Bob will join later.", "Okay, I'll remember Bob.")
print("\nFinal entities stored:")
print(memory.load_memory_variables({})['entities'])
Hybrid Memory Approaches
For even more robust agents, you can combine different memory types.
- Use Summary Memory for general conversation flow.
- Use Entity Memory to track specific facts about key subjects.
- This creates a rich, layered understanding without overwhelming the LLM's context window.
Remembering Across Sessions
By default, an agent's memory is lost when the program ends. But what if you want an agent to remember a user over days or weeks?
Persistent Memory allows you to save and load an agent's memory, enabling long-term conversations and continuity.
Saving & Loading Memory
A simple way to persist memory is to save its state to a file, like JSON. When the agent restarts, it can load this file to restore its memory.
This example shows how to serialize (save) and deserialize (load) memory:
import json
from langchain.memory import ConversationBufferMemory
# Example of a simple buffer memory
memory = ConversationBufferMemory()
if __name__ == "__main__":
print("--- Memory Persistence Demo ---")
# 1. Save context
memory.save_context({"input": "Hello!"}, {"output": "Hi there!"})
memory.save_context({"input": "How are you?"}, {"output": "I'm good!"})
# 2. Extract and save memory variables
memory_data = memory.load_memory_variables({})
print(f"Memory before saving: {memory_data}")
# Convert to JSON string and save to a file
with open("agent_memory.json", "w") as f:
json.dump(memory_data, f, indent=2)
print("\nMemory saved to agent_memory.json")
# 3. Create new memory and load from file
new_memory = ConversationBufferMemory()
with open("agent_memory.json", "r") as f:
loaded_data = json.load(f)
# For ConversationBufferMemory, you can set the buffer directly
# More complex memories might have specific load methods
new_memory.buffer = loaded_data.get('history', '')
print(f"\nMemory loaded into new agent: {new_memory.load_memory_variables({})['history']}")
Robust Persistence Options
For production-grade applications, simple file persistence isn't enough. Consider these options:
- Databases: SQL (SQLite, PostgreSQL) or NoSQL (MongoDB, Redis) for structured and scalable storage.
- Vector Stores: For persisting embeddings of conversational history, useful for more advanced retrieval.
- LangChain integrates with many databases for seamless memory persistence.
Memory Types Quiz
Which memory type would be best suited for an agent that needs to remember specific details about named clients (e.g., their preferences, project names) over a very long conversation?
Recap: Advanced Memory Solutions
Today, we explored advanced memory solutions for AI agents:
- Summary Memory: Condenses long conversations.
- Entity Memory: Tracks specific facts about named entities.
- Persistence: Saving and loading memory to maintain context across sessions, using files or databases.
These techniques help build more intelligent and context-aware agents!
常见问题解答
「高级记忆解决方案」课时是免费的吗？
是的 — 「高级记忆解决方案」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 AI Agents with LangChain & Autonomous Workflows 课程的其余内容，请升级到 CoddyKit PRO。 AI Agents with LangChain & Autonomous Workflows 课程共包含 4 节课。
「高级记忆解决方案」这节课中我会学到什么？
探索摘要记忆、实体记忆等更高级的记忆类型，以及如何持久化保存对话历史 你通过在浏览器中直接运行的动手代码来练习 AI Agents with LangChain & Autonomous Workflows，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 AI Agents with LangChain & Autonomous Workflows 需要有经验吗？
无需任何先前经验。CoddyKit 上的 AI Agents with LangChain & Autonomous Workflows 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「高级记忆解决方案」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 AI Agents with LangChain & Autonomous Workflows 课中编写并运行代码吗？
能。每节 AI Agents with LangChain & Autonomous Workflows 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。