# ReMe
**Repository Path**: chenfei6095/ReMe
## Basic Information
- **Project Name**: ReMe
- **Description**: ReMe: Memory Management Kit for Agents
ReMe provides AI agents with a unified memory system—enabling the ability to extract, reuse, and share memories across users, tasks, and agents.
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: main
- **Homepage**: https://reme.agentscope.io
- **GVP Project**: No
## Statistics
- **Stars**: 1
- **Forks**: 0
- **Created**: 2026-01-05
- **Last Updated**: 2026-03-17
## Categories & Tags
**Categories**: Uncategorized
**Tags**: agentscope, ReMe, memory
## README
面向智能体的记忆管理工具包,Remember Me, Refine Me.
> 老版本请参阅 [0.2.x 版本文档](docs/README_0_2_x_ZH.md)
---
🧠 ReMe 是一个专为 **AI 智能体** 打造的记忆管理框架,同时提供基于[文件系统](#-基于文件的记忆系统-remelight)和基于[向量库](#-基于向量库的记忆系统)的记忆系统。
它解决智能体记忆的两类核心问题:**上下文窗口有限**(长对话时早期信息被截断或丢失)、**会话无状态**(新对话无法继承历史,每次从零开始)。
ReMe 让智能体拥有**真正的记忆力**——旧对话自动浓缩,重要信息持久保存,下次对话自动想起来。
你可以用 ReMe 做什么
- **个人助理**:为 [CoPaw](https://github.com/agentscope-ai/CoPaw) 等智能体提供长期记忆,记住用户偏好和历史对话。
- **编程助手**:记录代码风格偏好、项目上下文,跨会话保持一致的开发体验。
- **客服机器人**:记录用户问题历史、偏好设置,提供个性化服务。
- **任务自动化**:从历史任务中学习成功/失败模式,持续优化执行策略。
- **知识问答**:构建可检索的知识库,支持语义搜索和精确匹配。
- **多轮对话**:自动压缩长对话,在有限上下文窗口内保留关键信息。
---
## 📁 基于文件的记忆系统 (ReMeLight)
> 记忆即文件,文件即记忆
将**记忆视为文件**——可读、可编辑、可复制。
[CoPaw](https://github.com/agentscope-ai/CoPaw) 通过继承 `ReMeLight` 实现了长期记忆和上下文的管理。
| 传统记忆系统 | File Based ReMe |
|-----------|-----------------|
| 🗄️ 数据库存储 | 📝 Markdown 文件 |
| 🔒 不可见 | 👀 随时可读 |
| ❌ 难修改 | ✏️ 直接编辑 |
| 🚫 难迁移 | 📦 复制即迁移 |
```
working_dir/
├── MEMORY.md # 长期记忆:用户偏好等持久信息
├── memory/
│ └── YYYY-MM-DD.md # 每日日记:对话结束后自动写入
└── tool_result/ # 超长工具输出缓存(自动管理,超期自动清理)
└── .txt
```
### 核心能力
[ReMeLight](reme/reme_light.py) 是该记忆系统的核心类,为 AI Agent 提供完整的记忆管理能力:
| 类别 | 方法 | 功能 | 关键组件 |
| 上下文管理 | check_context | 📊 检查上下文大小 | ContextChecker — 检查上下文是否超出阈值并拆分 Message |
compact_memory | 📦 压缩历史对话为摘要 | Compactor — ReActAgent 生成结构化上下文摘要 |
compact_tool_result | ✂️ 压缩超长工具输出 | ToolResultCompactor — 截断超长的工具调用结果并转存到 tool_result/,消息中保留文件引用 |
pre_reasoning_hook | 🔄 推理前预处理钩子 | compact_tool_result + check_context + compact_memory + summary_memory(async) |
| 长期记忆 | summary_memory | 📝 将重要记忆写入文件 | Summarizer — ReActAgent + 文件工具(read / write / edit) |
memory_search | 🔍 语义搜索记忆 | MemorySearch — 向量 + BM25 混合检索 |
| - | start | 🚀 启动记忆系统 | 初始化文件存储、文件监控、Embedding 缓存;清理过期工具结果文件 |
| - | close | 📕 关闭并清理 | 清理工具结果文件、停止文件监控、保存 Embedding 缓存 |
---
### 🚀 快速开始
#### 安装
**从源码安装:**
```bash
git clone https://github.com/agentscope-ai/ReMe.git
cd ReMe
pip install -e ".[light]"
```
**更新到最新版本:**
```bash
git pull
pip install -e ".[light]"
```
#### 环境变量
`ReMeLight` 环境变量配置 Embedding 和存储后端
| Variable | Description | Example |
|----------------------|-------------------------|-----------------------------------------------------|
| `LLM_API_KEY` | LLM API key | `sk-xxx` |
| `LLM_BASE_URL` | LLM base URL | `https://dashscope.aliyuncs.com/compatible-mode/v1` |
| `EMBEDDING_API_KEY` | Embedding API key (可选) | `sk-xxx` |
| `EMBEDDING_BASE_URL` | Embedding base URL (可选) | `https://dashscope.aliyuncs.com/compatible-mode/v1` |
#### Python 使用
```python
import asyncio
from reme.reme_light import ReMeLight
async def main():
# 初始化 ReMeLight
reme = ReMeLight(
default_as_llm_config={"model_name": "qwen3.5-35b-a3b"},
# default_embedding_model_config={"model_name": "text-embedding-v4"},
default_file_store_config={"fts_enabled": True, "vector_enabled": False},
)
await reme.start()
messages = [...] # 对话消息列表
# 1. 压缩超长工具输出(防止工具结果撑爆上下文)
messages = await reme.compact_tool_result(messages)
# 2. 将历史对话压缩为结构化摘要(可传入上轮摘要,实现增量更新)
summary = await reme.compact_memory(
messages=messages,
previous_summary="",
max_input_length=128000, # 模型上下文窗口(tokens)
compact_ratio=0.7, # 达到 max_input_length * 0.7 时触发压缩
language="zh", # 摘要语言(zh / "")
)
# 3. 后台异步提交摘要任务(不阻塞对话,摘要写入 memory/YYYY-MM-DD.md)
reme.add_async_summary_task(messages=messages)
# 4. 推理前预处理钩子(自动压缩工具结果 + 生成摘要)
processed_messages, compressed_summary = await reme.pre_reasoning_hook(
messages=messages,
system_prompt="你是一个有帮助的 AI 助手。",
compressed_summary="",
max_input_length=128000,
compact_ratio=0.7,
memory_compact_reserve=10000,
enable_tool_result_compact=True,
tool_result_compact_keep_n=3,
)
# 5. 语义搜索记忆(向量 + BM25 混合检索)
result = await reme.memory_search(query="Python 版本偏好", max_results=5)
# 6. 创建会话内存实例(管理单次对话的上下文)
from reme.memory.file_based.reme_in_memory_memory import ReMeInMemoryMemory
memory = ReMeInMemoryMemory()
for msg in messages:
await memory.add(msg)
token_stats = await memory.estimate_tokens(max_input_length=128000)
print(f"当前上下文使用率: {token_stats['context_usage_ratio']:.1f}%")
print(f"消息 Token 数: {token_stats['messages_tokens']}")
print(f"预估总 Token 数: {token_stats['estimated_tokens']}")
# 7. 关闭前等待后台任务完成
summary_result = await reme.await_summary_tasks()
# 关闭 ReMeLight
await reme.close()
if __name__ == "__main__":
asyncio.run(main())
```
> 📂 完整示例代码:[test_reme_light.py](tests/light/test_reme_light.py)
> 📋 运行结果示例:[test_reme_light_log.txt](tests/light/test_reme_light_log.txt)(223,838 tokens → 1,105 tokens,压缩率99.5%)
### 基于文件的 ReMeLight 记忆系统架构
[CoPaw MemoryManager](https://github.com/agentscope-ai/CoPaw/blob/main/src/copaw/agents/memory/memory_manager.py) 继承
`ReMeLight`,将记忆能力集成到 Agent 推理流程中:
```mermaid
graph LR
Agent[Agent] -->|每轮推理前| Hook[pre_reasoning_hook]
Hook --> TC[compact_tool_result
压缩工具输出]
TC --> CC[check_context
Token 计数]
CC -->|超限| CM[compact_memory
生成摘要]
CC -->|超限| SM[summary_memory
异步持久化]
SM -->|ReAct + FileIO| Files[memory/*.md]
Agent -->|主动调用| Search[memory_search
向量+BM25]
Agent -->|会话内存| InMem[ReMeInMemoryMemory
Token感知内存]
Files -.->|FileWatcher| Store[(FileStore
向量+FTS索引)]
Search --> Store
```
---
#### 1. check_context — 上下文检查
[ContextChecker](reme/memory/file_based/components/context_checker.py) 基于 Token 计数判断上下文是否超限,自动拆分为「待压缩」和「保留」两组消息。
```mermaid
graph LR
M[messages] --> H[AsMsgHandler
Token 计数]
H --> C{total > threshold?}
C -->|否| K[返回全部消息]
C -->|是| S[从尾部向前保留
reserve tokens]
S --> CP[messages_to_compact
早期消息]
S --> KP[messages_to_keep
近期消息]
S --> V{is_valid
工具调用对齐?}
```
- **核心逻辑**:从尾部向前保留 `reserve` tokens,超出部分标记为待压缩
- **完整性保证**:不拆分 user-assistant 对话对,不拆分 tool_use/tool_result 配对
---
#### 2. compact_memory — 对话压缩
[Compactor](reme/memory/file_based/components/compactor.py) 使用 ReActAgent 将历史对话压缩为**结构化上下文摘要**。
```mermaid
graph LR
M[messages] --> H[AsMsgHandler
format_msgs_to_str]
H --> A[ReActAgent
reme_compactor]
P[previous_summary] -->|增量更新| A
A --> S[结构化摘要
Goal/Progress/Decisions...]
```
**摘要结构**(上下文检查点):
| 字段 | 说明 |
|-----------------------|--------------------|
| `## Goal` | 用户目标 |
| `## Constraints` | 约束和偏好 |
| `## Progress` | 任务进展 |
| `## Key Decisions` | 关键决策 |
| `## Next Steps` | 下一步计划 |
| `## Critical Context` | 文件路径、函数名、错误信息等关键数据 |
- **增量更新**:传入 `previous_summary` 时,自动将新对话与旧摘要合并
---
#### 3. summary_memory — 记忆持久化
[Summarizer](reme/memory/file_based/components/summarizer.py) 采用 **ReAct + 文件工具** 模式,让 AI 自主决定写什么、写到哪。
```mermaid
graph LR
M[messages] --> A[ReActAgent
reme_summarizer]
A -->|read| R[读取 memory/YYYY-MM-DD.md]
R --> T{思考: 如何合并?}
T -->|write| W[覆盖写入]
T -->|edit| E[精确替换]
W --> F[memory/YYYY-MM-DD.md]
E --> F
```
**文件工具**([FileIO](reme/memory/file_based/tools/file_io.py)):
| 工具 | 功能 |
|---------|---------|
| `read` | 读取文件内容 |
| `write` | 覆盖写入文件 |
| `edit` | 精确匹配后替换 |
---
#### 4. compact_tool_result — 工具结果压缩
[ToolResultCompactor](reme/memory/file_based/components/tool_result_compactor.py) 解决工具输出过长导致上下文膨胀的问题。
```mermaid
graph LR
M[messages] --> L{遍历 tool_result
len > threshold?}
L -->|否| K[保留原样]
L -->|是| T[truncate_text
截断到 threshold]
T --> S[完整内容写入
tool_result/uuid.txt]
S --> R[消息追加文件路径引用]
R --> C[cleanup_expired_files
清理过期文件]
```
- **自动清理**:过期文件(超过 `retention_days`)在 `start`/`close`/`compact_tool_result` 时自动删除
---
#### 5. memory_search — 记忆检索
[MemorySearch](reme/memory/file_based/tools/memory_search.py) 提供**向量 + BM25 混合检索**能力。
```mermaid
graph LR
Q[query] --> E[Embedding
向量化]
E --> V[vector_search
语义相似]
Q --> B[BM25
关键词匹配]
V -->|" weight: 0.7 "| M[去重 + 加权融合]
B -->|" weight: 0.3 "| M
M --> F[min_score 过滤]
F --> R[Top-N 结果]
```
- **融合机制**:向量权重 0.7 + BM25 权重 0.3,兼顾语义相似和精确匹配
---
#### 6. ReMeInMemoryMemory — 会话内存
[ReMeInMemoryMemory](reme/memory/file_based/reme_in_memory_memory.py) 扩展 AgentScope 的 `InMemoryMemory`,提供 Token
感知的内存管理。
```mermaid
graph LR
C[content] --> G[get_memory
exclude_mark=COMPRESSED]
G --> F[排除已压缩消息]
F --> P{prepend_summary?}
P -->|是| S[头部插入 previous-summary]
S --> O[输出 messages]
P -->|否| O
```
| 功能 | 说明 |
|----------------------------------|-------------------|
| `get_memory` | 按标记过滤,自动追加压缩摘要 |
| `estimate_tokens` | 估算上下文 Token 用量 |
| `state_dict` / `load_state_dict` | 状态序列化/反序列化(会话持久化) |
---
#### 7. pre_reasoning_hook — 推理前预处理
整合上述组件的统一入口,在每轮推理前自动管理上下文。
```mermaid
graph LR
M[messages] --> TC[compact_tool_result
压缩超长工具输出]
TC --> CC[check_context
计算剩余空间]
CC --> D{messages_to_compact
非空?}
D -->|否| K[返回原消息 + 原摘要]
D -->|是| V{is_valid?}
V -->|否| K
V -->|是| CM[compact_memory
同步生成摘要]
V -->|是| SM[add_async_summary_task
异步持久化]
CM --> R[返回 messages_to_keep + 新摘要]
```
**执行流程**:
1. `compact_tool_result` — 压缩超长工具输出
2. `check_context` — 检查上下文是否超限
3. `compact_memory` — 生成压缩摘要(同步)
4. `summary_memory` — 持久化记忆(异步后台)
---
## 🗃️ 基于向量库的记忆系统
[ReMe Vector Based](reme/reme.py) 是基于向量库的记忆系统核心类,支持三种记忆类型的统一管理:
| 记忆类型 | 用途 |
|--------------|------------------|
| **个人记忆** | 记录用户偏好、习惯 |
| **任务/程序性记忆** | 记录任务执行经验、成功/失败模式 |
| **工具记忆** | 记录工具使用经验、参数优化 |
### 核心能力
| 方法 | 功能 | 说明 |
|--------------------|----------|----------------|
| `summarize_memory` | 🧠 记忆总结 | 从对话中自动提取并存储记忆 |
| `retrieve_memory` | 🔍 记忆检索 | 根据查询检索相关记忆 |
| `add_memory` | ➕ 添加记忆 | 手动添加记忆到向量库 |
| `get_memory` | 📖 获取记忆 | 通过 ID 获取单条记忆 |
| `update_memory` | ✏️ 更新记忆 | 更新已有记忆的内容或元数据 |
| `delete_memory` | 🗑️ 删除记忆 | 删除指定记忆 |
| `list_memory` | 📋 列出记忆 | 列出某类记忆,支持过滤和排序 |
### 安装与环境变量
安装和环境变量配置与 [ReMeLight 一致](#安装),通过环境变量设置 API 密钥,可写在项目根目录的 `.env` 文件中。
## 🧪 实验
本实验部分在 LoCoMo、LongMemEval、HaluMem 三个数据集上进行评测,实验设置如下:
1. **ReMe 使用模型**:如各表 backbone 列所示。
2. **评估使用模型**:采用 LLM-as-a-Judge 协议(参照 MemOS)——每条回答由 GPT-4o-mini 裁判模型打分。
实验设置尽量与各基线论文保持一致,以复用其公开结果。
### LoCoMo
| Method | Single Hop | Multi Hop | Temporal | Open Domain | Overall |
|--------|------------|-----------|-----------|-------------|-----------|
| MemoryOS | 62.43 | 56.50 | 37.18 | 40.28 | 54.70 |
| Mem0 | 66.71 | 58.16 | 55.45 | 40.62 | 61.00 |
| MemU | 72.77 | 62.41 | 33.96 | 46.88 | 61.15 |
| MemOS | 81.45 | 69.15 | 72.27 | 60.42 | 75.87 |
| HiMem | 89.22 | 70.92 | 74.77 | 54.86 | 80.71 |
| Zep | 88.11 | 71.99 | 74.45 | 66.67 | 81.06 |
| TiMem | 81.43 | 62.20 | 77.63 | 52.08 | 75.30 |
| TSM | 84.30 | 66.67 | 71.03 | 58.33 | 76.69 |
| MemR3 | 89.44 | 71.39 | 76.22 | 61.11 | 81.55 |
| **ReMe** | **89.89** | **82.98** | **83.80** | **71.88** | **86.23** |
### HaluMem
| Method | Memory Integrity | Memory Accuracy | QA Accuracy |
|-------------|------------------|---------------|-------------|
| MemoBase | 14.55 | 92.24 | 35.53 |
| Supermemory | 41.53 | 90.32 | 54.07 |
| Mem0 | 42.91 | 86.26 | 53.02 |
| ProMem | **73.80** | 89.47 | 62.26 |
| **ReMe** | 67.72 | **94.06** | **88.78** |
### Python 使用
```python
import asyncio
from reme import ReMe
async def main():
# 初始化 ReMe
reme = ReMe(
working_dir=".reme",
default_llm_config={
"backend": "openai",
"model_name": "qwen3.5-plus",
},
default_embedding_model_config={
"backend": "openai",
"model_name": "text-embedding-v4",
"dimensions": 1024,
},
default_vector_store_config={
"backend": "local", # 支持 local/chroma/qdrant/elasticsearch
},
)
await reme.start()
messages = [
{"role": "user", "content": "帮我写一个 Python 脚本", "time_created": "2026-02-28 10:00:00"},
{"role": "assistant", "content": "好的,我来帮你写", "time_created": "2026-02-28 10:00:05"},
]
# 1. 从对话中总结记忆(自动提取用户偏好、任务经验等)
result = await reme.summarize_memory(
messages=messages,
user_name="alice", # 个人记忆
# task_name="code_writing", # 任务记忆
)
print(f"总结结果: {result}")
# 2. 检索相关记忆
memories = await reme.retrieve_memory(
query="Python 编程",
user_name="alice",
# task_name="code_writing",
)
print(f"检索结果: {memories}")
# 3. 手动添加记忆
memory_node = await reme.add_memory(
memory_content="用户喜欢简洁的代码风格",
user_name="alice",
)
print(f"添加的记忆: {memory_node}")
memory_id = memory_node.memory_id
# 4. 通过 ID 获取单条记忆
fetched_memory = await reme.get_memory(memory_id=memory_id)
print(f"获取的记忆: {fetched_memory}")
# 5. 更新记忆内容
updated_memory = await reme.update_memory(
memory_id=memory_id,
user_name="alice",
memory_content="用户喜欢简洁且带注释的代码风格",
)
print(f"更新后的记忆: {updated_memory}")
# 6. 列出用户的所有记忆(支持过滤和排序)
all_memories = await reme.list_memory(
user_name="alice",
limit=10,
sort_key="time_created",
reverse=True,
)
print(f"用户记忆列表: {all_memories}")
# 7. 删除指定记忆
await reme.delete_memory(memory_id=memory_id)
print(f"已删除记忆: {memory_id}")
# 8. 删除所有记忆(谨慎使用)
# await reme.delete_all()
await reme.close()
if __name__ == "__main__":
asyncio.run(main())
```
### 技术架构
```mermaid
graph LR
User[用户 / Agent] --> ReMe[Vector Based ReMe]
ReMe --> Summarize[记忆总结]
ReMe --> Retrieve[记忆检索]
ReMe --> CRUD[增删改查]
Summarize --> PersonalSum[PersonalSummarizer]
Summarize --> ProceduralSum[ProceduralSummarizer]
Summarize --> ToolSum[ToolSummarizer]
Retrieve --> PersonalRet[PersonalRetriever]
Retrieve --> ProceduralRet[ProceduralRetriever]
Retrieve --> ToolRet[ToolRetriever]
PersonalSum --> VectorStore[向量数据库]
ProceduralSum --> VectorStore
ToolSum --> VectorStore
PersonalRet --> VectorStore
ProceduralRet --> VectorStore
ToolRet --> VectorStore
```
### 实验效果
Coming soon...
---
## 🧪 程序化记忆论文
> 我们的程序性(任务)记忆论文已在 [arXiv](https://arxiv.org/abs/2512.10696) 发布
### 🌍 [Appworld 实验](benchmark/appworld/quickstart.md)
我们在 Appworld 环境上使用 Qwen3-8B(非思考模式)进行评测:
| 方法 | Avg@4 | Pass@4 |
|---------|---------------------|---------------------|
| 无 ReMe | 0.1497 | 0.3285 |
| 使用 ReMe | 0.1706 **(+2.09%)** | 0.3631 **(+3.46%)** |
Pass@K 衡量在生成 K 个候选中,至少一个成功完成任务(score=1)的概率。
当前实验使用的是内部 AppWorld 环境,可能与对外版本存在轻微差异。
关于如何复现实验的更多细节,见 [quickstart.md](benchmark/appworld/quickstart.md)
### 🔧 [BFCL-V3 实验](benchmark/bfcl/quickstart.md)
我们在 BFCL-V3 multi-turn-base 任务(随机划分 50 train / 150 val)上,使用 Qwen3-8B(思考模式)进行评测:
| 方法 | Avg@4 | Pass@4 |
|---------|---------------------|---------------------|
| 无 ReMe | 0.4033 | 0.5955 |
| 使用 ReMe | 0.4450 **(+4.17%)** | 0.6577 **(+6.22%)** |
关于如何复现实验的更多细节,见 [quickstart.md](benchmark/bfcl/quickstart.md)
## ⭐ 社区与支持
- **Star 与 Watch**:Star 可让更多智能体开发者发现 ReMe;Watch 可助你第一时间获知新版本与特性。
- **分享你的成果**:在 Issue 或 Discussion 中分享 ReMe 为你的智能体解锁了什么——我们非常乐意展示社区的优秀案例。
- **需要新功能?** 提交 Feature Request,我们将与社区一起完善。
- **代码贡献**:欢迎任何形式的代码贡献,请参阅 [贡献指南](docs/contribution.md)。
- **致谢**:感谢 OpenClaw、Mem0、MemU、CoPaw 等优秀的开源项目,为项目带来诸多启发与帮助。
### 贡献者
感谢所有为 ReMe 做出贡献的朋友们:
---
## 📄 引用
```bibtex
@software{AgentscopeReMe2025,
title = {AgentscopeReMe: Memory Management Kit for Agents},
author = {ReMe Team},
url = {https://reme.agentscope.io},
year = {2025}
}
```
---
## ⚖️ 许可证
本项目基于 Apache License 2.0 开源,详情参见 [LICENSE](./LICENSE) 文件。
---
## 🤔 为什么叫 ReMe?
ReMe 是 **Remember Me** 和 **Refine Me** 的缩写,寓意让 AI 智能体「记住我」并在交互中「精进自我」。我们希望 ReMe
不只是一个冷冰冰的记忆模块,而是能让智能体真正理解用户、积累经验、持续进化的伙伴。
---
## 📈 Star 历史
[](https://www.star-history.com/#agentscope-ai/ReMe&Date)