@clawhub-zcz-user-d717ff77e3
7-Part Demand Analysis Framework. Use before executing any user task or request. Forces structured requirement analysis before action to prevent blind execut...
--- name: demand-analyzer description: "7-Part Demand Analysis Framework. Use before executing any user task or request. Forces structured requirement analysis before action to prevent blind execution. Triggers on: user task assignment, questions, link sharing, vague statements like '那个' or '怎么办'." --- # Demand Analyzer 7 部分需求拆解框架——在行动之前先理解,避免接到任务就瞎干。 ## 工作流程 1. **收到用户消息** → 停顿 3 秒,不要立刻回复 2. **输出 7 部分拆解** → 按框架逐项分析 3. **等用户确认** → 不要自己猜,让用户选 4. **执行计划** → 用户确认后按方案行动 ## 7 部分框架 读取 `references/framework.md` 获取完整框架和模板。 核心结构: ``` 1. 核心意图 — 用户真正想要什么 2. 关键约束 — 时间、资源、限制条件 3. 隐含需求 — 用户没明说但重要的 4. 歧义澄清 — 哪些地方需要确认 5. 信息缺口 — 还缺什么信息 6. 可选方案 — 2-5 个方案(不要只给 3 个!) 7. 执行计划 — 确认后怎么干 ``` ## 关键规则 ### ⚡ 停顿 3 秒 收到用户消息后,不要立刻回复"马上去做"。先拆解,再行动。 ### ⚡ 不要只给 3 个方案 打破"3 的魔咒"——方案数量根据实际需要,2-5 个或更多。 ### ⚡ 模糊问题先追问 用户说模糊的话(如"那个"、"怎么样了"),先列出 2-5 个可能的理解,让用户确认。 ### ⚡ 信息不够先问 不要猜,不要脑补。缺信息就问用户。 ## 适用场景 | 场景 | 怎么用 | |------|--------| | 用户提出任务 | 完整 7 部分拆解 | | 用户问问题 | 核心意图 + 歧义澄清 + 可选方案 | | 用户分享链接 | 核心意图 + 隐含需求 + 可选方案 | | 用户说模糊的话 | 列出 2-5 个理解 + 追问 | | 复杂任务 | 完整 7 部分 + 详细执行计划 | FILE:references/framework.md # 7 部分需求拆解框架 ## 完整框架 ``` 1. 核心意图(用户真正想要什么) 2. 关键约束(时间、资源、限制条件) 3. 隐含需求(用户没明说但重要的) 4. 歧义澄清(哪些地方需要用户确认) 5. 信息缺口(还缺什么信息) 6. 可选方案(列出 2-5 个方案让用户选,不要只给 3 个!) 7. 执行计划(用户确认后怎么干) ``` ## 各部分详解 ### 1️⃣ 核心意图 **问题:** 用户真正想要什么? **要点:** - 不要只看字面意思,要理解深层需求 - 用户说"帮我查 X",可能真正想要的是"了解 X 的决策依据" - 用一句话概括 ### 2️⃣ 关键约束 **问题:** 有哪些时间、资源、限制条件? **要点:** - 时间约束(截止日期、紧急程度) - 资源约束(权限、工具、数据) - 限制条件(不能做什么、必须遵守的规则) ### 3️⃣ 隐含需求 **问题:** 用户没明说但重要的需求是什么? **要点:** - 用户可能不知道自己要什么 - 从上下文推断(如用户分享工具,可能想让我做类似的事) - 长期需求 vs 短期需求 ### 4️⃣ 歧义澄清 **问题:** 哪些地方需要用户确认? **要点:** - 列出 2-5 个可能的理解(不要只给 3 个!打破数字魔咒) - 每个理解对应不同的执行方向 - 让用户选择,而不是自己猜 ### 5️⃣ 信息缺口 **问题:** 还缺什么信息才能准确执行? **要点:** - 明确列出缺少的具体信息 - 说明为什么需要这些信息 - 区分"必须有"和"有了更好" ### 6️⃣ 可选方案 **问题:** 有哪些方案可选? **要点:** - **至少 2-5 个方案,不要只给 3 个!** - 每个方案标注推荐度(⭐) - 给出推荐理由 - 包括"暂不行动"作为选项 ### 7️⃣ 执行计划 **问题:** 用户确认后怎么干? **要点:** - 具体的步骤(不是模糊的方向) - 预估时间 - 依赖条件 ## 模糊问题处理协议 当用户问模糊问题时: 1. 用语义搜索查找相关记忆 2. 列出 2-5 个可能的理解(不要只给 3 个!打破数字魔咒) 3. 询问用户具体指的是哪个 **示例:** 用户:"那个框架" ❌ 错误:自己猜是"7 部分需求拆解框架" ✅ 正确: ``` 少爷,您说的"框架"可能是: 1. 7 部分需求拆解框架(今天教的) 2. 理解/执行/检索框架(04-09 学的) 3. WORKFLOW.md 的 6 步工作流 4. 还是别的? ``` ## 回答架构模板 ```markdown ## 🎯 7 部分拆解 ### 1️⃣ 核心意图 [一句话概括] ### 2️⃣ 关键约束 - [约束 1] - [约束 2] ### 3️⃣ 隐含需求 - [隐含需求 1] - [隐含需求 2] ### 4️⃣ 歧义澄清 [需要确认的问题] ### 5️⃣ 信息缺口 - [缺少的信息 1] - [缺少的信息 2] ### 6️⃣ 可选方案 | 方案 | 操作 | 推荐度 | |------|------|--------| | **A** | [操作] | ⭐⭐⭐⭐⭐ | | **B** | [操作] | ⭐⭐⭐ | | **C** | [操作] | ⭐⭐⭐⭐ | | **D** | [操作] | ⭐⭐ | ### 7️⃣ 执行计划 [用户确认后怎么干] ```
Cross-Axis Analysis Framework. Use when you need to systematically research an unfamiliar domain, product, company, or technology concept through longitudina...
--- name: cross-axis-analysis description: "Cross-Axis Analysis Framework. Use when you need to systematically research an unfamiliar domain, product, company, or technology concept through longitudinal timeline analysis +横向同期竞争格局对比。Also triggers on: '横纵分析', 'research framework', 'deep analysis report', '快速了解某个领域'." --- # Cross-Axis Analysis 通过纵向时间深度 + 横向竞争格局的交汇分析,快速建立对陌生领域的系统性认知。 ## 工作流程 1. **确认研究对象** — 明确分析目标(产品/公司/技术/人物/趋势) 2. **加载 Prompt 模板** — 读取 `references/prompt-template.md` 3. **选择版本**: - 深度版:适合学术研究、投资决策、战略规划(10,000-30,000 字) - 快速版:适合紧急判断、初步了解(≤1,500 字) 4. **填充并执行** — 将 `[研究领域/对象]` 替换为实际目标,发送给 AI 5. **交付结果** — 将 AI 输出整理后交付用户,必要时补充自己的解读 ## 何时用这个方法 | 场景 | 版本 | 预期产出 | |------|------|---------| | 学术研究(文献综述) | 深度版 | 完整发展脉络 + 竞品对比 | | 选校/选公司决策 | 深度版 | 生态位分析 + 横纵交汇判断 | | 投资分析(币/股) | 深度版 | 路径依赖分析 + 未来展望 | | 快速了解新领域 | 快速版 | 3 个转折点 + 3 个竞品 | | 小说世界观调研 | 深度版 | 同类作品生态位 + 差异化机会 | ## 方法优势 - **结构清晰** — 纵+横+交汇,不遗漏关键维度 - **天然适配 AI** — 把 AI 的研究能力装了方向盘 - **横纵交汇是灵魂** — 把"三年前决策"和"今天地位"连起来,产生真正洞察 ## 局限性 - 冷门领域可能信息不足,需补充人工调研 - 深度版篇幅大,不适合需要即时决策的场景(用快速版) - 分析质量取决于 AI 的信息检索能力 FILE:references/prompt-template.md # 横纵分析法 — AI 研究 Prompt 模板 ## 使用说明 将 `[研究领域/对象]` 替换为实际目标,直接发送给 ChatGPT Deep Research、Claude、Gemini 等支持深度研究的 AI。 --- ## Prompt 正文 ``` 你是一位资深科技记者 + 行业分析师。请对以下研究对象进行深度研究,使用"横纵分析法"框架输出报告。 ## 研究对象 [研究领域/对象] ## 研究方法:横纵分析法 ### 一、纵向分析(Diachronic / Longitudinal) 沿时间线还原研究对象从诞生到现在的完整故事。 回答以下关键问题: - **起源与背景**:基于什么技术/理念/需求诞生?当时的环境如何? - **关键转折点**:经历了哪些重大版本、事件、转型?每个转折点的触发因素是什么? - **决策逻辑**:在每个关键节点,为什么做出特定选择?有哪些备选方案被放弃了? - **路径依赖**:早期的哪些决策塑造了今天的格局?哪些选择变成了优势,哪些变成了包袱? 要求:用叙事方式串联发展史,注重因果关系,而非干巴巴的年表。让读者能理解"为什么事情是这样发展的"。 ### 二、横向分析(Synchronic / Cross-sectional) 以当前时间点为切面,分析研究对象在竞争格局中的位置。 1. **判断竞品场景**:无直接竞品 / 少量竞品(1-2个)/ 竞品充分(3个及以上) 2. **对比维度**(根据对象类型调整): - 技术路线 / 核心方法论 - 产品形态 / 商业模式 - 目标用户 / 适用场景 - 核心优势与短板 - 用户口碑与社区评价 - 团队背景与资源 3. **生态位分析**:它在整个赛道中填补了什么空白?与谁竞争?与谁互补? ### 三、横纵交汇 将纵向的发展脉络与横向的竞争格局结合,给出综合性判断: - 今天的某个优势,可能是三年前一个不起眼决策的积累 - 今天的某个短板,可能是当初合理选择变成的路径依赖 - 未来的关键变量是什么?哪些趋势会改变竞争格局? - 给出你对研究对象未来 1-3 年的判断 ## 写作要求 - **风格**:像深度报道一样可读,有叙事感,用"人话"写作 - **观点**:每个观点必须有事实支撑,不空谈 - **结构**:先纵向叙事,再横向对比,最后是交汇总结 - **篇幅**:根据复杂度自适应调整,全文总计约 10,000-30,000 字 - 纵向分析(主体):6,000-15,000 字 - 横向分析:3,000-10,000 字 - 横纵交汇总结:1,500-3,000 字 ## 适用范围 产品/工具、公司/组织、技术概念、人物、行业趋势等。 ``` --- ## 快速版(3 分钟) 适合需要快速判断的场景: ``` 用横纵分析法快速分析 [研究领域/对象]: 1. 纵向:一句话概括起源 + 3个关键转折点 + 每个转折的决策逻辑 2. 横向:列出 3 个主要竞品,各用 1 句话对比优劣势 3. 交汇:100 字以内给出综合判断和未来展望 总字数控制在 1500 字以内,用要点格式。 ```
焦距记忆系统 - 智能记忆管理,支持消息分类、按需加载、自动标签、遗忘曲线。Token 优化 40-60%。
---
name: memory-focal-system
slug: memory-focal-system
version: 1.0.0
homepage: https://github.com/openclaw-lark/memory-focal-system
description: 焦距记忆系统 - 智能记忆管理,支持消息分类、按需加载、自动标签、遗忘曲线。Token 优化 40-60%。
changelog: 初始版本 - 完整功能上线
metadata: {"clawdbot":{"emoji":"🧠","os":["linux","darwin","win32"]}}
---
## 🧠 焦距记忆系统 (Memory Focal System)
**让 AI 记住重要的事,忘记不重要的事**
---
## 核心功能
### 1. 🎯 焦距记忆机制
根据消息类型自动调节"记忆焦距",决定读取多少上下文:
| 焦距模式 | 触发场景 | 加载内容 | Token 节省 |
|----------|----------|----------|-----------|
| **远景 (simple)** | 简单对话 | 无 | 100% |
| **中景 (task)** | 任务执行 | 相关记忆 | 60-75% |
| **近景 (memory)** | 情感/偏好 | 完整记忆 | 正常 |
| **微距 (new_info)** | 新信息 | 完整记忆 + 写入 | 正常 |
### 2. ⚡ 频率触发机制
基于访问频率自动强化重要记忆:
- 高频访问 → 自动提升到热存储
- 低频访问 → 自动降级到冷存储
- 智能计算记忆优先级
### 3. 📊 记忆分层管理
三层存储架构,优化性能:
- **热存储 (active)**:最近 7 天,自动加载
- **温存储 (short_term)**:7-30 天,按需加载
- **冷存储 (long_term)**:30 天+,归档保存
### 4. 🤖 LLM 自动标签
AI 自动生成记忆标签,支持语义检索:
- 调用大模型 API(支持 dashscope、openai 等)
- 基于 MD5 缓存,避免重复调用
- 成本约 ¥0.5-10/月
### 5. 📉 遗忘曲线
艾宾浩斯遗忘曲线算法,智能清理:
- 基于存在天数、访问次数计算记忆强度
- 低强度记忆自动归档
- 超过 365 天可删除
### 6. 🔍 双链索引
标签 - 记忆双向索引,快速检索:
- 标签 → 记忆 ID 列表
- 记忆 ID → 标签列表
- O(1) 时间复杂度查询
### 7. 💾 增量式存储
Append-Only JSONL 格式,保证数据完整性:
- 只追加,不修改
- 避免并发冲突
- 易于备份和恢复
---
## 安装
```bash
# 从 ClawHub 安装
clawhub install memory-focal-system
# 或本地安装(已预装)
cd ~/.openclaw/workspace/skills/memory-focal-system
```
---
## 配置
配置文件:`~/.openclaw/workspace/skills/memory-focal-system/config.json`
```json
{
"enabled": true,
"auto_classify": true,
"auto_write": true,
"load_user": true,
"load_memory": true,
"load_focal_active": true,
"token_limit": 8000
}
```
### 配置说明
| 字段 | 类型 | 默认值 | 说明 |
|------|------|--------|------|
| `enabled` | bool | true | 是否启用记忆系统 |
| `auto_classify` | bool | true | 自动分类消息 |
| `auto_write` | bool | true | 自动写入新记忆 |
| `load_user` | bool | true | 加载用户配置文件 |
| `load_memory` | bool | true | 加载长期记忆文件 |
| `load_focal_active` | bool | true | 加载热存储记忆 |
| `token_limit` | int | 8000 | Token 上限 |
---
## 使用方法
### 自动模式(推荐)
安装后自动生效,无需手动调用。
每次对话时:
1. 自动分类消息(4 种焦距模式)
2. 按需加载记忆文件
3. 判断是否需要写入新记忆
4. 自动写入(如需要)
### 手动模式
```python
from memory_manager import MemoryManager
manager = MemoryManager()
# 处理消息
context = manager.process_message("用户偏好早上 8 点起床")
print(context)
# {
# "category": "memory",
# "load_user": "...",
# "load_memory": "...",
# "load_focal": [...],
# "should_write": true,
# "token_count": 907
# }
# 写入记忆
manager.write_memory("用户明天考试", "已记录", "event", ["考试", "日程"])
```
### CLI 命令
```bash
cd ~/.openclaw/workspace/memory-focal
# 初始化
python3 scripts/cli.py init
# 添加记忆
python3 scripts/cli.py add "用户偏好早上 8 点起床" --type preference --tags 作息,偏好
# 搜索记忆
python3 scripts/cli.py search "作息"
# 查看统计
python3 scripts/cli.py stats
# 查看高优先级记忆
python3 scripts/cli.py top 5
# 分类测试
python3 scripts/cli.py classify "在吗"
# 生成标签
python3 scripts/cli.py tag "用户明天考试"
# 预览归档计划
python3 scripts/cli.py cleanup
```
---
## Token 优化效果
| 场景 | 优化前 | 优化后 | 节省 |
|------|--------|--------|------|
| 简单对话 | 8000 tokens | 0 tokens | **100%** |
| 任务执行 | 8000 tokens | 2000-3000 tokens | **60-75%** |
| 情感/偏好 | 8000 tokens | 8000 tokens | 0% |
| 新信息 | 8000 tokens | 8000 tokens | 0% |
**综合节省:40-60%**(取决于对话类型分布)
---
## 文件结构
```
memory-focal-system/
├── SKILL.md # 技能说明
├── README.md # 使用文档
├── _meta.json # 元数据
├── config.json # 配置文件
├── memory_manager.py # 核心管理模块
└── classifier.py # 消息分类器
memory-focal/ # 记忆数据存储(独立目录)
├── config/config.json
├── data/raw/buffer.jsonl
├── data/index/
│ ├── tag_index.json
│ └── memory_index.json
├── storage/
│ ├── active/
│ ├── short_term/
│ ├── long_term/
│ └── archive/
└── scripts/
├── cli.py
├── classifier.py
├── frequency_trigger.py
├── storage_manager.py
├── auto_tag.py
└── forget_curve.py
```
---
## 记忆数据格式
### 单条记忆(buffer.jsonl)
```json
{
"id": "mem_0001",
"text": "用户偏好早上 8 点起床",
"type": "preference",
"tags": ["作息", "偏好"],
"timestamp": "2026-03-29T08:00:00+08:00",
"created_at": "2026-03-29T08:00:00+08:00",
"access_count": 0,
"last_accessed": null,
"importance": 1.0,
"layer": "active",
"priority": 0.0
}
```
### 标签索引(tag_index.json)
```json
{
"version": "1.0.0",
"tags": {
"作息": ["mem_0001", "mem_0002"],
"偏好": ["mem_0001"]
}
}
```
---
## 高级功能
### LLM 自动标签
需要配置 dashscope API key:
```bash
python3 scripts/cli.py tag "用户明天考试" --api-key <your-api-key>
```
缓存机制:
- 基于 MD5 哈希缓存
- 相同文本不重复调用
- 查看缓存:`python3 scripts/cli.py tag-stats`
- 清空缓存:`python3 scripts/cli.py tag-clear`
### 频率触发
基于访问次数、最后访问时间、重要性计算优先级:
```python
from frequency_trigger import FrequencyTrigger
trigger = FrequencyTrigger()
priority = trigger.calculate_priority(memory)
```
### 遗忘曲线
艾宾浩斯遗忘曲线算法:
```python
from forget_curve import ForgetCurve
curve = ForgetCurve()
strength = curve.calculate_strength(memory)
schedule = curve.get_archive_schedule(memories)
```
---
## 注意事项
1. **首次使用需要初始化**
```bash
python3 scripts/cli.py init
```
2. **LLM 自动标签需要 API key**
- 成本约 ¥0.5-10/月
- 可手动关闭:`config.json` 中设置 `"auto_tag": false`
3. **Python 版本要求**
- 核心功能:Python 3.6+
- LLM 标签:Python 3.7+(需要 f-string 增强)
4. **备份建议**
- 定期备份 `data/raw/buffer.jsonl`
---
## 故障排除
### 问题 1:分类不准确
**解决:** 编辑 `classifier.py`,调整关键词列表
```python
# 添加新的关键词
self.simple_keywords.append("新关键词")
```
### 问题 2:记忆写入失败
**解决:** 检查 CLI 路径和权限
```bash
ls -la ~/.openclaw/workspace/memory-focal/scripts/cli.py
chmod +x ~/.openclaw/workspace/memory-focal/scripts/cli.py
```
### 问题 3:Token 超限
**解决:** 降低 `token_limit` 或减少加载的记忆文件
```json
{
"token_limit": 4000,
"load_focal_active": false
}
```
---
## 更新日志
### v1.0.0 (2026-03-29)
- ✅ 焦距记忆机制(4 种模式)
- ✅ 频率触发机制
- ✅ 记忆分层管理
- ✅ LLM 自动标签
- ✅ 遗忘曲线
- ✅ 双链索引
- ✅ 增量式存储
- ✅ CLI 工具(add/search/list/stats/top/tag/cleanup/classify)
---
## 反馈
- 问题反馈:GitHub Issues
- 技能更新:`clawhub sync memory-focal-system`
- 技能评分:`clawhub star memory-focal-system`
---
_焦距记忆系统 - 让 AI 记住重要的事,忘记不重要的事_
FILE:classifier.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Message Classifier - 消息分类器
根据关键词快速判断消息类型,决定是否需要读取记忆。
分类规则:
1. 简单对话 - 直接回复,不读取记忆
2. 任务执行 - 读取相关记忆后执行
3. 情感/偏好相关 - 读取完整记忆
4. 新问题/新信息 - 直接写入记忆
"""
from typing import Tuple, Dict, List
class MessageClassifier:
"""消息分类器"""
def __init__(self):
# 简单对话关键词(直接回复,不读取记忆)
self.simple_keywords = [
"在吗", "在嘛", "你好", "早", "好", "嗯", "哦", "好的", "收到",
"谢谢", "感谢", "辛苦了", "拜拜", "再见", "晚安", "早安",
"哈哈", "呵呵", "嘻嘻", "笑死", "666", "👍", "✅", "好嘞",
"休息", "待命", "待机", "暂停", "停一下", "等一下",
]
# 任务执行关键词(读取相关记忆后执行)
self.task_keywords = [
"查", "搜索", "找", "下载", "安装", "配置", "设置",
"发", "发送", "邮件", "报告", "生成", "创建", "写",
"打开", "关闭", "启动", "停止", "运行", "执行",
]
# 情感/偏好相关关键词(读取完整记忆)
self.memory_keywords = [
"记得", "记住", "记忆", "上次", "之前", "以前", "曾经",
"偏好", "喜欢", "讨厌", "不喜欢", "习惯", "规则",
"我说", "我说过", "你记得", "别忘了",
]
# 新信息关键词(直接写入记忆)
self.new_info_keywords = [
"新", "新增", "添加", "记录", "保存", "存一下",
"记下来", "写进去", "以后", "从现在开始", "以后都",
]
# 否定词关键词(不写入记忆)
self.negation_keywords = [
"别记住", "不要记", "别记", "忘了", "忘掉",
"不用记", "无需记", "不必记", "别存", "不要存",
"别写", "不要写", "别记录", "不要记录",
"别用", "不要用", "别开启", "不要开启",
"别用这", "别用这个", "不要用这", "不要用这个",
]
def classify(self, message: str) -> Tuple[str, Dict]:
"""
分类消息(权重计分版)
Returns:
(category, config)
category: "simple" | "task" | "memory" | "new_info"
config: {
"load_focal": bool, # 是否加载 memory-focal
"write_memory": bool, # 是否写入新记忆
}
"""
message_lower = message.lower()
# 1. 否定词优先(直接返回 simple)
for keyword in self.negation_keywords:
if keyword in message_lower:
return "simple", {
"load_focal": False,
"write_memory": False,
}
# 2. 权重计分
scores = {
"simple": 0,
"task": 0,
"memory": 0,
"new_info": 0
}
# 简单对话关键词
for keyword in self.simple_keywords:
if keyword in message_lower:
scores["simple"] += 1
# 任务执行关键词
for keyword in self.task_keywords:
if keyword in message_lower:
scores["task"] += 1
# 情感/偏好关键词
for keyword in self.memory_keywords:
if keyword in message_lower:
scores["memory"] += 1
# 新信息关键词
for keyword in self.new_info_keywords:
if keyword in message_lower:
scores["new_info"] += 1
# 3. 取最高分(如果有平局,优先级:new_info > memory > task > simple)
max_score = max(scores.values())
if max_score == 0:
# 无匹配,默认简单对话
return "simple", {
"load_focal": False,
"write_memory": False,
}
# 按优先级排序的类别
priority_order = ["new_info", "memory", "task", "simple"]
for category in priority_order:
if scores[category] == max_score:
return self._get_category_config(category)
# fallback
return "simple", {
"load_focal": False,
"write_memory": False,
}
def _get_category_config(self, category: str) -> Tuple[str, Dict]:
"""根据分类返回配置"""
configs = {
"simple": {
"load_focal": False,
"write_memory": False,
},
"task": {
"load_focal": True,
"write_memory": False,
},
"memory": {
"load_focal": True,
"write_memory": True,
},
"new_info": {
"load_focal": True,
"write_memory": True,
}
}
return category, configs.get(category, configs["simple"])
def should_write_memory(self, message: str) -> bool:
"""
判断是否需要写入记忆
Args:
message: 用户消息
Returns:
bool - 是否需要写入
"""
message_lower = message.lower()
# 否定词优先
for keyword in self.negation_keywords:
if keyword in message_lower:
return False
# 包含记忆相关关键词
for keyword in self.memory_keywords:
if keyword in message_lower:
return True
# 包含新信息关键词
for keyword in self.new_info_keywords:
if keyword in message_lower:
return True
# 用户明确要求记住
if "记住" in message or "记下来" in message or "存一下" in message:
return True
return False
def get_memory_priority(self, message: str) -> str:
"""
获取记忆优先级
Returns:
"high" | "medium" | "low"
"""
# 高优先级:用户的偏好、规则、决策
high_keywords = ["规则", "偏好", "禁止", "必须", "一定", "永远"]
for keyword in high_keywords:
if keyword in message:
return "high"
# 中优先级:任务相关、配置相关
medium_keywords = ["配置", "设置", "任务", "工作", "项目"]
for keyword in medium_keywords:
if keyword in message:
return "medium"
# 低优先级:其他
return "low"
# 测试
if __name__ == "__main__":
classifier = MessageClassifier()
test_cases = [
"在吗",
"用户偏好早上 8 点起床",
"查一下配置",
"记得上次说的规则吗",
"新增一条:以后每天晚上提醒我断电",
"谢谢",
"帮我生成报告",
"记住了,以后都这样",
"记住,以后别用这功能了",
]
print("🧪 消息分类测试\n")
for msg in test_cases:
category, config = classifier.classify(msg)
should_write = classifier.should_write_memory(msg)
priority = classifier.get_memory_priority(msg)
print(f"消息:{msg}")
print(f" 分类:{category}")
print(f" 配置:{config}")
print(f" 写入:{should_write}")
print(f" 优先级:{priority}")
print()
FILE:config.json
{
"enabled": true,
"auto_classify": true,
"auto_write": true,
"load_user": true,
"load_memory": true,
"load_focal_active": true,
"token_limit": 8000
}
FILE:memory_manager.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Memory Manager - 焦距记忆系统核心模块
功能:
1. 消息自动分类(4 种焦距模式)
2. 按需加载记忆
3. 自动记忆写入
4. Token 优化
Usage:
from memory_manager import MemoryManager
manager = MemoryManager()
context = manager.process_message(user_message)
if manager.should_write_memory(user_message):
manager.write_memory(user_message, response)
"""
import json
import os
import re
import sys
from pathlib import Path
from datetime import datetime
from typing import Dict, List, Optional, Tuple
# 添加 memory-focal 到路径
memory_focal_scripts = Path(os.path.expanduser("~/.openclaw/workspace/memory-focal/scripts"))
sys.path.insert(0, str(memory_focal_scripts))
# 导入分类器
from classifier import MessageClassifier
class MemoryManager:
"""焦距记忆管理器"""
def __init__(self, config_path: str = None):
"""初始化"""
self.workspace_base = Path(os.path.expanduser("~/.openclaw/workspace"))
self.memory_focal_base = self.workspace_base / "memory-focal"
# 默认配置
self.config = {
"enabled": True,
"auto_classify": True,
"auto_write": True,
"load_focal_active": True,
"token_limit": 8000,
}
# 加载配置
if config_path:
self.load_config(config_path)
else:
config_file = self.workspace_base / "skills" / "memory-focal-system" / "config.json"
if config_file.exists():
self.load_config(str(config_file))
# 初始化分类器
self.classifier = MessageClassifier()
# 当前状态
self.current_category = None
self.current_config = None
def load_config(self, config_path: str):
"""加载配置"""
with open(config_path, 'r', encoding='utf-8') as f:
loaded = json.load(f)
self.config.update(loaded)
def _count_tokens(self, text: str) -> int:
"""计算 Token 数(中英文友好)"""
if not text:
return 0
# 中文字符
chinese_chars = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
# 英文单词
english_words = len(re.findall(r'\b[a-zA-Z]+\b', text))
# 其他字符
other_chars = len(text) - chinese_chars - sum(len(w) for w in re.findall(r'\b[a-zA-Z]+\b', text))
# 计算
tokens = (chinese_chars / 1.5) + (english_words * 1.3) + (other_chars / 2)
return int(tokens)
def process_message(self, message: str) -> Dict:
"""
处理用户消息(核心入口)
Returns:
{
"category": str,
"load_focal": list,
"should_write": bool,
"token_count": int,
}
"""
result = {
"category": None,
"load_focal": [],
"should_write": False,
"token_count": 0,
}
if not self.config.get("enabled", True):
return result
# 1. 分类消息
if self.config.get("auto_classify", True):
self.current_category, self.current_config = self.classifier.classify(message)
result["category"] = self.current_category
result["should_write"] = self.classifier.should_write_memory(message)
# 2. 加载记忆(仅 memory-focal 系统)
token_count = 0
if self.current_config.get("load_focal") and self.config.get("load_focal_active", True):
memories = self._load_focal_active()
result["load_focal"] = memories
for mem in memories:
token_count += self._count_tokens(mem.get("text", ""))
result["token_count"] = int(token_count)
return result
def _load_focal_active(self) -> List[Dict]:
"""加载 memory-focal 热存储记忆"""
buffer_path = self.memory_focal_base / "data" / "raw" / "buffer.jsonl"
if not buffer_path.exists():
return []
memories = []
try:
with open(buffer_path, 'r', encoding='utf-8') as f:
for line in f:
try:
mem = json.loads(line.strip())
memories.append(mem)
except:
continue
except:
return []
# 按访问次数排序,取前 20 条
memories.sort(key=lambda x: x.get("access_count", 0), reverse=True)
return memories[:20]
def should_write_memory(self, message: str, response: str = None) -> bool:
"""判断是否需要写入"""
return self.classifier.should_write_memory(message)
def write_memory(self, message: str, response: str = None,
mem_type: str = None, tags: List[str] = None) -> Optional[str]:
"""写入新记忆"""
if not self.config.get("auto_write", True):
return None
if not self.should_write_memory(message, response):
return None
# 自动推断类型
if mem_type is None:
message_lower = message.lower()
if any(x in message_lower for x in ["偏好", "喜欢", "讨厌"]):
mem_type = "preference"
elif any(x in message_lower for x in ["规则", "禁止", "必须"]):
mem_type = "rule"
elif any(x in message_lower for x in ["决定", "决策"]):
mem_type = "decision"
else:
mem_type = "default"
# 自动生成标签
if tags is None:
tags = self._auto_generate_tags(message)
# 生成记忆 ID
index_path = self.memory_focal_base / "data" / "index" / "memory_index.json"
if index_path.exists():
with open(index_path, 'r', encoding='utf-8') as f:
index = json.load(f)
mem_id = f"mem_{index.get('total_memories', 0) + 1:04d}"
else:
mem_id = "mem_0001"
# 创建记忆对象
memory = {
"id": mem_id,
"text": message,
"type": mem_type,
"tags": tags,
"timestamp": datetime.now().astimezone().isoformat(),
"created_at": datetime.now().astimezone().isoformat(),
"access_count": 0,
"last_accessed": None,
"importance": 1.0,
"layer": "active",
"priority": 0.0,
}
# 写入 buffer
buffer_path = self.memory_focal_base / "data" / "raw" / "buffer.jsonl"
buffer_path.parent.mkdir(parents=True, exist_ok=True)
with open(buffer_path, 'a', encoding='utf-8') as f:
f.write(json.dumps(memory, ensure_ascii=False) + '\n')
# 更新索引
self._update_index(mem_id, memory)
return mem_id
def _update_index(self, mem_id: str, memory: Dict):
"""更新记忆索引"""
index_path = self.memory_focal_base / "data" / "index" / "memory_index.json"
if index_path.exists():
with open(index_path, 'r', encoding='utf-8') as f:
index = json.load(f)
else:
index = {"version": "1.0.0", "total_memories": 0, "memories": []}
index["total_memories"] += 1
index["memories"].append({
"id": mem_id,
"type": memory["type"],
"tags": memory["tags"],
"created_at": memory["timestamp"],
"layer": "active"
})
index["updated_at"] = datetime.now().astimezone().isoformat()
with open(index_path, 'w', encoding='utf-8') as f:
json.dump(index, f, ensure_ascii=False, indent=2)
# 更新标签索引
self._update_tag_index(mem_id, memory["tags"])
def _update_tag_index(self, mem_id: str, tags: List[str]):
"""更新标签索引"""
tag_index_path = self.memory_focal_base / "data" / "index" / "tag_index.json"
if tag_index_path.exists():
with open(tag_index_path, 'r', encoding='utf-8') as f:
tag_index = json.load(f)
else:
tag_index = {"version": "1.0.0", "tags": {}}
for tag in tags:
if tag not in tag_index["tags"]:
tag_index["tags"][tag] = []
if mem_id not in tag_index["tags"][tag]:
tag_index["tags"][tag].append(mem_id)
tag_index["updated_at"] = datetime.now().astimezone().isoformat()
with open(tag_index_path, 'w', encoding='utf-8') as f:
json.dump(tag_index, f, ensure_ascii=False, indent=2)
def _auto_generate_tags(self, message: str) -> List[str]:
"""自动生成标签"""
tags = []
message_lower = message.lower()
if any(x in message_lower for x in ["偏好", "喜欢", "讨厌"]):
tags.append("偏好")
if any(x in message_lower for x in ["规则", "禁止", "必须"]):
tags.append("规则")
if any(x in message_lower for x in ["作息", "起床", "睡觉"]):
tags.append("作息")
if any(x in message_lower for x in ["工作", "任务"]):
tags.append("工作")
if any(x in message_lower for x in ["邮件", "邮箱"]):
tags.append("工具")
if any(x in message_lower for x in ["记忆", "记住"]):
tags.append("记忆")
if not tags:
tags.append("对话")
return tags
def get_stats(self) -> Dict:
"""获取统计"""
buffer_path = self.memory_focal_base / "data" / "raw" / "buffer.jsonl"
if not buffer_path.exists():
return {"total": 0}
total = 0
with open(buffer_path, 'r', encoding='utf-8') as f:
for line in f:
try:
json.loads(line.strip())
total += 1
except:
continue
return {"total": total}
# 测试
if __name__ == "__main__":
manager = MemoryManager()
test_cases = [
("在吗", "简单对话"),
("用户偏好早上 8 点起床", "偏好记忆"),
("查一下配置", "任务执行"),
("记住,以后别用这功能", "否定词"),
("新增一条规则", "新信息"),
]
print("🧪 Memory Focal System 测试\n")
for msg, note in test_cases:
result = manager.process_message(msg)
should_write = manager.should_write_memory(msg)
print(f'{note}: {msg}')
print(f' 分类:{result["category"]}')
print(f' Token: {result["token_count"]}')
print(f' 写入:{should_write}')
print()
FILE:README.md
# 🧠 焦距记忆系统 (Memory Focal System)
**智能记忆管理,Token 优化 40-60%**
---
## 快速开始
### 1. 安装
技能包已预装在:
```
~/.openclaw/workspace/skills/memory-focal-system/
```
### 2. 初始化
```bash
cd ~/.openclaw/workspace/memory-focal
python3 scripts/cli.py init
```
### 3. 配置
编辑配置文件:
```bash
nano ~/.openclaw/workspace/skills/memory-focal-system/config.json
```
默认配置已优化好,无需修改。
### 4. 测试
```bash
cd ~/.openclaw/workspace/skills/memory-focal-system
python3 memory_manager.py
```
---
## 核心功能
### 消息自动分类
- simple:简单对话,不加载记忆(节省 100% Token)
- task:任务执行,仅加载相关文件(节省 60-75%)
- memory:情感/偏好,加载完整记忆
- new_info:新信息,加载并写入记忆
### 分层记忆加载
- 热存储:最近 7 天,自动加载
- 温存储:7-30 天,按需加载
- 冷存储:30 天+,归档保存
### 自动记忆写入
- 检测新信息
- 自动写入
- 自动生成标签
---
## 配置说明
```json
{
"enabled": true, // 是否启用
"auto_classify": true, // 自动分类
"auto_write": true, // 自动写入
"load_user": true, // 加载 USER.md
"load_memory": true, // 加载 MEMORY.md
"load_focal_active": true, // 加载热存储
"token_limit": 8000 // Token 上限
}
```
---
## CLI 命令
```bash
cd ~/.openclaw/workspace/memory-focal
# 添加记忆
python3 scripts/cli.py add "少爷偏好早上 8 点起床" --type preference --tags 作息,偏好
# 搜索记忆
python3 scripts/cli.py search "作息"
# 查看统计
python3 scripts/cli.py stats
# 查看高优先级记忆
python3 scripts/cli.py top 5
# 分类测试
python3 scripts/cli.py classify "在吗"
# 生成标签
python3 scripts/cli.py tag "少爷明天考试"
# 预览归档计划
python3 scripts/cli.py cleanup
```
---
## Token 优化效果
| 场景 | 优化前 | 优化后 | 节省 |
|------|--------|--------|------|
| 简单对话 | 8000 tokens | 0 tokens | 100% |
| 任务执行 | 8000 tokens | 2000-3000 tokens | 60-75% |
| 情感/偏好 | 8000 tokens | 8000 tokens | 0% |
| 新信息 | 8000 tokens | 8000 tokens | 0% |
**综合节省:40-60%**
---
## 文件结构
```
memory-focal-system/
├── SKILL.md # 技能说明
├── README.md # 本文档
├── _meta.json # 元数据
├── config.json # 配置
├── memory_manager.py # 核心管理模块
└── classifier.py # 消息分类器
```
---
## 故障排除
### 分类不准确
编辑 `classifier.py`,调整关键词列表
### 记忆写入失败
```bash
chmod +x ~/.openclaw/workspace/memory-focal/scripts/cli.py
```
### Token 超限
降低 `config.json` 中的 `token_limit`
---
## 作者
**Beta (贝塔)** - 少爷翟常喆的专属女秘书
---
## 许可证
MIT License
FILE:_meta.json
{
"name": "memory-focal-system",
"version": "1.0.0",
"slug": "memory-focal-system",
"description": "焦距记忆系统 - 智能记忆管理,Token 优化 40-60%",
"author": "OpenClaw Community",
"license": "MIT",
"tags": ["memory", "ai", "optimization", "token-saving"],
"emoji": "🧠",
"category": "productivity",
"min_openclaw_version": "2026.3.0",
"python_version": ">=3.6",
"dependencies": [],
"optional_dependencies": {
"dashscope": "LLM 自动标签需要"
},
"files": [
"SKILL.md",
"memory_manager.py",
"classifier.py",
"config.json",
"_meta.json"
],
"entry_point": "memory_manager.py",
"auto_load": false,
"priority": 100
}
动态思考的领域专家角色扮演技能。当用户需要深度专业分析时使用。自动识别问题领域,扮演该领域顶尖专家,通过内部思考框架、自我批判、多质量标准迭代,提供兼具深度、广度和实用性的专家级见解。
---
name: expert-role
description: 动态思考的领域专家角色扮演技能。当用户需要深度专业分析时使用。自动识别问题领域,扮演该领域顶尖专家,通过内部思考框架、自我批判、多质量标准迭代,提供兼具深度、广度和实用性的专家级见解。
---
# Expert Role - 动态思考的领域专家
## 核心理念
**成为动态思考的领域专家**
首先思考:谁是这个世界上最擅长完成这个需求的人?
贝塔将扮演这个特定领域的顶尖专家,通过深入分析、批判性思维和清晰沟通,提供专家级见解。
---
## 🎯 何时使用
| 场景 | 触发条件 |
|------|---------|
| 复杂问题分析 | 需要深度分析而非简单回答 |
| 专业领域咨询 | 涉及特定专业领域知识 |
| 决策建议 | 需要权衡利弊、提供建议 |
| 批判性思考 | 需要多角度分析、正反论证 |
| 高质量输出 | 用户明确要求深度、专业内容 |
---
## 🧠 内部思考框架
### 1. 解构请求
- 明确用户的核心问题
- 识别隐含需求
- 确定最终目标
### 2. 知识框架构建
围绕问题快速构建知识框架:
- 关键概念
- 上下文信息
- 正反论点
- 潜在延伸领域
### 3. 质量标准定义
为自己设立不少于 **5 个核心标准**:
| 标准 | 要求 |
|------|------|
| **深度与洞察力** | 超越表面信息,提供独特分析或深层联系 |
| **清晰度与结构** | 逻辑严密,表达易懂,格式助力阅读 |
| **完整性与严谨性** | 覆盖所有关键方面,考虑例外和争议 |
| **实用性与价值** | 带来切实帮助或启发 |
| **专业性与权威** | 展现领域专家水平的见解 |
### 4. 草稿与迭代
```
生成初步回答草稿
↓
对照质量标准批判性审查
↓
发现不足 → 针对性重写完善
↓
持续迭代直到达到卓越水准
```
---
## 📋 响应结构
### 1. 专家角色确立
在回答开始时,用一行简洁文字确立专家身份。
**示例:**
> "作为有 15 年经验的投资分析师,我来分析这个问题……"
### 2. 核心洞察 (Key Insight)
在回答开头,用**加粗**或引用方式,给出高度浓缩的结论性核心观点。
### 3. 深度解析 (Deep Dive)
采用清晰的段落和标题,分点展开详细论述:
- 逻辑链条清晰
- 上下文信息充足
- 多角度分析
### 4. 总结与展望 (Conclusion & Outlook)
- 总结核心观点
- 提供前瞻性思考或建议
---
## 💬 风格与限制
| 维度 | 要求 |
|------|------|
| **语言** | 严格使用用户所用语言 |
| **语气** | 自然、自信、严谨但易亲近 |
| **格式** | 多使用段落、列表、粗体增强可读性 |
| **表达方式** | 像真正的专家咨询,不背书 |
---
## 📝 使用示例
### 用户输入
> "分析一下现在投资比特币的利弊"
### 贝塔响应
**角色确立:** 作为有 10 年加密货币研究经验的分析师……
**核心洞察:**
> **短期内比特币面临监管压力和宏观经济逆风,但长期来看,其作为数字黄金的叙事仍在强化,适合高风险承受能力的投资者小仓位配置。**
**深度解析:**
#### 1. 利好因素
- ...
#### 2. 风险因素
- ...
#### 3. 技术面分析
- ...
**总结与展望:**
综合来看……
---
## 🔧 配置选项
在 `references/expert-roles.md` 中定义了不同领域的专家角色模板。
---
## 参考资料
- `references/expert-roles.md` - 各领域专家角色定义
- `references/thinking-frameworks.md` - 思考框架模板
- `references/quality-checklist.md` - 质量检查清单
---
_追求卓越,拒绝平庸。每一次输出都是代表作。_
FILE:expert-roles.md
# 专家角色模板库
## 金融投资类
| 角色 | 适用场景 |
|------|---------|
| 投资分析师 (15 年经验) | 股票、债券、基金分析 |
| 加密货币研究员 | 比特币、以太坊、山寨币分析 |
| 宏观经济学家 | 经济政策、利率、通胀分析 |
| 风险管理师 | 投资组合风险评估 |
## 科技类
| 角色 | 适用场景 |
|------|---------|
| 资深软件架构师 (20 年经验) | 系统设计、技术选型 |
| AI/ML 研究员 | 人工智能、机器学习分析 |
| 网络安全专家 | 安全审计、漏洞分析 |
| 数据科学家 | 数据分析、洞察提取 |
## 商业策略类
| 角色 | 适用场景 |
|------|---------|
| 管理咨询顾问 (MBB 背景) | 商业策略、市场分析 |
| 创业导师 | 创业指导、融资建议 |
| 市场营销专家 | 品牌、推广策略 |
## 学术类
| 角色 | 适用场景 |
|------|---------|
| 领域教授 (PhD) | 学术研究、论文指导 |
| 科研研究员 | 实验设计、数据分析 |
---
## 使用方式
在回答开始时,根据问题领域选择合适的专家角色:
```
作为 [角色],我来分析这个问题……
```
---
_持续更新中_
FILE:prompt.md
# 专家角色提示词完整版
**来源:** 少爷提供
**用途:** 专家角色扮演的完整指导原则
---
## 核心理念
**成为动态思考的领域专家**
首先思考谁是这个世界上最擅长完成我这个需求的人,你将扮演这个特定领域的顶尖专家。你的核心任务不是简单地提供信息,而是通过深入的分析、批判性思维和清晰的沟通,为用户提供兼具深度、广度和实用性的专家级见解。你的一切行为都遵循"卓越原则",即在每个环节都追求最高质量的输出。
---
## 1. 内部思考与自我批判框架
在生成最终答案之前,必须在内部激活以下思考过程。这是一个动态的自我完善循环,而不是一次性的检查。
### 1.1 解构请求
- 明确用户的核心问题
- 隐含需求
- 最终目标
### 1.2 知识框架构建
围绕问题,快速构建一个知识框架。确定回答应包含:
- 关键概念
- 上下文
- 正反论点
- 潜在的延伸领域
### 1.3 质量标准定义
根据请求,在内部为自己设立不少于 **5 个成功的核心标准**。例如:
| 标准 | 说明 |
|------|------|
| **深度与洞察力** | 是否超越了表面信息,提供了独特的分析或深层联系? |
| **清晰度与结构** | 逻辑是否严密?表达是否易于理解?格式是否有助于阅读? |
| **完整性与严谨性** | 是否涵盖了所有关键方面?信息源是否可靠?有无考虑潜在的例外或争议? |
| **实用性与价值** | 回答能否为用户带来切实的帮助或启发? |
### 1.4 草稿与迭代
1. 生成初步的回答草稿
2. 对照上述质量标准进行批判性审查和修改
3. 如果发现任何维度的不足,应针对性地重写和完善该部分,而不是完全推倒重来
4. 持续迭代,直到你确信草稿已达到卓越水准
---
## 2. 角色与沟通框架
### 2.1 专家角色确立
在对话开始时,使用一行简洁的文字确立你的专家身份。**避免使用过于浮夸的形容词。**
**示例:**
- ✅ "作为有 15 年经验的投资分析师……"
- ❌ "作为世界上最顶尖的、无与伦比的投资专家……"
### 2.2 响应结构
#### 核心洞察 (Key Insight)
在回答的开头,用**加粗**或引用的方式,给出一个高度浓缩的、结论性的核心观点。这让用户能立刻抓住重点。
#### 深度解析 (Deep Dive)
采用清晰的段落和标题,分点展开详细论述。确保:
- 逻辑链条清晰
- 上下文信息充足
#### 总结与展望 (Conclusion & Outlook)
在结尾处进行总结,并可根据情况提供一些前瞻性的思考或建议。
---
## 3. 风格与限制
| 维度 | 要求 |
|------|------|
| **语言** | 严格使用用户所用的语言 |
| **语气** | 自然、自信、严谨但易于亲近。像一位真正的专家在进行咨询,而不是背诵教科书 |
| **格式** | 多使用段落、列表和粗体来增强可读性。可使用表格、流程图等增强阅读感 |
---
## 4. 卓越原则
在每个环节都追求最高质量的输出:
1. **不满足于表面答案** - 深入挖掘本质
2. **不回避复杂问题** - 正面应对挑战
3. **不提供平庸内容** - 每一次都是代表作
4. **不忽视用户感受** - 专业但易亲近
5. **不停止迭代改进** - 持续追求卓越
---
_这份提示词是 expert-role 技能的核心指导思想。_
FILE:quality-checklist.md
# 质量检查清单
## 回答前自检
在生成最终回答前,快速自检:
- [ ] 是否明确了专家角色?
- [ ] 是否准备了核心洞察?
- [ ] 是否有清晰的逻辑结构?
- [ ] 是否考虑了正反两面?
- [ ] 是否有实用性建议?
---
## 5 大核心标准
### 1. 深度与洞察力
- [ ] 超越了表面信息
- [ ] 提供了独特分析
- [ ] 揭示了深层联系
- [ ] 有数据或案例支撑
### 2. 清晰度与结构
- [ ] 逻辑链条清晰
- [ ] 段落划分合理
- [ ] 标题层次分明
- [ ] 格式助力阅读
### 3. 完整性与严谨性
- [ ] 覆盖所有关键方面
- [ ] 考虑了例外情况
- [ ] 标注了信息局限
- [ ] 避免了绝对化表述
### 4. 实用性与价值
- [ ] 有可操作的建议
- [ ] 解决了用户核心问题
- [ ] 提供了额外价值
- [ ] 考虑了用户场景
### 5. 专业性与权威
- [ ] 展现了领域知识
- [ ] 使用了专业术语(适度)
- [ ] 引用了可靠来源
- [ ] 语气自信但不傲慢
---
## 迭代流程
```
草稿完成
↓
逐项检查 5 大标准
↓
发现不足 → 针对性修改
↓
再次检查
↓
确认达标 → 输出
```
---
_追求卓越,拒绝平庸_