进阶篇05Agent记忆memory

AI Agent记忆（Memory）机制深度解析

记忆（Memory）模块负责存储信息，包括过去的交互、学习到的知识，甚至是临时的任务信息。对于一个智能体来说，有效的记忆机制能够保障它在面对新的或复杂的情况时，调用以往的经验和知识。

例如，一个具备记忆功能的聊天机器人可以记住用户的偏好或先前的对话内容，从而提供更个性化和连贯的交流体验。
它分为短期记忆和长期记忆：
a. 短期记忆，所有的上下文学习都是利用短期记忆来学习；
b. 长期记忆，这为智能体提供了长时间保留和回忆。

Agent记忆（Agent Memory）是指AI Agent在执行任务过程中存储和管理信息的能力和机制。它类似于人类的记忆系统，使Agent能够记住过去的交互、经验和知识，并在后续任务中利用这些信息做出更好的决策。这种记忆机制对于实现持续学习和处理长期任务至关重要。
AI Agent的记忆机制主要包括短期记忆和长期记忆。短期记忆用于存储任务执行过程中的临时信息，而长期记忆则用于存储历史数据和知识。记忆在AI Agent中起着至关重要的作用，它能够帮助Agent积累经验、优化决策，并支持长期学习。例如，在完成一项任务时，Agent会记录下每次交互的细节，这些信息被存储在短期记忆中，并在任务完成后转移到长期记忆中，供未来参考‌

一、人类记忆机制原理

人类记忆机制则更为复杂，涉及多个心理过程和生理机制。人类的记忆可以分为短期记忆（工作记忆）和长期记忆（长时记忆）。工作记忆是暂时存储和处理信息的区域，容量有限且容易受到干扰。长时记忆则用于存储长期信息，包括事实、技能和经验等。长时记忆可以通过重复和巩固过程转化为永久记忆。

1.1 记忆的三级存储模型

1.1.1 感觉记忆（瞬时记忆）

• 持续时间：0.5-3秒
• 典型场景：
  • 刷短视频时的视觉暂留
  • 膝跳反射的肌肉记忆
  • 听觉信息的瞬时存储

1.1.2 短期记忆（工作记忆）

• 容量限制：7±2个信息块
• 典型应用：
  • 临时记住电话号码
  • 编程时的上下文保持
  • 会议中的即时讨论

1.1.3 长期记忆

类型	特征	示例
情景记忆	事件细节	初恋场景回忆
语义记忆	概念知识	国家首都记忆
程序记忆	技能操作	骑自行车/打字

二、AI Agent记忆实现

2.1 记忆系统架构

class MemorySystem:
    def __init__(self):
        self.short_term = []  # 短期记忆缓冲区
        self.long_term = VectorDB()  # 长期记忆向量库
        
    def process_input(self, prompt):
        # 上下文关联处理
        context = self._retrieve_context(prompt)
        return self._generate_response(prompt, context)
    
    def _retrieve_context(self, prompt):
        # 混合检索策略
        stm_context = self._search_short_term(prompt)
        ltm_context = self.long_term.semantic_search(prompt)
        return combine_contexts(stm_context, ltm_context)

2.2 记忆类型对比

维度	人类记忆	AI Agent记忆
存储介质	生物神经网络	分布式参数/向量数据库
遗忘机制	自然衰减	LRU缓存策略
检索方式	联想回忆	相似度计算
容量限制	生理限制	存储硬件限制
记忆强化	重复学习	Fine-tuning

2.3 关键技术实现

记忆的层次
短期记忆：对话上下文
长期记忆：持久化的知识库

2.3.1 短期记忆管理

# 使用双向LSTM管理对话上下文
class ShortTermMemory(nn.Module):
    def __init__(self, hidden_size=512):
        super().__init__()
        self.lstm = nn.LSTM(
            input_size=768, 
            hidden_size=hidden_size,
            bidirectional=True
        )
        
    def forward(self, embeddings):
        outputs, (h_n, c_n) = self.lstm(embeddings)
        return outputs

class ConversationMemory:
    def __init__(
        self,
        max_turns: int = 5,
        max_tokens: int = 2000
    ):
        self.messages = []
        self.max_turns = max_turns
        self.max_tokens = max_tokens

    def add_message(
        self,
        role: str,
        content: str
    ):
        self.messages.append({
            "role": role,
            "content": content,
            "timestamp": datetime.now()
        })

        # 保持对话长度在限制内
        self._truncate_if_needed()

    def get_context(self) -> List[dict]:
        return [
            {
                "role": msg["role"],
                "content": msg["content"]
            }
            for msg in self.messages
        ]

    def _truncate_if_needed(self):
        # 1. 按对话轮数截断
        if len(self.messages) > self.max_turns * 2:
            self.messages = self.messages[-(self.max_turns * 2):]

        # 2. 按token数截断
        total_tokens = sum(
            len(msg["content"].split())
            for msg in self.messages
        )
        while (
            total_tokens > self.max_tokens and
            len(self.messages) > 2
        ):
            self.messages.pop(0)
            total_tokens = sum(
                len(msg["content"].split())
                for msg in self.messages
            )

使用示例：

memory = ConversationMemory(max_turns=5)

# 记录对话
memory.add_message("user", "Python的装饰器是什么？")
memory.add_message("assistant", "装饰器是Python中用于修改函数或类行为的一种设计模式...")
memory.add_message("user", "能给个例子吗？")

# 获取上下文
context = memory.get_context()

这样实现有几个关键点：

• 容量限制
  控制对话轮数
  限制总token数
  防止上下文爆炸
• 时间衰减
  优先保留最近的对话
  重要信息可以标记保留
  定期清理过期内容
• 上下文组织
  保持对话的连贯性
  突出重要信息
  压缩冗余内容

2.3.2 长期记忆存储

# 基于FAISS的向量记忆库
class LongTermMemory:
    def __init__(self, dim=768):
        self.index = faiss.IndexFlatIP(dim)
        self.memory_map = {}
        
    def add_memory(self, text, embedding):
        idx = self.index.ntotal
        self.index.add(embedding)
        self.memory_map[idx] = {
            'text': text,
            'timestamp': time.time()
        }
        
    def search(self, query_emb, k=5):
        distances, indices = self.index.search(query_emb, k)
        return [self.memory_map[i] for i in indices[0]]

class LongTermMemory:
    def __init__(
        self,
        vector_store: VectorStore,
        ttl_store: TTLStore
    ):
        self.vector_store = vector_store
        self.ttl_store = ttl_store
        self.importance_threshold = 0.7

    async def remember(
        self,
        content: str,
        metadata: dict = None,
        importance: float = None
    ):
        # 1. 评估重要性
        if importance is None:
            importance = await self._evaluate_importance(
                content
            )

        # 2. 决定存储策略
        if importance > self.importance_threshold:
            # 重要信息，存入向量数据库
            await self.vector_store.add(
                content=content,
                metadata={
                    **(metadata or {}),
                    "importance": importance,
                    "created_at": datetime.now()
                }
            )
        else:
            # 临时信息，存入TTL存储
            ttl = self._calculate_ttl(importance)
            await self.ttl_store.set(
                key=self._generate_key(content),
                value={
                    "content": content,
                    "metadata": metadata,
                    "importance": importance
                },
                ttl=ttl
            )

    async def recall(
        self,
        query: str,
        limit: int = 5
    ) -> List[Memory]:
        # 1. 搜索向量数据库
        vector_results = await self.vector_store.search(
            query=query,
            limit=limit
        )

        # 2. 搜索TTL存储
        ttl_results = await self.ttl_store.search(
            query=query,
            limit=limit
        )

        # 3. 合并结果
        all_results = [
            *vector_results,
            *ttl_results
        ]

        # 4. 按相关性排序
        return sorted(
            all_results,
            key=lambda x: x.relevance,
            reverse=True
        )[:limit]

    async def forget(
        self,
        query: str = None,
        before: datetime = None
    ):
        # 删除旧的或不相关的记忆
        if query:
            await self.vector_store.delete(query)
        if before:
            await self.vector_store.delete_before(before)

    async def _evaluate_importance(
        self,
        content: str
    ) -> float:
        # 使用 LLM 评估内容的重要性
        response = await self.llm.evaluate(
            content=content,
            criteria=[
                "信息的独特性",
                "内容的时效性",
                "知识的通用性"
            ]
        )
        return float(response.importance)

    def _calculate_ttl(
        self,
        importance: float
    ) -> int:
        # 根据重要性计算过期时间
        base_ttl = 60 * 60 * 24  # 1天
        return int(base_ttl * importance)

使用示例：

memory = LongTermMemory(
    vector_store=MilvusStore(),
    ttl_store=RedisStore()
)

# 存储新知识
await memory.remember(
    content="Python 3.12 引入了新的类型语法...",
    metadata={
        "category": "Python",
        "source": "PEP-xxx"
    }
)

# 回忆相关内容
results = await memory.recall(
    query="Python 3.12 新特性",
    limit=5
)

# 清理旧记忆
await memory.forget(
    before=datetime.now() - timedelta(days=30)
)

长期记忆的核心特点：

• 分级存储
  重要信息持久化
  临时信息用TTL
  自动清理过期内容
• 智能归档
  评估信息重要性
  选择存储策略
  管理存储周期
• 高效检索
  向量相似度搜索
  关键词匹配
  实时更新索引

三、记忆优化策略

3.1 性能提升技巧

1. 记忆压缩：使用T5等模型进行摘要生成

   summarizer = pipeline("summarization", model="t5-small")
   compressed_mem = summarizer(long_text, max_length=100)
   

2. 记忆索引：构建分层导航索引
3. 遗忘机制：基于LRU的缓存淘汰策略

3.2 工程实践建议

• 设置记忆存储时长策略（TTL）
• 实现记忆版本控制机制
• 添加记忆可信度评估模块

AI Agent记忆机制与人类记忆机制在原理上有许多相似之处，但也有一些关键区别

‌- 存储方式‌：AI Agent的记忆通常是数字化的，存储在计算机中，可以无限扩展且不易受物理限制影响；而人类记忆则是生物化学过程，受限于大脑的物理结构和化学过程。
‌- 信息处理方式‌：AI Agent的记忆可以通过算法和模型进行快速处理和优化；人类记忆则需要通过思考和联想来处理信息，过程更为复杂和耗时。