---
title: Generative Agents 与 MemGPT：跨轮次记忆与 Agent 系统
draft: false
tags:
  - Generative-Agents
  - MemGPT
  - Memory
  - Agent
  - 大语言模型
---

# Generative Agents 与 MemGPT：跨轮次记忆与 Agent 系统

---

## 一、记忆问题的形式化

### 1.1 单轮对话的局限

**标准 LLM 的设置**：

给定当前输入 $x_t$ 和对话历史 $(x_1, y_1, \ldots, x_{t-1}, y_{t-1})$，生成响应：
$$P(y_t | x_t, \text{history}) = \prod_{k=1}^T P_\theta(y_{t,k} | x_t, y_{t,<k}, \text{history}) \tag{1.1}$$

**问题**：当对话轮次很多时：
1. **上下文长度限制**：LLM 有最大上下文长度（如 4K/8K/32K tokens）
2. **距离衰减**：早期的重要信息在上下文中被稀释
3. **计算成本**：长上下文带来二次方 attention 成本

### 1.2 记忆的层级

**定义（记忆层级）**：

| 层级 | 描述 | 容量 | 访问频率 |
|------|------|------|---------|
| **上下文记忆** | 当前上下文中的信息 | ~4K-32K tokens | 最高 |
| **短期记忆** | 最近几轮对话 | ~10-50 轮 | 高 |
| **长期记忆** | 整个对话历史 | 无限制 | 低 |
| **情节记忆** | 重要事件的高层摘要 | 中等 | 中 |

### 1.3 记忆管理的核心问题

**问题 1：信息该存在哪里？**

- 不是所有信息都值得存在记忆中
- 重要的、经常使用的信息应该优先保留

**问题 2：信息如何被检索？**

当需要时，如何从记忆中快速找到相关信息？

**问题 3：信息如何更新？**

记忆应该随着时间推移而更新，而不是无限累积。

---

## 二、Generative Agents：模拟人类行为的 Agent

### 2.1 核心思想

**Generative Agents**（Park et al., 2023）的核心是：构建一个能够**跨时间保持一致性**的虚拟 Agent 社会。

**关键创新**：

1. **观察-反思-检索-规划**的循环框架
2. **动态记忆流**：随时间累积和更新信息
3. **行为生成**：基于记忆和当前状态生成行为

### 2.2 Generative Agents 的架构

**核心组件**：

```
┌─────────────────────────────────────────────┐
│            Generative Agent                  │
├─────────────────────────────────────────────┤
│  感知模块 (Perception)                       │
│  → 从环境中接收事件                         │
├─────────────────────────────────────────────┤
│  记忆流 (Memory Stream)                      │
│  → 存储所有观察和反思                        │
│  → 支持增量和检索                           │
├─────────────────────────────────────────────┤
│  反思模块 (Reflection)                      │
│  → 定期总结记忆为高层见解                    │
│  → 指导未来行为                             │
├─────────────────────────────────────────────┤
│  规划模块 (Planning)                         │
│  → 将高层目标分解为具体行动                  │
│  → 生成行为序列                             │
└─────────────────────────────────────────────┘
```

### 2.3 记忆流的数学表示

**定义（记忆）**：

记忆 $m$ 是一个三元组：
$$m = (t, \text{content}, \text{importance}) \tag{2.1}$$

其中：
- $t$：时间戳
- $\text{content}$：记忆内容
- $\text{importance}$：重要程度评分

**定义（记忆流）**：

记忆流 $\mathcal{M}$ 是按时间排序的记忆序列：
$$\mathcal{M} = (m_1, m_2, \ldots, m_n) \quad \text{s.t.} \quad t_1 \leq t_2 \leq \cdots \leq t_n \tag{2.2}$$

### 2.4 观察（Observation）

**观察的定义**：

Agent 从环境接收观察 $o$：
$$o = (\text{agent}, \text{action}, \text{objects}, \text{location}) \tag{2.3}$$

**示例**：

```
[观察到] Isabella Rodriguez 正在收银台前排...
```

**观察的处理**：

每个观察都被编码并存储到记忆流中：
$$\mathcal{M} \leftarrow \mathcal{M} \cup \{\text{encode}(o)\} \tag{2.4}$$

### 2.5 检索（Retrieval）

**检索函数**：

给定当前状态 $s_t$，检索相关的记忆：
$$\text{retrieved} = \text{Retrieve}(\mathcal{M}, s_t, k) \tag{2.5}$$

其中 $\text{retrieved}$ 是 top-$k$ 个最相关的记忆。

**检索的相关性评分**：

$$\text{score}(m, s) = \alpha_1 \cdot \text{recency}(m) + \alpha_2 \cdot \text{relevance}(m, s) + \alpha_3 \cdot \text{importance}(m) \tag{2.6}$$

其中：
- $\text{recency}(m)$：新近度，越新越高
- $\text{relevance}(m, s)$：与当前状态的相关性
- $\text{importance}(m)$：记忆的重要性评分

### 2.6 反思（Reflection）

**反思的触发条件**：

当累积的观察数量超过阈值时，触发反思：
$$\text{if } |\mathcal{M}_{\mathrm{KL}} > \tau_{\mathrm{KL}}: \text{ trigger reflection} \tag{2.7}$$

**反思的数学表示**：

反思 $r$ 是对近期记忆的高层总结：
$$r = \text{Summarize}(\mathcal{M}_{\mathrm{KL}}) \tag{2.8}$$

**反思的内容**：

- 当前状态的解释
- 相关的高层模式
- 未来行为的建议

**反思存储**：

反思结果作为新的记忆存储：
$$\mathcal{M} \leftarrow \mathcal{M} \cup \{r\} \tag{2.9}$$

### 2.7 规划（Planning）

**规划的层级**：

1. **高层目标**：Agent 想要实现什么
2. **行动序列**：具体要做什么
3. **时间安排**：什么时候做

**数学表示**：

给定高层目标 $G$，生成行动序列：
$$\text{plan} = \text{Plan}(G, \mathcal{M}, s_t) = (a_1, a_2, \ldots, a_K) \tag{2.10}$$

其中每个 $a_k$ 是具体的行动。

---

## 三、MemGPT：层级记忆管理

### 3.1 核心思想

**MemGPT**（Packer et al., 2023）的核心是：将**不同层级的记忆**显式化，通过**记忆管理机制**在层级之间移动信息。

**关键创新**：

1. **上下文层级**：将 LLM 上下文视为"寄存器"
2. **主存层级**：作为持久化存储
3. **存储系统层级**：作为外部存储
4. **智能检索**：根据需要动态加载/卸载

### 3.2 层级记忆架构

**三层架构**：

```
┌────────────────────────────────────────────────────┐
│         LLM Context Window (Register)               │
│         - 当前对话上下文                           │
│         - 最近的记忆片段                            │
│         - 当前任务相关的检索结果                    │
│  [容量限制：4K-128K tokens]                        │
└────────────────────────────────────────────────────┘
                         ↑↓
┌────────────────────────────────────────────────────┐
│              Working Memory (RAM)                    │
│         - 中期记忆                                 │
│         - 重要但非紧急的信息                        │
│         - Agent 的当前状态摘要                     │
│  [容量：约 50-100 个记忆单元]                     │
└────────────────────────────────────────────────────┘
                         ↑↓
┌────────────────────────────────────────────────────┐
│             Archive Storage (Disk)                  │
│         - 长期记忆                                 │
│         - 历史对话摘要                             │
│         - 事实和知识                               │
│  [容量：几乎无限]                                 │
└────────────────────────────────────────────────────┘
```

### 3.3 记忆管理操作

**MemGPT 支持的操作**：

| 操作 | 说明 | 从 → 到 |
|------|------|--------|
| **RECALL** | 从存档中检索并加载到工作记忆 | Archive → Working |
| **EMIT** | 将工作记忆写入存档 | Working → Archive |
| **RETAIN** | 将上下文片段保留在工作记忆 | Context → Working |
| **BURY** | 将工作记忆放入存档 | Working → Archive |

**Algorithm: Memory Management**

```
while agent running:
    # 评估当前上下文状态
    context_utility = evaluate_context(current_messages)

    # 如果上下文太满，溢出到工作记忆
    if context_overflow():
        emit_to_working_memory(least_recent_messages())

    # 如果工作记忆太满，溢出到存档
    if working_memory_overflow():
        emit_to_archive(least_important_memories())

    # 如果需要检索，从存档加载
    if need_to_recall():
        recalled = recall_from_archive(query)
        load_to_working_memory(recalled)
```

### 3.4 智能检索策略

**检索决策**：

当处理查询时，MemGPT 决定是否需要从存档检索：
$$\text{need\_recall} = \text{MLP}(\text{query\_embedding}, \text{context\_embedding}) \tag{3.1}$$

**检索排序**：

$$\text{score}(m, q) = \beta_1 \cdot \text{relevance}(m, q) + \beta_2 \cdot \text{recency}(m) + \beta_3 \cdot \text{importance}(m) \tag{3.2}$$

### 3.5 MemGPT vs Generative Agents

| 维度 | Generative Agents | MemGPT |
|------|------------------|--------|
| **记忆表示** | 自然语言叙事 | 结构化记忆单元 |
| **检索方式** | 基于重要性和相关性的检索 | 动态层级管理 |
| **反思机制** | 定期总结 | 可选的反思触发 |
| **架构层级** | 2层（记忆流+检索） | 3层（上下文+工作+存档） |

---

## 四、Agent 系统的核心算法

### 4.1 Agent-Environment 交互

**定义（Agent 循环）**：

$$\text{AgentLoop}: \quad s_0 \xrightarrow{a_0} s_1 \xrightarrow{a_1} s_2 \xrightarrow{a_2} \cdots \tag{4.1}$$

其中 $s_t$ 是状态，$a_t$ 是行动。

**行动生成**：

$$a_t = \pi_\theta(a | \text{context}, \text{memory}, \text{goals}) \tag{4.2}$$

### 4.2 观察过滤

**问题**：不是所有观察都值得记忆。

**解决方案**：使用重要性评分过滤：
$$\text{importance}(o) = \text{MLP}(\text{embed}(o)) \tag{4.3}$$

只保留高于阈值的观察：
$$\text{if } \text{importance}(o) > \tau: \mathcal{M} \leftarrow \mathcal{M} \cup \{o\} \tag{4.4}$$

### 4.3 记忆压缩

**问题**：记忆流会无限增长。

**解决方案**：定期压缩记忆。

**压缩策略**：

1. **摘要压缩**：将多个记忆合并为一个高层摘要
2. **重要性过滤**：只保留最重要的记忆
3. **时间窗口**：只保留最近 $N$ 个记忆

**数学表示**：

$$\mathcal{M}_{\mathrm{KL}} = \text{Compress}(\mathcal{M}) = \text{Summarize}(\mathcal{M}_{\mathrm{KL}}) \cup \mathcal{M}_{\mathrm{KL}} \tag{4.5}$$

### 4.4 目标一致性

**问题**：Agent 的行为应该与高层目标一致。

**定义（目标）**：

$$G = (g_1, g_2, \ldots, g_m) \tag{4.6}$$

其中每个 $g_i$ 是一个子目标。

**目标跟踪**：

$$a_t \in G \quad \text{if } \text{is\_relevant}(a_t, G) \tag{4.7}$$

**重新规划**：

当目标无法完成时，重新规划：
$$\text{plan} = \text{Replan}(G, \mathcal{M}, s_t) \quad \text{if } \text{goal\_failed}(G) \tag{4.8}$$

---

## 五、训练过程与问题

### 5.1 记忆系统的训练

**记忆编码器训练**：

使用对比学习训练记忆编码器：
$$\mathcal{L} = -\log \frac{\exp(\text{sim}(m^+, q))}{\exp(\text{sim}(m^+, q)) + \sum \exp(\text{sim}(m^-, q))} \tag{5.1}$$

**重要性评分器训练**：

使用人类标注的重要性数据训练：
$$\mathcal{L}_{\mathrm{KL}} = \sum_{(o, \text{label})} \text{BCE}(\text{MLP}(\text{embed}(o)), \text{label}) \tag{5.2}$$

### 5.2 训练中的常见问题

**问题 1：遗忘早期重要信息**

**表现**：Agent 记住了最近的，忘记了重要的早期信息。

**解决方案**：
1. 重要性评分应该考虑信息的长期价值
2. 使用定期检查点保存重要记忆

**问题 2：记忆过度膨胀**

**表现**：记忆流变得很大，检索变慢。

**解决方案**：
1. 设置记忆上限
2. 使用记忆压缩
3. 分层存储

**问题 3：检索质量差**

**表现**：检索到的记忆不相关。

**解决方案**：
1. 改进检索模型
2. 使用更丰富的查询表示
3. 多样性检索（避免返回相似的多个记忆）

### 5.3 对话一致性问题

**问题**：Agent 在不同轮次中表现不一致。

**原因**：
1. 记忆没有被正确检索
2. 记忆被错误更新
3. 检索时忽略了关键信息

**解决方案**：
1. 确保检索包含所有相关的历史
2. 使用一致性约束
3. 定期验证记忆的正确性

---

## 六、实际应用中的挑战

### 6.1 记忆与上下文的边界

**问题**：如何决定信息该存在记忆里还是上下文里？

**原则**：
- **上下文**：当前对话直接相关的信息
- **工作记忆**：Agent 的当前状态和目标
- **存档**：历史信息和知识

### 6.2 实时更新 vs 批量更新

**实时更新**：每个观察立即存储

**批量更新**：定期总结和压缩

**混合策略**：重要信息实时存储，不重要的批量处理。

### 6.3 安全性与隐私

**问题**：记忆可能包含敏感信息。

**解决方案**：
1. 记忆加密
2. 访问控制
3. 定期清理

---

## 七、数学公式速查

### 7.1 记忆表示

**记忆**：
$$m = (t, \text{content}, \text{importance}) \tag{7.1}$$

**记忆流**：
$$\mathcal{M} = (m_1, m_2, \ldots, m_n) \quad \text{s.t.} \quad t_1 \leq \cdots \leq t_n \tag{7.2}$$

### 7.2 检索公式

**检索评分**：
$$\text{score}(m, s) = \alpha_1 \cdot \text{recency}(m) + \alpha_2 \cdot \text{relevance}(m, s) + \alpha_3 \cdot \text{importance}(m) \tag{7.3}$$

### 7.3 记忆管理

**RECALL 操作**：
$$\text{recalled} = \text{Retrieve}(\mathcal{M}_{\mathrm{KL}}, q, k) \tag{7.4}$$

**EMIT 操作**：
$$\mathcal{M}_{\mathrm{KL}} \leftarrow \mathcal{M}_{\mathrm{KL}} \cup \{m\} \tag{7.5}$$

---

## 八、总结

**Generative Agents vs MemGPT**：

| 方面 | Generative Agents | MemGPT |
|------|------------------|--------|
| **核心创新** | 观察-反思-检索-规划循环 | 层级记忆管理系统 |
| **记忆表示** | 自然语言叙事 | 结构化层级 |
| **检索方式** | 重要性加权的动态检索 | 智能层级管理 |
| **适用场景** | 长时间一致性的 Agent | 突破上下文限制 |

**核心洞察**：

> 记忆是 Agent 系统的基础设施。Generative Agents 强调如何动态管理记忆流，MemGPT 强调如何在有限的上下文和无限的记忆之间做层级管理。两者都指向同一个问题：**如何让模型在长期交互中保持一致性和知识**。

**关键挑战**：

1. 信息的压缩与摘要
2. 检索的相关性排序
3. 记忆与当前上下文的融合
4. 长时间一致性

---

**延伸阅读**：

1. Park et al., "Generative Agents: Interactive Simulacra of Human Behavior" (UIST 2022)
2. Packer et al., "MemGPT: Towards LLMs as Operating Systems" (2023)
3. Shinn et al., "Reflexion: Language Agents with Verbal Reinforcement Learning" (NeurIPS 2023)
4. Liu et al., "Let Me Tell You a Story: Long-Term Memory for Agent Applications" (2023)
5. Zhong et al., "Memory Sandbox: Unified Memory Platform for LLM Applications" (2023)