AI Agent 记忆系统实现：让机器人记住对话历史

用户44659454787
3 阅读5分钟

AI Agent 记忆系统实现：让机器人记住对话历史

系列文章： 《AI Agent 开发实战》第 2 期
难度等级： ⭐⭐⭐
预计耗时： 40 分钟

🎯 本文目标

学会为 AI Agent 实现记忆系统：

  • ✅ 短期记忆（对话历史）
  • ✅ 长期记忆（持久化存储）
  • ✅ 向量记忆（语义搜索）
  • ✅ 记忆管理策略

📚 记忆类型

1. 短期记忆 (Short-term Memory)

特点：

  • 保存最近对话
  • 容量有限
  • 快速访问
  • 会话结束清除

适用场景：

  • 多轮对话上下文
  • 临时信息存储

2. 长期记忆 (Long-term Memory)

特点：

  • 持久化存储
  • 容量大
  • 跨会话保留
  • 需要检索机制

适用场景：

  • 用户偏好
  • 重要决策
  • 历史经验

3. 向量记忆 (Vector Memory)

特点：

  • 语义相似度搜索
  • 模糊匹配
  • 智能检索
  • 需要向量数据库

适用场景：

  • 知识库查询
  • 经验回忆
  • 智能推荐

🔧 实现方案

方案 1：基于列表的短期记忆

from google.adk import Agent, Memory

# 简单记忆
agent = Agent(
    name="ChatBot",
    memory=Memory(max_turns=10)  # 保留最近 10 轮对话
)

# 对话
agent.run("我叫张三")
agent.run("我喜欢编程")
agent.run("记住我的名字和爱好")

# 后续对话会自动包含历史信息
response = agent.run("我是谁？喜欢什么？")
# 输出：你是张三，喜欢编程

方案 2：带摘要的记忆

问题： 对话太长，超出 token 限制

解决： 自动摘要

from google.adk import Memory, Summarizer

class SummarizedMemory(Memory):
    def __init__(self, max_turns=10, summary_interval=20):
        super().__init__(max_turns)
        self.summary_interval = summary_interval
        self.summary = ""
        self.turn_count = 0
    
    def add_turn(self, user_msg, assistant_msg):
        self.turn_count += 1
        
        # 定期生成摘要
        if self.turn_count % self.summary_interval == 0:
            self.summary = self.generate_summary()
            self.clear_old_turns()
    
    def generate_summary(self) -> str:
        # 使用 LLM 生成摘要
        prompt = f"""
        请总结以下对话的关键信息：
        {self.get_recent_turns()}
        
        摘要：
        """
        return llm.generate(prompt)
    
    def get_context(self) -> str:
        return f"{self.summary}\n\n最近对话:\n{self.get_recent_turns()}"

方案 3：向量记忆实现

依赖：

pip install chromadb sentence-transformers

实现：

import chromadb
from sentence_transformers import SentenceTransformer

class VectorMemory:
    def __init__(self, collection_name="agent_memory"):
        # 初始化向量数据库
        self.client = chromadb.Client()
        self.collection = self.client.get_or_create_collection(collection_name)
        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
    
    def add(self, text: str, metadata: dict = None):
        """添加记忆"""
        # 生成向量
        embedding = self.embedder.encode(text)
        
        # 存储
        self.collection.add(
            embeddings=[embedding.tolist()],
            documents=[text],
            metadatas=[metadata or {}],
            ids=[f"mem_{len(self.collection)}"]
        )
    
    def search(self, query: str, top_k=3) -> list:
        """语义搜索"""
        query_embedding = self.embedder.encode(query)
        
        results = self.collection.query(
            query_embeddings=[query_embedding.tolist()],
            n_results=top_k
        )
        
        return results['documents'][0]
    
    def forget(self, threshold=0.5):
        """遗忘不重要的记忆"""
        # 实现记忆清理逻辑
        pass

使用示例：

memory = VectorMemory()

# 添加记忆
memory.add("用户喜欢 Python 编程", {"type": "preference"})
memory.add("项目使用 FastAPI 框架", {"type": "project"})
memory.add("用户住在北京市", {"type": "personal"})

# 搜索相关记忆
related = memory.search("用户的编程背景")
# 返回：["用户喜欢 Python 编程", "项目使用 FastAPI 框架"]

💻 实战案例

案例 1：个性化助手

class PersonalAssistant:
    def __init__(self):
        self.memory = VectorMemory()
        self.agent = Agent(
            name="PersonalAssistant",
            memory=self.create_memory()
        )
    
    def chat(self, message: str) -> str:
        # 检索相关记忆
        relevant_memories = self.memory.search(message, top_k=5)
        
        # 构建上下文
        context = "已知信息:\n" + "\n".join(relevant_memories)
        
        # 生成回复
        prompt = f"{context}\n\n用户：{message}\n助手："
        response = self.agent.run(prompt)
        
        # 保存新记忆
        if self.should_remember(message, response):
            self.memory.add(f"用户说：{message}")
            self.memory.add(f"助手回复：{response}")
        
        return response
    
    def should_remember(self, user_msg, assistant_msg) -> bool:
        # 判断是否需要记住
        keywords = ["记住", "重要", "喜欢", "不喜欢", "偏好"]
        return any(k in user_msg for k in keywords)

案例 2：客服机器人

class CustomerServiceBot:
    def __init__(self):
        self.knowledge_base = VectorMemory("customer_service")
        self.load_knowledge_base()
    
    def load_knowledge_base(self):
        # 加载产品知识
        faqs = [
            ("如何退货？", "7 天内可无理由退货"),
            ("发货时间？", "24 小时内发货"),
            ("保修期多久？", "全国联保 1 年")
        ]
        
        for question, answer in faqs:
            self.knowledge_base.add(
                f"问题：{question}\n答案：{answer}",
                metadata={"type": "faq"}
            )
    
    def answer(self, question: str) -> str:
        # 搜索相关知识
        knowledge = self.knowledge_base.search(question, top_k=3)
        
        # 生成回答
        context = "参考知识:\n" + "\n".join(knowledge)
        prompt = f"{context}\n\n客户问题：{question}\n客服："
        
        return llm.generate(prompt)

🎓 记忆管理策略

1. 记忆重要性评分

def calculate_importance(memory_entry) -> float:
    """计算记忆重要性 (0-1)"""
    score = 0.5  # 基础分
    
    # 用户明确要求记住
    if "记住" in memory_entry.text:
        score += 0.3
    
    # 包含个人信息
    if any(k in memory_entry.text for k in ["我叫", "我喜欢", "我住在"]):
        score += 0.2
    
    # 最近访问
    if time.time() - memory_entry.last_accessed < 3600:  # 1 小时内
        score += 0.1
    
    return min(score, 1.0)

2. 记忆清理策略

class MemoryManager:
    def __init__(self, max_memories=1000):
        self.max_memories = max_memories
    
    def cleanup(self, memory: VectorMemory):
        """清理不重要的记忆"""
        if len(memory) < self.max_memories:
            return  # 不需要清理
        
        # 获取所有记忆
        all_memories = memory.get_all()
        
        # 按重要性排序
        sorted_memories = sorted(
            all_memories,
            key=calculate_importance,
            reverse=True
        )
        
        # 保留重要的
        to_keep = sorted_memories[:self.max_memories]
        to_delete = sorted_memories[self.max_memories:]
        
        # 删除不重要的
        for mem in to_delete:
            memory.delete(mem.id)

3. 记忆更新策略

def update_memory(memory: VectorMemory, old_info: str, new_info: str):
    """更新记忆（而不是重复添加）"""
    # 搜索旧信息
    results = memory.search(old_info, top_k=5)
    
    # 删除过时信息
    for result in results:
        if is_outdated(result, new_info):
            memory.delete(result.id)
    
    # 添加新信息
    memory.add(new_info)

⚠️ 注意事项

1. 隐私保护

class PrivacyAwareMemory(VectorMemory):
    def add(self, text: str, metadata: dict = None):
        # 检测敏感信息
        if self.contains_sensitive_info(text):
            # 加密存储
            text = self.encrypt(text)
            metadata = metadata or {}
            metadata["encrypted"] = True
        
        super().add(text, metadata)
    
    def contains_sensitive_info(self, text: str) -> bool:
        # 检测密码、身份证号等
        patterns = [
            r"密码 [：:]\s*\S+",
            r"身份证 [：:]\s*\d+",
            r"银行卡 [：:]\s*\d+"
        ]
        return any(re.search(p, text) for p in patterns)

2. 性能优化

# 批量添加
memory.batch_add([
    ("记忆 1", {"type": "a"}),
    ("记忆 2", {"type": "b"}),
    ("记忆 3", {"type": "c"})
])

# 异步搜索
async def search_async(query: str):
    loop = asyncio.get_event_loop()
    return await loop.run_in_executor(None, memory.search, query)

📊 效果对比

记忆类型优点缺点适用场景
短期记忆快速、简单容量有限多轮对话
摘要记忆节省 token信息损失长对话
向量记忆智能检索需要向量库知识库
混合记忆综合优势实现复杂生产环境

📚 系列导航

期数主题状态
第 1 期30 分钟搭建第一个 Agent✅
第 2 期记忆系统实现✅
第 3 期工具调用能力下一篇
第 4 期多 Agent 协作待发布
第 5 期LangChain vs Google ADK待发布
第 6 期Agent 自动写代码待发布
第 7 期Agent 性能优化待发布

作者： AI 技术实践者
最后更新： 2026 年 3 月 21 日

觉得有用？点赞 👍 收藏 ⭐ 关注 ➕ 三连支持一下！

avatar
文章
阅读
粉丝