🌊 Agent持久化记忆是什么？——AI的"不忘本"修炼手册

# OpenClaw Skill: persistent-memory.yaml
name: persistent-memory
description: "Agent持久化记忆管理"

tools:
  - name: save_memory
    description: "保存记忆到本地文件"
    parameters:
      key: string
      value: string
      category: string  # 分类：user_pref | task_state | knowledge
    command: |
      mkdir -p ~/.openclaw/memory/{{category}}
      echo "{{value}}" > ~/.openclaw/memory/{{category}}/{{key}}.txt
      
  - name: load_memory
    description: "读取持久化记忆"
    parameters:
      key: string
      category: string
    command: |
      cat ~/.openclaw/memory/{{category}}/{{key}}.txt 2>/dev/null || echo "NOT_FOUND"
      
  - name: search_memories
    description: "搜索历史记忆（grep）"
    parameters:
      query: string
      category: string (optional)
    command: |
      if [ -z "{{category}}" ]; then
        grep -r "{{query}}" ~/.openclaw/memory/ 2>/dev/null
      else
        grep -r "{{query}}" ~/.openclaw/memory/{{category}}/ 2>/dev/null
      fi

// OpenClaw Skill集成agentmemory
// 安装：npm install agentmemory

const { AgentMemory } = require('agentmemory');

// 初始化记忆系统
const memory = new AgentMemory({
  storage: 'sqlite',  // 或 'postgres', 'mongodb'
  dbPath: '~/.openclaw/memory/agent.db'
});

// Skill: save_to_memory
async function saveToMemory(key, value, metadata = {}) {
  await memory.set({
    key,
    value,
    namespace: 'openclaw-agent',
    metadata: {
      timestamp: Date.now(),
      source: 'openclaw',
      ...metadata
    }
  });
}

// Skill: recall_from_memory
async function recallFromMemory(query, options = {}) {
  const results = await memory.search({
    query,
    limit: options.limit || 5,
    threshold: options.threshold || 0.7
  });
  return results;
}

// 使用示例：在OpenClaw Session中
// 1. 保存用户偏好
await saveToMemory('user_pref_model', 'gpt-4', { type: 'preference' });

// 2. 任务完成后的总结存储
await saveToMemory('task_123_summary', 
  '完成了RAG系统搭建，关键发现：向量维度需优化',
  { type: 'task_result', taskId: '123' }
);

// 3. 下次启动时召回
const pastTasks = await recallFromMemory('RAG系统', { limit: 3 });
console.log('历史相关任务：', pastTasks);

# OpenClaw + Qdrant/Pinecone向量记忆
# requirements.txt: qdrant-client, openai

from openai import OpenAI
from qdrant_client import QdrantClient
from qdrant_client.http import models

# 初始化
client = QdrantClient(path="~/.openclaw/memory/qdrant_db")
openai_client = OpenAI()

# 创建记忆集合
def init_memory_collection():
    client.create_collection(
        collection_name="agent_memories",
        vectors_config=models.VectorParams(
            size=1536,  # OpenAI embedding维度
            distance=models.Distance.COSINE
        )
    )

# 存储记忆（自动向量化）
def save_memory(text, metadata):
    embedding = openai_client.embeddings.create(
        input=text,
        model="text-embedding-3-small"
    ).data[0].embedding
    
    client.upsert(
        collection_name="agent_memories",
        points=[models.PointStruct(
            id=hash(text) % (2**63),  # 简单hash作为ID
            vector=embedding,
            payload={"text": text, **metadata}
        )]
    )

# 检索记忆
def recall_memory(query, top_k=5):
    query_embedding = openai_client.embeddings.create(
        input=query,
        model="text-embedding-3-small"
    ).data[0].embedding
    
    results = client.search(
        collection_name="agent_memories",
        query_vector=query_embedding,
        limit=top_k
    )
    
    return [hit.payload["text"] for hit in results]

# OpenClaw Skill调用示例
# save_memory("用户喜欢在凌晨1点42分工作，效率最高", 
#             {"type": "user_habit", "timestamp": "2026-05-31"})
# 
# related = recall_memory("用户工作习惯")
# print(related)  # 输出：["用户喜欢在凌晨1点42分工作..."]