📦 Daxiang Memory Optimization — 记忆优化
v1.0.0通过评分、淘汰低价值条目、控制容量并智能检索高相关记忆，实现高效内存管理。
by 详细分析 ▾
运行时依赖
版本
Memory Optimization Skill v1.0.0 – 初始版本 - 引入多层记忆系统（L0–L3），附带摘要与长期洞察。 - 基于可配置相关阈值，提供自动记忆评分、修剪与归档。 - 实现智能检索与记忆容量控制，最大化检索效率。 - 包含 Python 与 PowerShell 代码示例，展示关键优化策略。 - 聚焦在降低存储与检索成本的同时保持有价值的知识。
安装命令
点击复制技能文档
版本: v1.0 创建日期: 2026-03-26 作者: 象腿 (main agent) 用途: 优化memory管理，自动修剪低价值记忆，提升检索效率
---
🎯 核心功能
Memory Optimization skill 负责：- 记忆评分: 为每条记忆计算相关度分数
- 自动修剪: 删除/归档低价值记忆（相关度<0.6）
- 智能检索: 基于相关度排序的memory检索
- 容量控制: 控制memory总大小（window: 200）
- 定期维护: 定期清理和优化memory
---
📋 Memory 架构回顾
L0: 完整原始记录
位置:memory/YYYY-MM-DD.md
内容: 完整的对话记录、操作日志、事件详情
特点:
- 100% 保留原始数据
- 用于深度检索和审计
- 文件大小: 10-50 KB/日
---
L1: 关键点提炼
位置:memory/summaries/YYYY-MM-DD-summary.md
内容: 当日关键点、重要决策、错误记录
特点:
- 保留 70% token（相比 L0）
- 提取关键信息，丢弃冗余
- 文件大小: 3-15 KB/日
---
L2: 结构化知识
位置:MEMORY.md
内容: 长期有价值的知识、经验、洞察
特点:
- 保留 90% token（相比 L0）
- 结构化存储，易于检索
- 文件大小: 20-30 KB
---
L3: 核心洞察
位置:library/insights/, library/sops/, library/references/
内容: 最核心的洞察、SOP、参考资料
特点:
- 保留 95% token（相比 L0）
- 精华中的精华
- 文件大小: 5-10 KB/文档
---
🔄 Memory 优化策略
策略1: 相关度评分
``python
def calculate_relevance_score(memory, query):
"""
计算记忆与查询的相关度分数
Args:
memory: 记忆对象
query: 查询字符串
Returns:
float: 相关度分数 (0.0-1.0)
"""
# 1. 关键词匹配 (40%)
keyword_score = calculate_keyword_match(memory, query)
# 2. 时间衰减 (20%)
time_score = calculate_time_decay(memory)
# 3. 访问频率 (20%)
access_score = calculate_access_frequency(memory)
# 4. 标签匹配 (20%)
tag_score = calculate_tag_match(memory, query)
# 综合评分
total_score = (
keyword_score 0.4 +
time_score 0.2 +
access_score 0.2 +
tag_score 0.2
)
return total_score
`
---
策略2: 自动修剪
`python
def prune_low_value_memories(memories, threshold=0.6):
"""
修剪低价值记忆
Args:
memories: 记忆列表
threshold: 修剪阈值（默认 0.6）
Returns:
tuple: (保留的记忆, 删除的记忆)
"""
kept = []
pruned = []
for memory in memories:
score = memory.get('relevance_score', 0.5)
if score >= threshold:
kept.append(memory)
else:
# 归档到 archive
archive_memory(memory)
pruned.append(memory)
log(f"Pruned {len(pruned)} low-value memories (threshold: {threshold})")
log(f"Kept {len(kept)} high-value memories")
return kept, pruned
`
---
策略3: 容量控制
`python
def control_memory_size(memories, window=200):
"""
控制 memory 总大小
Args:
memories: 记忆列表
window: 最大记忆数量（默认 200）
Returns:
list: 修剪后的记忆列表
"""
if len(memories) <= window:
return memories
# 按相关度排序
sorted_memories = sorted(
memories,
key=lambda m: m.get('relevance_score', 0.5),
reverse=True
)
# 保留前 N 条
kept = sorted_memories[:window]
pruned = sorted_memories[window:]
# 归档删除的记忆
for memory in pruned:
archive_memory(memory)
log(f"Memory size controlled: {len(memories)} -> {len(kept)} (window: {window})")
return kept
`
---
策略4: 智能检索
`python
def smart_retrieve_memories(query, memories, top_k=10):
"""
基于相关度的智能检索
Args:
query: 查询字符串
memories: 记忆列表
top_k: 返回前 K 条结果（默认 10）
Returns:
list: 相关度最高的前 K 条记忆
"""
# 计算所有记忆的相关度
scored_memories = []
for memory in memories:
score = calculate_relevance_score(memory, query)
memory['relevance_score'] = score
scored_memories.append(memory)
# 按相关度排序
sorted_memories = sorted(
scored_memories,
key=lambda m: m['relevance_score'],
reverse=True
)
# 返回前 K 条
return sorted_memories[:top_k]
`
---
🛠️ PowerShell 实现
PowerShell 相关度计算
`powershell
function Calculate-RelevanceScore {
param(
[hashtable]$Memory,
[string]$Query
)
# 1. 关键词匹配 (40%)
$keywordScore = Calculate-KeywordMatch -Memory $Memory -Query $Query
# 2. 时间衰减 (20%)
$timeScore = Calculate-TimeDecay -Memory $Memory
# 3. 访问频率 (20%)
$accessScore = Calculate-AccessFrequency -Memory $Memory
# 4. 标签匹配 (20%)
$tagScore = Calculate-TagMatch -Memory $Memory -Query $Query
# 综合评分
$totalScore = ($keywordScore 0.4) + ($timeScore 0.2) + ($accessScore 0.2) + ($tagScore 0.2)
return [math]::Round($totalScore, 2)
}
function Calculate-KeywordMatch {
param(
[hashtable]$Memory,
[string]$Query
)
$memoryText = $Memory.content -join " "
$queryWords = $Query -split "\s+"
$matchCount = 0
foreach ($word in $queryWords) {
if ($memoryText -match [regex]::Escape($word)) {
$matchCount++
}
}
return $matchCount / $queryWords.Count
}
function Calculate-TimeDecay {
param(
[hashtable]$Memory
)
$memoryDate = [datetime]$Memory.created_at
$daysSince = (Get-Date) - $memoryDate
# 指数衰减：7 天内不衰减，之后每天衰减 2%
if ($daysSince.Days -le 7) {
return 1.0
} else {
$decayRate = 1 - ($daysSince.Days 0.02)
return [math]::Max($decayRate, 0.1) # 最小 0.1
}
}
function Calculate-AccessFrequency {
param(
[hashtable]$Memory
)
$accessCount = $Memory.access_count
$lastAccess = [datetime]$Memory.last_accessed
# 访问次数越多，分数越高（但递减）
$score = [math]::Log($accessCount + 1) / 10
# 最近访问过的有额外加分
$daysSinceAccess = (Get-Date) - $lastAccess
if ($daysSinceAccess.Days -le 7) {
$score = 1.5
}
return [math]::Min($score, 1.0)
}
function Calculate-TagMatch {
param(
[hashtable]$Memory,
[string]$Query
)
$memoryTags = $Memory.tags -split ","
$queryWords = $Query -split "\s+"
$matchCount = 0
foreach ($word in $queryWords) {
foreach ($tag in $memoryTags) {
if ($tag -match [regex]::Escape($word)) {
$matchCount++
break
}
}
}
if ($memoryTags.Count -eq 0) {
return 0.5 # 无标签的记忆给中等分数
}
return $matchCount / $memoryTags.Count
}
`
---
PowerShell 记忆修剪
`powershell
function Prune-LowValueMemories {
param(
[array]$Memories,
[double]$Threshold = 0.6
)
$kept = @()
$pruned = @()
foreach ($memory in $Memories) {
# 计算相关度分数
$score = $memory.relevance_score
if (-not $score) {
$score = Calculate-RelevanceScore -Memory $memory -Query ""
}
if ($score -ge $Threshold) {
$kept += $memory
} else {
# 归档到 archive
Archive-Memory -Memory $memory
$pruned += $memory
}
}
Write-Host "Pruned $($pruned.Count) low-value memories (threshold: $Threshold)"
Write-Host "Kept $($kept.Count) high-value memories"
return $kept, $pruned
}
function Archive-Memory {
param(
[hashtable]$Memory
)
$archiveDir = "C:\Users\Administrator\.openclaw\workspace-main\memory\archive"
if (-not (Test-Path $archiveDir)) {
New-Item -ItemType Directory -Path $archiveDir -Force | Out-Null
}
$archiveFile = Join-Path $archiveDir "archive-$(Get-Date -Format 'yyyy-MM').json"
# 追加到 archive 文件
$archiveEntry = @{
id = $Memory.id
content = $Memory.content
created_at = $Memory.created_at
relevance_score = $Memory.relevance_score
archived_at = (Get-Date -Format "yyyy-MM-dd HH:mm:ss")
}
$json = $archiveEntry | ConvertTo-Json -Compress
Add-Content -Path $archiveFile -Value $json -Encoding UTF8
}
`
---
PowerShell 智能检索
`powershell
function Smart-RetrieveMemories {
param(
[string]$Query,
[array]$Memories,
[int]$TopK = 10
)
# 计算所有记忆的相关度
$scoredMemories = @()
foreach ($memory in $Memories) {
$score = Calculate-RelevanceScore -Memory $memory -Query $Query
$memory.relevance_score = $score
$scoredMemories += $memory
}
# 按相关度排序
$sortedMemories = $scoredMemories | Sort-Object -Property relevance_score -Descending
# 返回前 K 条
return $sortedMemories | Select-Object -First $TopK
}
`
---
📊 性能优化
优化1: 增量评分
`python
def incremental_scoring(memories, changed_memories):
"""
只对变化的记忆重新评分
Args:
memories: 所有记忆
changed_memories: 变化的记忆列表
Returns:
更新后的记忆列表
"""
# 只对变化的记忆重新计算分数
for memory in changed_memories:
memory['relevance_score'] = calculate_relevance_score(memory, "")
return memories
`
---
优化2: 缓存评分结果
`python
class RelevanceCache:
def __init__(self):
self.cache = {}
self.ttl = 3600 # 缓存 1 小时
def get_score(self, memory_id, query):
cache_key = f"{memory_id}:{query}"
if cache_key in self.cache:
cached = self.cache[cache_key]
if time.time() - cached['timestamp'] < self.ttl:
return cached['score']
return None
def set_score(self, memory_id, query, score):
cache_key = f"{memory_id}:{query}"
self.cache[cache_key] = {
'score': score,
'timestamp': time.time()
}
def clear(self):
self.cache.clear()
`
---
优化3: 批量操作
`python
def batch_prune_memories(memories, batch_size=50):
"""
批量修剪记忆
Args:
memories: 记忆列表
batch_size: 批次大小
Returns:
修剪后的记忆列表
"""
pruned_count = 0
for i in range(0, len(memories), batch_size):
batch = memories[i:i + batch_size]
# 批量计算相关度
for memory in batch:
memory['relevance_score'] = calculate_relevance_score(memory, "")
# 批量修剪
kept, pruned = prune_low_value_memories(batch)
pruned_count += len(pruned)
log(f"Batch {i // batch_size + 1}: pruned {len(pruned)} memories")
log(f"Total pruned: {pruned_count} memories")
return kept
`
---
🎓 使用示例
示例1: 基础修剪
`python
# 加载所有记忆
memories = load_all_memories()
# 修剪低价值记忆
kept, pruned = prune_low_value_memories(memories, threshold=0.6)
# 保存结果
save_memories(kept)
`
示例2: 智能检索
`python
# 用户查询
query = "如何优化AI Agent的性能"
# 智能检索
results = smart_retrieve_memories(query, memories, top_k=10)
# 输出结果
for i, memory in enumerate(results, 1):
print(f"{i}. [Score: {memory['relevance_score']:.2f}] {memory['content'][:50]}...")
`
示例3: 定期维护
`python
# 每周执行一次 memory 维护
def weekly_maintenance():
# 1. 加载所有记忆
memories = load_all_memories()
# 2. 容量控制（window: 200）
memories = control_memory_size(memories, window=200)
# 3. 修剪低价值记忆（threshold: 0.6）
memories, _ = prune_low_value_memories(memories, threshold=0.6)
# 4. 清理 archive
clean_old_archive()
# 5. 保存结果
save_memories(memories)
log("Weekly memory maintenance completed")
`
---
⚙️ 配置文件
memory-optimization-config.json
`json
{
"version": "1.0",
"config": {
"window": 200,
"prune_threshold": 0.6,
"enable_auto_prune": true,
"prune_interval": 604800,
"enable_smart_retrieve": true,
"top_k": 10
},
"scoring": {
"keyword_weight": 0.4,
"time_decay_weight": 0.2,
"access_frequency_weight": 0.2,
"tag_match_weight": 0.2
},
"time_decay": {
"no_decay_days": 7,
"decay_rate_per_day": 0.02,
"min_score": 0.1
},
"archive": {
"enabled": true,
"archive_dir": "memory/archive",
"retention_days": 90
},
"optimization": {
"enable_incremental_scoring": true,
"enable_score_cache": true,
"cache_ttl": 3600,
"batch_size": 50
}
}
`
---
📈 性能指标
关键指标
`yaml
metrics:
- name: "memory_size"
description: "记忆总数"
target: "<= 200"
- name: "avg_relevance_score"
description: "平均相关度分数"
target: "> 0.7"
- name: "retrieval_accuracy"
description: "检索准确率"
formula: "相关结果数 / 总结果数"
target: "> 0.8"
- name: "prune_rate"
description: "修剪率"
formula: "修剪记忆数 / 总记忆数"
target: "< 0.2"
- name: "token_efficiency"
description: "Token 效率"
formula: "保留价值 / 总 token 数"
target: "> 0.95"
``
---
🚀 未来优化
短期 (1-2 周)
- [ ] 实现向量检索（embedding-based）
- [ ] 添加记忆聚类分析
- [ ] 实现自动标签生成
中期 (1 个月)
- [ ] 实现跨 agent 记忆共享
- [ ] 添加记忆图谱可视化
- [ ] 实现记忆推荐系统
长期 (3 个月)
- [ ] 引入强化学习优化修剪策略
- [ ] 实现自适应阈值调整
- [ ] 构建记忆价值预测模型
---
Skill 版本: v1.0 最后更新: 2026-03-26 维护者: 象腿 (main agent)