07. 记忆系统完全指南

课程信息

• 作者：老金

• GitHub：https://github.com/KimYx0207

• 公众号：老金带你玩AI

• X（Twitter）：老金带你玩AI

• 个人博客：https://aiking.dev

• 难度等级：🟡 进阶

• 阅读时间：25 分钟

• 前置知识：已完成快速开始（03-快速开始指南）

本篇你将学会： 理解 AI 的记忆机制、配置记忆存储、管理和优化 AI 的记忆

小白速通： 只看前 2 节（"为什么 AI 需要记忆"、"记忆架构"），了解概念就够了。OpenClaw 的记忆系统开箱即用，不需要额外配置

2026-08-06 版本口径：v2026.7.1-1 修复了 Memory Core 启动冲突导致的 fatal restart loop（之前部分配置会在启动时无限重启），同时 State safety & recovery 让记忆写入遇到 schema 升级时拒绝丢数据而非静默覆盖。如果你之前因为记忆相关报错而停用，升级到 v2026.7.1-2 后建议先用 openclaw doctor 验证一次再决定是否重新启用。具体行为以本机版本为准。

为什么 AI 需要记忆？

我在 OpenClaw 记忆这篇里保留很多边界提醒，是因为老金知道记忆一旦写错，后面所有自动化都会被带偏。

你跟朋友聊天，不需要每次都自我介绍。因为朋友记得你是谁、你喜欢什么、上次聊了什么。

但 AI 不一样。大语言模型本质上是"无状态"的 — 每次对话结束，它就把你忘得一干二净。下次你再说"继续上次的方案"，它会一脸茫然地问你"什么方案？"

这就是记忆系统要解决的核心问题：让 AI 像一个真正的助手一样，记住你是谁、你在做什么、你喜欢什么。

没有记忆的 AI 助手：

你：帮我改一下昨天那个 React 组件
AI：请问你指的是哪个组件？能提供更多上下文吗？
你：……我昨天跟你聊了两个小时啊
AI：抱歉，我没有之前对话的记录。

有记忆的 AI 助手：

你：帮我改一下昨天那个 React 组件
AI：你说的是 UserProfile 组件吧？昨天你提到想把头像上传功能
    从 base64 改成 presigned URL。我来改一下。

差距一目了然。

记忆系统的三大价值

价值

说明

举例

连续性

跨会话保持上下文

记住你正在做的项目、进度、决策

个性化

了解你的偏好和习惯

知道你喜欢 TypeScript、不用分号、偏好函数式风格

效率

减少重复沟通

不用每次都解释你的技术栈、团队结构、工作流程

OpenClaw 记忆架构

OpenClaw 的记忆系统设计哲学非常务实：Markdown 文件 + sqlite-vec（轻量级的向量数据库，用于语义搜索） 向量索引，兼顾透明可控和智能检索。

AI 的记忆源头是写在磁盘上的 Markdown 文件和会话日志。你可以直接用文本编辑器查看、修改、删除 AI 的记忆，完全透明可控。同时，系统使用 sqlite-vec 做向量存储，支持语义搜索、混合搜索（hybrid search）、时间衰减（temporal decay）、最大边际相关性（MMR）和查询扩展（query expansion）等高级检索能力。

三层记忆架构

OpenClaw 把记忆分成三层，各司其职：

┌─────────────────────────────────────────────────┐
│                  会话记忆 (Session Memory)         │
│  存在于当前对话的上下文窗口中                        │
│  会话结束即消失（除非主动持久化）                     │
│  容量：受模型上下文窗口限制                          │
└──────────────────────┬──────────────────────────┘
                       │ compaction（上下文压缩，当对话太长时自动总结之前的内容） 时自动刷新
                       ▼
┌─────────────────────────────────────────────────┐
│                  短期记忆 (Daily Logs)             │
│  memory/YYYY-MM-DD.md                            │
│  每天一个文件，记录当天的笔记和上下文                 │
│  默认加载今天 + 昨天的日志                          │
│  容量：无限制（每天一个文件）                        │
└──────────────────────┬──────────────────────────┘
                       │ 手动或自动整理
                       ▼
┌─────────────────────────────────────────────────┐
│                  长期记忆 (MEMORY.md)              │
│  精选的持久信息                                    │
│  偏好、决策、重要事实、用户画像                      │
│  每次主会话启动时加载                               │
│  容量：建议控制在 2000 行以内                       │
└─────────────────────────────────────────────────┘

记忆源

OpenClaw 的记忆来自三类文件：

~/.openclaw/workspace/
├── MEMORY.md              # 长期记忆（精选的重要信息）
├── USER.md                # 用户画像（姓名、偏好、习惯）
├── SOUL.md                # Agent 人格定义
├── dreams.md              # Dreaming 系统产出（v2026.4.5 新增）
├── memory/
│   ├── 2026-02-25.md      # 今天的日志
│   ├── 2026-02-24.md      # 昨天的日志
│   ├── 2026-02-23.md      # 前天的日志
│   └── ...                # 更早的日志
└── sessions/
    └── *.jsonl            # 会话日志（自动记录）

记忆源汇总：

• MEMORY.md — 手动维护的长期记忆

• workspace/memory/*.md — 每日日志

• dreams.md — Dreaming 系统自动整理的记忆产出（v2026.4.5 新增）

• sessions/*.jsonl — 会话历史记录

各层记忆详解

会话记忆 (Session Memory)

会话记忆就是当前对话的上下文。你跟 AI 说的每一句话、AI 的每一个回复，都在会话记忆里。

特点：

• 速度最快，AI 可以直接引用

• 容量有限，受模型上下文窗口约束（通常 128K-200K tokens）

• 会话结束就消失

• 对话太长时会触发 compaction（压缩），旧消息会被摘要

你：我的项目用 Next.js 14
AI：好的，Next.js 14。（这句话现在在会话记忆里）

... 聊了 200 条消息 ...

AI：（compaction 触发，早期消息被压缩成摘要）

短期记忆 (Daily Logs)

每天一个 Markdown 文件，记录当天的重要信息。

<!-- memory/2026-02-25.md -->
# 2026-02-25

## 上午
- 讨论了新的认证方案，决定用 NextAuth.js v5
- 用户提到下周三有产品评审会

## 下午
- 修复了 UserProfile 组件的头像上传 bug
- 用户要求把所有 API 响应格式统一为 { data, error } 结构

加载策略：

• 每次新会话启动时，自动加载今天和昨天的日志

• 可以通过配置调整加载天数

长期记忆 (MEMORY.md)

精选的、持久的重要信息。这是 AI 的"核心记忆"。

<!-- MEMORY.md -->
# 长期记忆

## 用户偏好
- 编程语言：TypeScript，不用分号
- 框架：Next.js 14 + React 18
- 代码风格：函数式优先，避免 class
- 编辑器：VS Code + Vim 键位

## 项目信息
- 当前项目：电商平台重构
- 部署环境：Vercel (前端) + Railway (后端)
- 数据库：PostgreSQL + Prisma ORM

## 重要决策
- 2026-02-20：决定从 REST 迁移到 tRPC
- 2026-02-22：选择 Stripe 作为支付方案

记忆存储与检索

OpenClaw 的记忆系统使用 sqlite-vec 作为向量存储后端，结合 Markdown 文件实现透明可控的记忆管理。

向量存储：sqlite-vec

⏭️ 小白可跳过 — 这部分是技术深入分析，记忆系统默认配置已经够用

sqlite-vec 是 OpenClaw 的默认向量存储方案。它基于 SQLite 扩展，零配置、单文件，同时支持向量语义搜索。

sqlite-vec 开箱即用，不需要额外配置。如果需要自定义扩展路径，可以通过以下配置覆盖：

// ~/.openclaw/openclaw.json
{
  "agents": {
    "defaults": {
      "memorySearch": {
        "store": {
          "vector": {
            "enabled": true,
            "extensionPath": "/path/to/sqlite-vec"
          }
        }
      }
    }
  }
}

优点：

• 零配置，开箱即用（enabled 默认为 true）

• 单文件数据库，不需要安装额外服务

• 支持向量语义搜索和 BM25 混合搜索

• 记忆源文件（Markdown）仍然可以直接用编辑器查看和修改

• 如果 sqlite-vec 扩展加载失败，自动回退到 JS 内存中的余弦相似度计算

Embedding 提供商

⏭️ 小白可跳过 — 这部分是技术深入分析，记忆系统默认配置已经够用

sqlite-vec 需要配合 embedding（把文本转换成数字向量的技术，让 AI 能理解语义相似性） 模型将文本转为向量。OpenClaw 支持多种 embedding 提供商：

提供商

说明

OpenAI

text-embedding-3-small 等

Gemini

Google 的 embedding 模型

Mistral

Mistral 的 embedding 模型

Voyage

Voyage AI 的 embedding 模型

// ~/.openclaw/openclaw.json
{
  "agents": {
    "defaults": {
      "memorySearch": {
        "provider": "openai",
        "model": "text-embedding-3-small"
      }
    }
  }
}

Embedding 提供商通过 agents.defaults.memorySearch.provider 配置。如果不设置，OpenClaw 会按以下优先级自动选择：本地模型（如果配置了 local.modelPath）→ OpenAI → Gemini → Voyage → Mistral。也可以设置 provider: "local" 使用本地 GGUF 模型，完全离线运行。

高级检索能力

⏭️ 小白可跳过 — 这部分是技术深入分析，记忆系统默认配置已经够用

OpenClaw 的记忆检索不是简单的关键词匹配，而是一套完整的智能检索系统：

能力

说明

Hybrid Search（混合搜索）

同时使用关键词匹配和向量语义搜索，综合排序

Temporal Decay（时间衰减）

越新的记忆权重越高，旧记忆逐渐淡化

MMR（最大边际相关性）

搜索结果去重，避免返回高度相似的内容

Query Expansion（查询扩展）

自动扩展搜索词，提高召回率

这些能力开箱即用，不需要额外配置。

v2026.4.24 更新： 混合搜索现在在结果中暴露原始的 vectorScore（向量语义分数）和 textScore（关键词匹配分数），方便调试搜索质量。会话记录搜索也新增了可见性和 Agent 间策略控制。

记忆配置详解

记忆系统的行为可以通过 ~/.openclaw/openclaw.json（JSON5 格式）精细控制。

基础配置

记忆系统默认启用，不需要额外配置。OpenClaw 通过 memory-core 插件提供记忆功能（默认加载）。

如果你想关闭记忆系统：

如果要彻底关闭记忆插件，沿用前文 plugins.slots.memory = "none" 的配置即可；这里不重复贴完整 JSON，避免读者误以为这是另一种配置格式。

记忆文件存储在 workspace 目录下（默认 ~/.openclaw/workspace），可以通过 agents.defaults.workspace 修改 workspace 路径。记忆系统默认加载今天和昨天的日志（memory/YYYY-MM-DD.md）以及长期记忆（MEMORY.md，仅在私聊会话中加载）。

Compaction 与记忆刷新

这是 OpenClaw 记忆系统最聪明的设计之一。当对话越来越长，上下文窗口快要满的时候，OpenClaw 会触发 compaction（压缩）。在压缩之前，它会自动提醒 AI 把重要信息存到记忆文件里。

// ~/.openclaw/openclaw.json
{
  "agents": {
    "defaults": {
      "compaction": {
        "reserveTokensFloor": 20000,
        "memoryFlush": {
          "enabled": true,
          "softThresholdTokens": 4000,
          "systemPrompt": "Session nearing compaction. Store durable memories now.",
          "prompt": "Write any lasting notes to memory/YYYY-MM-DD.md; reply with NO_REPLY if nothing to store."
        }
      }
    }
  }
}

工作流程：上下文使用率达到阈值 → 触发 memoryFlush（隐藏的 Agent 轮次）→ AI 自动把重要信息写入日志 → 执行 compaction 压缩旧消息 → 对话继续。

你也可以在对话中手动触发压缩，使用聊天命令 /compact。

字段

说明

reserveTokensFloor

压缩后至少保留多少 tokens 的上下文

softThresholdTokens

距离压缩还有多少 tokens 时触发记忆刷新

记忆加载行为

每次会话启动时，OpenClaw 自动加载以下记忆：

• MEMORY.md — 长期记忆（仅在私聊会话中加载，群聊中不加载）

• memory/YYYY-MM-DD.md — 今天和昨天的日志

这个行为是内置的，不需要额外配置。如果你想让记忆搜索覆盖更多文件（比如 workspace 外的 Markdown），可以通过 extraPaths 扩展搜索范围：

// ~/.openclaw/openclaw.json
{
  "agents": {
    "defaults": {
      "memorySearch": {
        "extraPaths": ["../team-docs", "/srv/shared-notes/overview.md"]
      }
    }
  }
}

路径可以是绝对路径或相对于 workspace 的路径。目录会被递归扫描，但只索引 Markdown 文件（.md）。

为什么要注意记忆大小？因为记忆也占上下文窗口。日志写得太详细时，会挤占正常对话的空间。建议 MEMORY.md 控制在 3000 tokens 以内。

按 Agent 配置记忆

不同的 Agent 可以有不同的记忆行为。通过给每个 Agent 配置独立的 workspace，实现记忆隔离：

// ~/.openclaw/openclaw.json
{
  "agents": {
    "list": [
      {
        "id": "coding",
        "workspace": "~/.openclaw/workspace-coding"
      },
      {
        "id": "social",
        "workspace": "~/.openclaw/workspace-social"
      }
    ]
  }
}

每个 Agent 的 workspace 下有独立的 MEMORY.md 和 memory/ 目录。如果某个 Agent 完全不需要记忆功能，可以在它的 workspace 里不放任何记忆文件即可。

对话上下文管理

上下文窗口是 AI 的"工作记忆"，理解它的工作方式对用好记忆系统至关重要。

什么是上下文窗口？

上下文窗口就是模型一次能"看到"的所有文本。包括：

┌─────────────────────────────────────────┐
│ 系统提示词 (System Prompt)               │  ← 固定占用
│ - Agent 人格 (SOUL.md)                  │
│ - 技能指令                               │
│ - 工具定义                               │
├─────────────────────────────────────────┤
│ 记忆注入                                 │  ← 启动时加载
│ - MEMORY.md                             │
│ - USER.md                               │
│ - 最近几天的日志                          │
├─────────────────────────────────────────┤
│ 对话历史                                 │  ← 动态增长
│ - 用户消息                               │
│ - AI 回复                               │
│ - 工具调用结果                            │
├─────────────────────────────────────────┤
│ 剩余空间                                 │  ← 给 AI 生成回复用
└─────────────────────────────────────────┘

常见模型的上下文窗口差异很大，而且会随 provider 更新。写课程和配置前，先查当前 OpenClaw models 输出和 provider 文档，不要把旧数字当永久事实。

滑动窗口策略

当对话越来越长，上下文窗口快满了怎么办？OpenClaw 使用滑动窗口策略：

正常对话：  [系统提示 | 记忆 | 消息1 | 消息2 | ... | 消息N]
接近上限：  [系统提示 | 记忆 | [摘要:消息1-50] | 消息51 | ... | 消息N]
继续对话：  [系统提示 | 记忆 | [摘要:消息1-50] | 消息51 | ... | 消息N+M]

compaction 的过程：检测到上下文使用率超过阈值 → 触发 memoryFlush，AI 保存重要信息到记忆文件 → 将早期消息压缩成摘要 → 释放上下文空间，继续对话。

上下文预算管理

OpenClaw 通过 compaction 机制自动管理上下文空间。当对话接近上下文窗口上限时，会自动触发压缩。你可以通过 reserveTokensFloor 控制压缩后保留多少上下文空间：

// ~/.openclaw/openclaw.json
{
  "agents": {
    "defaults": {
      "compaction": {
        "reserveTokensFloor": 20000
      }
    }
  }
}

reserveTokensFloor 越大，压缩越激进（保留的旧消息越少）。默认值 20000 tokens 对大多数场景够用。

💡 实用建议： 如果记忆文件太大导致上下文空间不足，最有效的做法是精简 MEMORY.md 的内容（建议控制在 3000 tokens 以内），而不是调整配置参数。

用户画像和偏好记忆

OpenClaw 有一个专门的文件 USER.md 来存储用户画像。这跟 MEMORY.md 不同 — MEMORY.md 存的是各种杂项记忆，USER.md 专门描述"你是谁"。

USER.md 结构

<!-- ~/.openclaw/workspace/USER.md -->
# 用户画像

## 基本信息
- 姓名：老金 | 时区：Asia/Shanghai | 语言：中文为主

## 技术偏好
- 主力语言：TypeScript（不用分号，单引号，2 空格缩进）
- 前端：React + Next.js | 后端：Node.js + Fastify
- 数据库：PostgreSQL | 部署：Docker + Railway

## 沟通偏好
- 喜欢简洁直接的回答，代码示例比文字解释更有用
- 遇到问题先给方案，再解释原因

## 日程习惯
- 工作时间：9:00-18:00
- 每周一 10:00 团队周会 | 每周五 15:00 代码评审

自动学习用户偏好

OpenClaw 没有专门的"自动学习"配置开关。用户偏好的记录依赖于 AI 模型自身的判断 — 当你在对话中表达偏好时，AI 会主动将其写入 USER.md 或 MEMORY.md。

你可以通过 SOUL.md（Agent 人格文件）来引导 AI 更主动地记录偏好：

<!-- ~/.openclaw/workspace/SOUL.md 中添加 -->
## 记忆习惯
- 当用户表达偏好或习惯时，主动写入 USER.md
- 当用户做出重要决策时，记录到 MEMORY.md
- 每次对话结束前，检查是否有值得记录的信息

这种方式比配置文件更灵活 — 你可以用自然语言精确描述 AI 应该记住什么、怎么记住。

主动让 AI 记住

直接告诉 AI 你想让它记住什么：

记住：我的 GitHub 用户名是 laojin-dev
记住：项目部署在 Hetzner 的 VPS 上
记住：我不喜欢在代码里用分号
记住：跟我说话不用太客气，直接说重点

AI 会根据内容类型，自动决定写入 MEMORY.md 还是 USER.md：

• 个人偏好、习惯 → USER.md

• 项目信息、决策、事实 → MEMORY.md

• 临时笔记、当天事项 → memory/YYYY-MM-DD.md

记忆工具

AI 有专门的工具来操作记忆：

memory_search — 语义搜索

从所有记忆文件中搜索相关内容。

用户：我之前说过用什么支付方案来着？
AI：（调用 memory_search("支付方案")）
    → 找到 MEMORY.md 中的记录：2026-02-22 决定用 Stripe
AI：你在 2 月 22 号决定用 Stripe 作为支付方案。

搜索范围：

• MEMORY.md — 长期记忆

• USER.md — 用户画像

• memory/*.md — 所有日志文件

memory_get — 精确读取

读取某个记忆文件的特定内容。

用户：看看我昨天的笔记
AI：（调用 memory_get("memory/2026-02-24.md")）
    → 返回昨天日志的完整内容

记忆写入

AI 通过普通的文件写入工具来更新记忆文件。没有专门的"记忆写入"工具 — 这是故意的设计，保持简单。

用户：记住，我们决定用 Stripe
AI：（调用 file_write，写入 MEMORY.md）
    好的，已记录到长期记忆中。

知识库集成 (RAG)

当你需要 AI 记住大量结构化知识（比如公司文档、产品手册、代码库），普通的记忆文件就不够用了。这时候需要 RAG（Retrieval-Augmented Generation，检索增强生成）。

什么是 RAG？

简单说：AI 回答问题之前，先从知识库里搜索相关内容，然后带着这些内容去回答。

传统方式：
用户提问 → AI 凭记忆回答（可能瞎编）

RAG 方式：
用户提问 → 搜索知识库 → 找到相关文档 → AI 基于文档回答（有据可查）

OpenClaw 的 RAG 实现

OpenClaw 的记忆搜索本身就具备 RAG 能力 — 通过 memorySearch 索引 workspace 下的 Markdown 文件，支持语义搜索。如果你想索引 workspace 之外的文件，可以通过 extraPaths 扩展：

// ~/.openclaw/openclaw.json
{
  "agents": {
    "defaults": {
      "memorySearch": {
        "extraPaths": [
          "~/Documents/company-wiki",
          "~/projects/myapp/README.md"
        ]
      }
    }
  }
}

对于更高级的知识检索需求，OpenClaw 支持 QMD 后端（实验性功能），它结合了 BM25 + 向量搜索 + 重排序：

// ~/.openclaw/openclaw.json
{
  "memory": {
    "backend": "qmd",
    "qmd": {
      "includeDefaultMemory": true,
      "paths": [
        { "name": "docs", "path": "~/notes", "pattern": "**/*.md" }
      ],
      "update": { "interval": "5m" },
      "limits": { "maxResults": 6, "timeoutMs": 4000 }
    }
  }
}

⚠️ QMD 需要单独安装（bun install -g https://github.com/tobi/qmd），且需要支持扩展的 SQLite 构建。如果 QMD 不可用，OpenClaw 会自动回退到内置的 SQLite 搜索引擎。

知识源类型

OpenClaw 的 memorySearch 默认只索引 Markdown 文件（.md）。如果使用 QMD 后端，可以通过 paths 配置索引额外目录：

配置方式

说明

适用场景

默认 workspace

自动索引 MEMORY.md + memory/*.md

日常使用

extraPaths

索引 workspace 外的 Markdown 文件

需要引用外部文档

QMD paths

索引任意目录，支持 glob 模式

大规模知识库

向量搜索引擎

OpenClaw 内置两种搜索引擎：

引擎

特点

配置方式

内置 SQLite（默认）

零配置，sqlite-vec 加速，支持混合搜索

开箱即用

QMD（实验性）

BM25 + 向量 + 重排序，功能更强

memory.backend = "qmd"

知识库与记忆管理命令

记忆索引和知识库都通过 openclaw memory 子命令管理：

# 记忆索引管理
openclaw memory status             # 查看记忆索引状态
openclaw memory index              # 重建记忆索引
openclaw memory search "部署"       # 搜索记忆（支持语义搜索）

记忆 vs 知识库

维度

记忆系统

知识库 (RAG)

内容来源

对话中产生

预先准备的文档

更新方式

AI 自动写入

手动索引或监控

搜索方式

混合搜索（关键词 + 语义）

语义向量搜索

适合内容

偏好、决策、笔记

文档、手册、代码

数据量

小（几十个文件）

大（成百上千个文件）

记忆的增删改查操作

通过 CLI 操作

# 查看记忆索引状态
openclaw memory status

# 重建记忆索引（当记忆文件有变动时）
openclaw memory index

# 搜索记忆（支持语义搜索）
openclaw memory search "React 组件"

记忆文件本身是 Markdown，可以直接用编辑器查看和修改：

code ~/.openclaw/workspace/MEMORY.md                    # VS Code
vim ~/.openclaw/workspace/memory/2026-02-25.md          # Vim

修改后运行 openclaw memory index 重建索引，下次会话启动时 AI 就能看到更新的内容。

通过对话操作

直接跟 AI 说就行：

你：记住，我们的 API 基础 URL 是 https://api.example.com/v2    → 写入
你：我之前说过 API 地址是什么？                                  → 查询
你：API 地址改了，新地址是 https://api.example.com/v3            → 更新
你：把关于旧项目的记忆都删掉                                     → 删除
你：帮我整理一下长期记忆，删掉过时的信息                          → 整理

AI 会自动调用对应的记忆工具完成操作。

记忆隐私和安全

记忆文件里可能包含敏感信息。OpenClaw 提供了多层保护机制。

敏感信息过滤

OpenClaw 没有内置的记忆内容自动过滤配置。防止敏感信息写入记忆文件的最佳做法是通过 SOUL.md 明确告诉 AI：

<!-- ~/.openclaw/workspace/SOUL.md 中添加 -->
## 安全规则
- 永远不要将密码、API Key、Token、身份证号、银行卡号写入记忆文件
- 如果用户要求记住敏感信息，提醒用户使用环境变量或密钥管理器
- 记忆文件中的敏感信息用 [REDACTED] 替代

这种方式利用 AI 模型自身的判断力来过滤敏感内容，比正则匹配更智能（能识别上下文中的敏感语义，而不仅仅是模式匹配）。

记忆文件安全

OpenClaw 的记忆文件是纯文本 Markdown，存储在本地磁盘上，没有内置加密功能。如果你需要保护记忆文件：

• 磁盘加密：使用操作系统级别的磁盘加密（macOS FileVault、Linux LUKS、Windows BitLocker）

• 文件权限：确保 ~/.openclaw/workspace/ 目录权限为 700（仅所有者可读写）

• Git 忽略：如果 workspace 在 Git 仓库中，将记忆文件加入 .gitignore

# 设置 workspace 目录权限（macOS/Linux）
chmod 700 ~/.openclaw/workspace

不应该存入记忆的内容

无论有没有加密，密码、API Key、JWT Token、身份证号、银行卡号等敏感信息都不应该写入记忆文件。用环境变量或密钥管理器代替。

记忆操作追踪

OpenClaw 没有内置的记忆审计日志配置。但你可以通过以下方式追踪记忆变更：

• Git 版本控制：将 workspace 初始化为 Git 仓库，每次记忆变更都有完整历史

• 会话日志：OpenClaw 的会话日志（sessions/*.jsonl）记录了所有工具调用，包括文件写入操作

# 用 Git 追踪记忆变更
cd ~/.openclaw/workspace
git init
git add MEMORY.md USER.md memory/
git commit -m "memory snapshot"

这比内置审计日志更强大 — 你可以用 git diff 看到每次记忆变更的具体内容。

记忆系统调优

⏭️ 小白可跳过 — 这部分是技术深入分析，记忆系统默认配置已经够用

记忆文件大小控制

MEMORY.md 不应该无限增长。OpenClaw 没有内置的自动归档配置，但有以下最佳实践：

• MEMORY.md：建议控制在 500 行（约 3000 tokens）以内。内容太多会挤占对话上下文

• 每日日志：每天自动创建新文件，天然不会过大

• 手动归档：超过 30 天的日志可以手动移到归档目录

# 手动归档旧日志
mkdir -p ~/.openclaw/workspace/memory/archive
mv ~/.openclaw/workspace/memory/2025-*.md ~/.openclaw/workspace/memory/archive/

定期整理 MEMORY.md 是保持 AI 助手高效的关键 — 过时的信息不仅浪费上下文空间，还可能让 AI 产生错误判断。

记忆搜索优化

如果记忆文件很多，搜索会变慢。优化建议：

1. 运行 openclaw memory index 确保索引是最新的

2. 将旧日志移到归档目录（memory/archive/），减少索引文件数量

3. 给记忆内容加标签方便精确搜索：## 项目信息 [tags: project, tech-stack]

记忆加载性能

如果启动时加载记忆太慢，可以优化以下方面：

1. 精简 MEMORY.md — 删除过时内容，控制在 500 行以内

2. 减少日志文件数量 — 归档超过 30 天的旧日志

3. 重建索引 — 运行 openclaw memory index 确保索引是最新的

如果使用 QMD 后端，可以调整刷新间隔和超时：

// ~/.openclaw/openclaw.json
{
  "memory": {
    "backend": "qmd",
    "qmd": {
      "update": {
        "interval": "10m",
        "commandTimeoutMs": 30000
      },
      "limits": {
        "maxResults": 4,
        "timeoutMs": 3000
      }
    }
  }
}

💡 提示： QMD 首次搜索可能较慢（需要下载本地 GGUF 模型用于重排序和查询扩展）。后续搜索会快很多。

多用户记忆隔离

如果多个人共用一个 OpenClaw 实例（比如家庭成员或小团队），记忆必须隔离。

通过多 Agent 隔离

最简单的方案：每个用户一个 Agent，配置独立的 workspace。

// ~/.openclaw/openclaw.json
{
  "agents": {
    "list": [
      {
        "id": "alice",
        "workspace": "~/.openclaw/workspace-alice"
      },
      {
        "id": "bob",
        "workspace": "~/.openclaw/workspace-bob"
      }
    ]
  }
}

每个 Agent 有独立的 workspace，记忆文件完全隔离：

~/.openclaw/
├── workspace-alice/
│   ├── MEMORY.md          # Alice 的长期记忆
│   ├── USER.md            # Alice 的用户画像
│   └── memory/            # Alice 的日志
└── workspace-bob/
    ├── MEMORY.md          # Bob 的长期记忆
    ├── USER.md            # Bob 的用户画像
    └── memory/            # Bob 的日志

通过消息路由绑定

配合多 Agent 路由，让不同联系人的消息自动路由到对应 Agent。在顶层 bindings 配置中设置 channel、contact 和 agent 的映射关系即可（bindings 是顶层配置，不嵌套在 channels 内部）。详见 08. 多 Agent 路由。

共享记忆方案

如果需要多个 Agent 共享部分记忆，可以用符号链接指向同一个 MEMORY.md 文件，但要注意并发写入可能导致冲突。更安全的做法是通过独立 workspace 隔离，仅在需要时手动同步。

记忆插件系统

默认插件：memory-core

OpenClaw 默认使用 memory-core 插件提供记忆功能。这个插件包含：

• 记忆文件的读写操作

• memory_search 和 memory_get 工具

• compaction 时的自动记忆刷新

• 日志文件的自动创建和管理

关闭记忆功能

如果你不需要记忆（比如一次性的问答场景）：

// ~/.openclaw/openclaw.json
{
  "plugins": {
    "slots": {
      "memory": "none"
    }
  }
}

多语言记忆（v2026.2.22 新功能）

v2026.2.22 新增多语言记忆支持：

• 西班牙语

• 葡萄牙语

• 日语

• 韩语

• 阿拉伯语

AI 可以用这些语言写入和搜索记忆。搜索时会自动处理多语言匹配。

Dreaming 记忆整理系统（v2026.4.5 新增）

v2026.4.5 引入了实验性的 Dreaming（做梦） 机制 — 这是 OpenClaw 对记忆自动整理的一次大胆尝试。它模拟人类睡眠中的记忆巩固过程，在后台自动整理、提炼、淘汰记忆。

三阶段架构

Dreaming 系统由三个协作阶段组成（不是竞争关系，各自有独立的调度和恢复行为）：

阶段

名称

作用

Light（浅睡眠）

初步筛选

扫描最近的会话记录和日志，提取值得保留的信息片段

Deep（深度睡眠）

巩固整合

将分散的信息整合到长期记忆中，合并重复项，形成结构化知识

REM（快速眼动）

持久提升

将整理后的高价值记忆提升（promote）为持久记忆，写入 dreams.md

三个阶段在后台独立运行，不会阻塞正常对话。

Recall Decay（回忆衰减）

Dreaming 系统引入了可配置的记忆老化控制：

参数

说明

默认值

recencyHalfLifeDays

记忆权重半衰期（天数）— 超过此天数的记忆，召回权重降为一半

根据实例配置

maxAgeDays

记忆最大年龄（天数）— 超过此天数的记忆从活跃召回中淘汰

根据实例配置

这意味着 OpenClaw 可以自动「遗忘」过时的信息，而不需要你手动清理。越新的记忆越容易被召回，越旧的逐渐淡出 — 跟人类记忆的工作方式一样。

dreams.md 文件

Dreaming 的产出内容写入 dreams.md 文件（位于 workspace 目录下），与每日日志（memory/YYYY-MM-DD.md）分开存放。这样设计的好处是 dreams.md 可以被显式读取，但不会自动拉入默认召回上下文，避免占用过多上下文窗口空间。

~/.openclaw/workspace/
├── MEMORY.md              # 长期记忆（手动维护）
├── USER.md                # 用户画像
├── dreams.md              # Dreaming 系统产出（自动维护）
├── memory/
│   ├── 2026-04-25.md      # 今天的日志
│   └── ...
└── sessions/
    └── *.jsonl

Dream Diary（梦境日记 UI）

v2026.4.5 同时在 Control UI 的 Dreams 面板中添加了 Dream Diary 界面，可以直观查看 Dreaming 系统的活动记录 — 包括每次做梦的时间、阶段、处理了哪些记忆、提升了哪些内容。

Dreaming 与手动记忆管理的关系

Dreaming 是一个补充机制，不替代手动管理：

• MEMORY.md — 仍然是你手动维护的核心长期记忆

• dreams.md — Dreaming 系统自动产出的整理结果

• memory/YYYY-MM-DD.md — 每日日志，不受 Dreaming 影响

如果你不需要 Dreaming 功能，它默认处于实验状态，需要主动启用才会运行。

记忆最佳实践

1. 定期整理 MEMORY.md

MEMORY.md 是 AI 每次启动都会加载的文件。如果它太大太杂，会浪费上下文空间，还可能让 AI 混淆。

建议：

• 每周花 5 分钟整理一次

• 删除过时的信息（比如已完成的项目）

• 合并重复的条目

• 保持分类清晰

2. 善用日志文件

日常的临时信息写入日志，不要塞进 MEMORY.md：

# 好的做法
MEMORY.md → 只放长期有效的信息
memory/2026-02-25.md → 今天的临时笔记

# 不好的做法
MEMORY.md → 什么都往里塞，越来越臃肿

3. 让 AI 主动记录

重要对话后，主动让 AI 记录：

你：把今天讨论的技术方案要点记下来
AI：好的，我把以下要点写入了今天的日志：
    1. 认证方案选择 NextAuth.js v5
    2. 数据库从 MySQL 迁移到 PostgreSQL
    3. 缓存层用 Redis，TTL 设为 1 小时

4. 分类存储

在 MEMORY.md 中用清晰的标题分类：

## 技术栈
...

## 项目决策
...

## 团队信息
...

## 工作流程
...

5. 不要存敏感信息

密码、API Key、Token 等敏感信息不要写入记忆文件。用环境变量或密钥管理器。

6. 备份记忆

记忆文件是纯文本，非常适合用 Git 管理或定期导出：

# Git 管理
cd ~/.openclaw/workspace && git init && git add MEMORY.md USER.md memory/
git commit -m "backup: memory snapshot 2026-02-25"

# 定期打包备份
tar -czf ~/backups/memory-$(date +%Y%m%d).tar.gz ~/.openclaw/workspace/

工坊：给自己的 OpenClaw 做一次记忆整理

记忆系统真正好用，因为它知道什么应该长期保留，什么只应该进入当天日志，什么应该完全不写。下面这次练习会把 USER.md、MEMORY.md、每日记忆和索引命令串起来。

先查看当前记忆状态：

openclaw memory status

打开工作空间：

cd ~/.openclaw/workspace
ls

你通常会看到这些文件：

MEMORY.md
USER.md
dreams.md
memory/
sessions/

第一步，整理 USER.md。它只放长期稳定的用户偏好，不放项目临时事项：

# 用户画像

## 沟通偏好

- 希望回答先给结论，再给步骤。
- 不喜欢把内部检查标准写进面向读者的文章。
- 写中文教程时偏好自然、具体、可操作的表达。

## 技术偏好

- 代码修改前先阅读现有结构。
- 文档教程要有真实命令、真实案例、排错路径。

第二步，整理 MEMORY.md。它放长期项目事实和持续有效的决策：

# 长期记忆

## OpenClaw 学习环境

- Gateway 默认端口使用 18789。
- 常用配置文件位于 `~/.openclaw/openclaw.json`。
- 本地工作空间位于 `~/.openclaw/workspace/`。

## 文档写作原则

- 教程内容面向读者，不写内部交付标准。
- 遇到平台能力差异时，要明确说明边界，不把 Claude Code 或 Codex 的能力硬套到 OpenClaw。

第三步，把今天的临时工作写入每日日志，而不是塞进长期记忆：

# 2026-06-09

## OpenClaw 文档整理

- 检查了技能系统、记忆系统、多 Agent、Docker、安全配置几章。
- 发现 FAQ 编号需要按章节重新从 Q1 开始。
- 下一步继续补充可执行工坊和排错案例。

第四步，重建索引：

openclaw memory index
openclaw memory status

第五步，用自然语言测试召回：

我写 OpenClaw 教程时有哪些原则？

如果 OpenClaw 把当天临时事项误当成长期原则，说明 MEMORY.md 写得太杂；如果它完全召回不到文档写作原则，说明索引未更新、文件位置不对，或内容写得太抽象。

记忆分层决策：一句话应该写到哪里

很多记忆污染来自一个小问题：用户说“记一下”，Agent 不知道写到哪里。你可以用下面这张表做判断。

信息类型

推荐位置

示例

长期稳定偏好

USER.md

“我喜欢先结论后步骤”

长期项目事实

MEMORY.md

“Gateway 默认端口是 18789”

当天进展

memory/YYYY-MM-DD.md

“今天修了 FAQ 编号”

会议整理产物

dreams.md 或单独文档

“会议决定下周迁移部署方式”

外部知识资料

知识库 / RAG

“某 API 文档内容”

凭证、token、个人隐私

不写入记忆

API Key、身份证号、私聊原文

判断时可以问三个问题：

1. 三个月后还会有效吗？

2. 每次启动都应该让 Agent 看到吗？

3. 如果这个信息被另一个 Agent 看到，会不会造成隐私或误操作风险？

三个问题都偏“是”，才适合进入 MEMORY.md。只对今天有用，就写每日日志。只对某个材料检索有用，就进知识库。涉及凭证和隐私，直接不要写。

遗忘流程：删除、覆盖和降权

“让 AI 忘记”不是一句魔法咒语。OpenClaw 的记忆主要来自文件和索引，所以遗忘也要回到文件和索引。

如果你只是想删除一条明确内容：

cd ~/.openclaw/workspace

打开 MEMORY.md 或对应日期日志，删除那段内容，然后重建索引：

openclaw memory index

如果信息在多处出现，用搜索定位：

rg "旧项目 X|old-project-x|相关关键词" ~/.openclaw/workspace

逐处删除后，再问一次：

你还记得旧项目 X 的哪些信息？

如果 OpenClaw 仍然召回，可能来自会话历史、dreams.md 或知识库。继续搜索这些位置：

rg "旧项目 X|old-project-x|相关关键词" ~/.openclaw

如果要让旧信息不再主导回答，可以在 MEMORY.md 写清楚新的事实：

## 项目状态

- 旧项目 X 已归档，不再作为当前默认项目。
- 当前默认项目是 OpenClaw 文档课程。

这种做法适合项目迁移、偏好变化、职责变化。删除适合敏感信息和错误事实；覆盖适合“以前是真的，现在变了”的事实。

冲突处理：当 USER.md、MEMORY.md 和每日日志互相打架

记忆冲突很常见。例如：

USER.md：用户希望回答简短。
MEMORY.md：OpenClaw 教程需要写得厚。
memory/2026-06-09.md：今天要把安全章节补成详细工坊。

这三条并不矛盾。用户沟通偏好是“跟用户说话简短”，文档产物要求是“课程内容厚”。如果 Agent 把它们混起来，就会出现“教程也写得很短”的问题。

整理冲突时，用“适用范围”消解：

## 沟通偏好

- 和用户汇报进度时保持简短。
- 写课程正文时根据主题充分展开，不因为聊天偏好压缩教程内容。

再比如：

MEMORY.md：默认使用本地模型。
memory/2026-06-09.md：今天为了测试模型配置，临时使用 OpenAI provider。

这里应该把 MEMORY.md 改成：

## 模型策略

- 默认使用本地模型处理隐私材料。
- 做公开文档示例或非敏感测试时，可以临时切换云端 provider。

记忆冲突不能简单越删越好。把“默认规则”“例外情况”“适用场景”写清楚是更有效的整理方式。

迁移记忆：从个人机器到新环境

换电脑、换服务器、把 OpenClaw 从本地迁到 Docker，都会遇到记忆迁移。记忆迁移最重要的不是复制目录，而是避免把旧机器的凭证和会话垃圾一起带过去。

推荐迁移这些：

~/.openclaw/workspace/MEMORY.md
~/.openclaw/workspace/USER.md
~/.openclaw/workspace/memory/
~/.openclaw/workspace/dreams.md

谨慎迁移这些：

~/.openclaw/auth-profiles.json
~/.openclaw/agents/*/auth-profiles.json
~/.openclaw/workspace/sessions/

不要直接打包整个 ~/.openclaw 扔到新机器，除非你非常确定新旧环境的用户、路径、权限、模型 provider 都一致。

更稳的迁移流程：

# 旧机器：只打包记忆和用户画像
cd ~/.openclaw/workspace
tar -czf ~/openclaw-memory-clean.tar.gz MEMORY.md USER.md memory dreams.md

# 新机器：解压到工作空间
mkdir -p ~/.openclaw/workspace
tar -xzf ~/openclaw-memory-clean.tar.gz -C ~/.openclaw/workspace

# 新机器：重建索引
openclaw memory index
openclaw memory status

如果你有多个 Agent，不要把所有记忆合并成一个大文件。按 Agent 迁移：

main      -> ~/.openclaw/workspace/
coding    -> ~/.openclaw/workspace-coding/
support   -> ~/.openclaw/workspace-support/

迁移后分别测试：

你是谁？你负责什么？

如果 coding Agent 回答了 support Agent 的职责，说明工作空间或 SOUL/MEMORY 文件放错了。

记忆卫生：每周 10 分钟维护法

记忆系统不需要每天大扫除，但需要固定维护。每周花十分钟就够：

1. 打开 MEMORY.md，删除已经完成或过期的项目。

2. 把重复偏好合并成一条。

3. 把“今天做了什么”移到对应日期日志。

4. 搜索 key、token、password、secret，确认没有敏感信息。

5. 运行 openclaw memory index。

6. 问一个和当前工作有关的问题，看召回是否准确。

可以用命令快速找风险词：

rg -n "key|token|password|secret|AKIA|sk-" ~/.openclaw/workspace

如果命中的是示例，也要确认已经脱敏：

sk-*** 或 ${OPENAI_API_KEY}

记忆文件是给未来的 Agent 看的。写得越像“可执行上下文”，未来越省力；写得越像聊天碎片，未来越容易误导。

记忆工坊：把项目上下文交给新 Agent

很多人使用记忆系统，是为了让新会话不用从零解释项目。下面练习把一个项目上下文整理成 Agent 能长期使用的记忆。

假设你正在维护一个开源课程项目。你希望 OpenClaw 以后知道：

- 课程面向中文读者。
- 文档要有真实命令和排错路径。
- 不在正文里写内部质量检查。
- FAQ 编号按每个分类从 Q1 开始。
- OpenClaw 的功能不能照搬 Claude Code 或 Codex。

不要把这些话全部塞进一段长文本。拆成 USER.md 和 MEMORY.md。

USER.md：

# 用户偏好

## 写作偏好

- 中文教程要自然、具体、可操作。
- 汇报时先说结论，再给关键数据。
- 不喜欢机械堆叠固定模板。

## 协作偏好

- 修改文档前先读现有结构。
- 发现问题要直接修，不只给建议。

MEMORY.md：

# 项目记忆

## OpenClaw 课程原则

- 教程正文只写读者需要的课程内容。
- 不写内部交付口径、打分表和自检话术。
- 不放空图说明或未提供的图片提示。
- FAQ 分类内编号从 Q1 开始。
- 不能虚构 OpenClaw 功能，能力边界要按本项目文档确认。

## 课程结构

- 00 阅读指南：学习路径。
- 01 项目介绍：产品心智模型。
- 02 安装部署：安装、升级、迁移。
- 03 快速开始：第一条消息和日志。
- 04 模型配置：provider、fallback、成本。
- 05 消息平台：Channel、Pairing、日志。
- 06 技能系统：Skill 编写和调试。
- 07 记忆系统：USER/MEMORY/日志。
- 08 多 Agent：路由和协作。
- 09 Docker：长期部署。
- 10 安全：加固和事故响应。
- 11 FAQ：问题定位。

写完后重建索引：

openclaw memory index

测试：

我写 OpenClaw 课程时有哪些不能做的事？

理想回答应该提到课程正文只保留读者需要的内容、不放空图提示、不虚构功能、FAQ 编号规则。如果它只泛泛回答“要写得清楚”，说明记忆写得太抽象。

记忆模板：个人、项目、团队三类分开

你可以直接复用下面三种模板。

个人偏好模板

适合 USER.md：

# 用户画像

## 沟通偏好

- ...

## 写作偏好

- ...

## 技术偏好

- ...

## 不喜欢的做法

- ...

## 需要提醒我的事

- ...

不要写：

- 密码。
- token。
- 家庭住址。
- 身份证。
- 私聊原文。

项目事实模板

适合 MEMORY.md：

# 项目记忆

## 项目目标

- ...

## 技术栈

- ...

## 目录结构

- ...

## 长期决策

- ...

## 当前约束

- ...

## 不要做

- ...

这里的关键是“长期”。今天临时修一个错别字，不该进入项目长期记忆；“FAQ 编号规则”这种会持续影响写作的规则，才适合放进去。

团队协作模板

适合共享记忆或团队 Agent：

# 团队工作记忆

## 频道

- 支持频道：
- 公告频道：
- 内部讨论：

## 升级流程

- ...

## 安全边界

- ...

## 转交规则

- ...

## 常用 Runbook

- ...

团队记忆要写得更克制。不要把个人偏好、私聊、客户原文混进去。团队 Agent 只需要完成工作所需的信息。

记忆质量自查：一条记忆是否值得长期保存

每次准备写入长期记忆前，问五个问题：

1. 这条信息三个月后还有效吗？
2. 它会影响未来多次回答吗？
3. 它是否可以被另一个 Agent 看到？
4. 它是否包含敏感信息？
5. 它是否比“今天的日志”更稳定？

例子：

句子

放哪里

原因

“用户喜欢先结论后步骤”

USER.md

长期沟通偏好

“今天修了 Docker 章节”

每日日志

临时进展

“Gateway 默认端口是 18789”

MEMORY.md

长期事实

“API Key 是 sk-xxx”

不保存

敏感凭证

“下周可能换模型”

每日日志

未确定计划

“团队禁止 Bot 自动发布公告”

MEMORY.md / 团队记忆

长期安全边界

记忆写得好，Agent 像了解你的同事；记忆写得乱，Agent 像翻过一堆旧聊天记录的人。

多 Agent 记忆分工

多 Agent 场景下，不建议所有 Agent 共享同一份 MEMORY.md。每个 Agent 应该记住自己职责内的信息。

例如：

main Agent:
用户偏好、全局安全边界、当前主要项目。

support Agent:
常见安装问题、排查流程、公开文档链接。

docs Agent:
文档结构、写作规范、术语表。

ops Agent:
运行手册、部署路径、告警解释规则。

目录可以这样：

~/.openclaw/workspace/
~/.openclaw/workspace-support/
~/.openclaw/workspace-docs/
~/.openclaw/workspace-ops/

如果需要共享事实，不要复制粘贴到每个 MEMORY.md，可以写一个共享文件：

~/.openclaw/shared/project-facts.md

然后在各 Agent 的 SOUL.md 中说明只读引用：

## 共享项目事实

需要项目通用背景时，读取 `~/.openclaw/shared/project-facts.md`。
不要修改该文件；如果发现过时信息，向 main Agent 或用户提出更新建议。

这样能减少冲突。共享记忆越少，越容易维护；共享事实越清楚，越不容易互相污染。

记忆与知识库的边界

记忆和知识库都能让 AI “知道更多”，但它们用途不同。

类型

适合放

不适合放

记忆

用户偏好、项目事实、长期决策

大量文档、完整日志、外部网页

知识库

API 文档、产品手册、FAQ、长资料

私人偏好、临时计划

每日日志

当天进展、临时结论、待办

永久规则、凭证

如果你有一份 200 页的产品手册，不要塞进 MEMORY.md。它应该进知识库或 RAG。MEMORY.md 只需要记：

## 产品资料

- 产品手册位于知识库 `product-manual`。
- 回答产品功能问题时优先检索该知识库。
- 不确定时引用资料位置，不编造。

这样长期记忆保持轻，知识库负责大资料。

常见问题

Q1：AI 怎么突然不记得之前说的话了？

最常见的原因是 compaction。当对话太长，早期消息会被压缩成摘要，细节可能丢失。

解决方案：

• 重要信息主动让 AI 写入记忆文件

• 开启 memoryFlush，compaction 前自动保存

• 增大 reserveTokensFloor，保留更多上下文

Q2：记忆文件太大了怎么办？

用 openclaw memory status 查看索引状态，直接编辑 ~/.openclaw/workspace/MEMORY.md 整理内容。超过 30 天的日志可以手动归档到 memory/archive/ 目录。建议 MEMORY.md 控制在 500 行以内。

Q3：能不能让 AI 忘记某些事？

可以。直接编辑记忆文件删除对应内容，或者告诉 AI：

你：忘掉关于旧项目 X 的所有信息
AI：好的，我已从记忆中删除了关于项目 X 的 5 条记录。

Q4：多个 Agent 能共享记忆吗？

默认不共享。每个 Agent 有独立的 workspace 和记忆文件。

如果需要共享，可以用符号链接：

# 让 coding Agent 共享 main Agent 的 MEMORY.md
ln -s ~/.openclaw/workspace/MEMORY.md ~/.openclaw/workspace-coding/MEMORY.md

但要注意并发写入可能导致冲突。更安全的做法是通过独立 workspace 隔离，仅在需要时手动同步。

Q5：记忆搜索不准确怎么办？

OpenClaw 使用 sqlite-vec 支持混合搜索（关键词 + 语义），搜索质量通常不错。如果仍然不够精确：

1. 运行 openclaw memory index 确保索引是最新的

2. 开启 RAG + 知识库插件，扩大搜索范围

3. 给记忆内容加标签，提高匹配精度

Q6：换了电脑怎么迁移记忆？

记忆就是文件，直接复制或用 Git 同步：

# 打包导出
tar -czf openclaw-memory.tar.gz ~/.openclaw/workspace/

# 新电脑导入
tar -xzf openclaw-memory.tar.gz -C ~/

# 或者用 Git
cd ~/.openclaw/workspace && git init && git add . && git commit -m "backup"

Q7：记忆系统会影响响应速度吗？

影响很小。主要开销在启动时加载记忆文件（通常 < 1 秒）和 memory_search 搜索。如果觉得慢，精简 MEMORY.md 内容、归档旧日志文件，或运行 openclaw memory index 重建索引。

下一步

记忆系统搞定了，你的 AI 助手现在能记住你是谁、你在做什么、你喜欢什么。去 08. 多 Agent 路由 学习如何运行多个 AI 助手，让它们各司其职。