下载入口:https://github.com/openclaw/skills/tree/main/skills/nextfrontierbuilds/elite-longterm-memory

安装与下载

1. ClawHub CLI

从源直接安装技能的最快方式。

npx clawhub@latest install elite-longterm-memory

2. 手动安装

将技能文件夹复制到以下位置之一

全局模式 ~/.openclaw/skills/ 工作区 <project>/skills/

优先级：工作区 > 本地 > 内置

3. 提示词安装

将此提示词复制到 OpenClaw 即可自动安装。

请帮我使用 Clawhub 安装 elite-longterm-memory。如果尚未安装 Clawhub，请先安装（npm i -g clawhub）。

什么是 Elite 长期记忆？

Elite 长期记忆是一个先进的上下文管理框架，专为 AI 编程智能体设计，旨在解决会话历史丢失的问题。通过结合从基于会话的热内存到云端归档的六个不同记忆层，它确保智能体永远不会丢失项目目标或技术约束。这一架构是开发者使用 Openclaw 技能的基石，能够让智能体在重启和长期任务中保持状态的一致性。

该系统采用预写式日志 (WAL) 协议，要求智能体在生成响应之前记录决策和任务状态。这保证了持久性和可靠性，特别是在上下文窗口可能变得杂乱或压缩的复杂编码会话中。Elite 长期记忆为 Openclaw 技能提供了强大的支柱，实现了随代码库演进的语义自动召回和结构化知识存储。

Elite 长期记忆 应用场景

• 在超出标准上下文窗口的长期开发会话中保持深度的项目上下文。
• 存储和检索架构决策及编码偏好，以确保智能体的一致性。
• 通过云端集成，在不同设备或团队成员之间同步技术知识和会话状态。
• 通过从长对话中提取并仅存储最相关的核心事实，降低 Token 消耗。

Elite 长期记忆 工作原理

1. 智能体首先读取 SESSION-STATE.md 文件，以加载即时活动上下文和当前任务状态。
2. 通过 LanceDB 执行语义搜索，根据当前用户输入自动召回相关记忆。
3. 每当识别出新的决策或偏好时，智能体在响应前将其写入 SESSION-STATE.md 文件，以确保数据持久性。
4. 永久决策和结构化元数据被提交到 Git-Notes，创建项目的分支感知知识图谱。
5. 定期将每日日志和会话状态提炼并归档到人类可读的 MEMORY.md 文件中，作为长期项目智慧。

Elite 长期记忆 配置指南

1. 初始化热内存

在项目根目录下创建初始会话状态文件：

cat > SESSION-STATE.md << 'EOF'
# SESSION-STATE.md — 活动工作内存

## 当前任务
[无]

## 关键上下文
[暂无]

---
*最后更新：[时间戳]*
EOF

2. 配置 Openclaw

更新您的 ~/.openclaw/openclaw.json 以启用语义搜索和 LanceDB 插件：

{
  "memorySearch": {
    "enabled": true,
    "provider": "openai",
    "sources": ["memory"]
  },
  "plugins": {
    "entries": {
      "memory-lancedb": {
        "enabled": true
      }
    }
  }
}

3. 设置冷存储

初始化基于 Git-Notes 的存储系统：

cd your-project-dir
git init
python3 skills/git-notes-memory/memory.py -p . sync --start

Elite 长期记忆 数据架构与分类体系

层级	存储类型	功能
热内存	SESSION-STATE.md	使用 WAL 协议的活动工作内存和任务追踪。
温存储	LanceDB 向量	用于自动上下文注入的语义搜索数据库。
冷存储	Git-Notes	用于永久技术决策的分支感知知识图谱。
归档	MEMORY.md & daily/	人类可读的精选历史记录和每日日志。
云端	SuperMemory API	可选的跨设备同步和备份。

name: elite-longterm-memory
version: 1.2.3
description: "Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot. WAL protocol + vector search + git-notes + cloud backup. Never lose context again. Vibe-coding ready."
author: NextFrontierBuilds
keywords: [memory, ai-agent, ai-coding, long-term-memory, vector-search, lancedb, git-notes, wal, persistent-context, claude, claude-code, gpt, chatgpt, cursor, copilot, github-copilot, openclaw, moltbot, vibe-coding, agentic, ai-tools, developer-tools, devtools, typescript, llm, automation]
metadata:
  openclaw:
    emoji: "??"
    requires:
      env:
        - OPENAI_API_KEY
      plugins:
        - memory-lancedb

Elite Longterm Memory ??

The ultimate memory system for AI agents. Combines 6 proven approaches into one bulletproof architecture.

Never lose context. Never forget decisions. Never repeat mistakes.

Architecture Overview

┌─────────────────────────────────────────────────────────────────┐
│                    ELITE LONGTERM MEMORY                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐             │
│  │   HOT RAM   │  │  WARM STORE │  │  COLD STORE │             │
│  │             │  │             │  │             │             │
│  │ SESSION-    │  │  LanceDB    │  │  Git-Notes  │             │
│  │ STATE.md    │  │  Vectors    │  │  Knowledge  │             │
│  │             │  │             │  │  Graph      │             │
│  │ (survives   │  │ (semantic   │  │ (permanent  │             │
│  │  compaction)│  │  search)    │  │  decisions) │             │
│  └─────────────┘  └─────────────┘  └─────────────┘             │
│         │                │                │                     │
│         └────────────────┼────────────────┘                     │
│                          ▼                                      │
│                  ┌─────────────┐                                │
│                  │  MEMORY.md  │  ← Curated long-term           │
│                  │  + daily/   │    (human-readable)            │
│                  └─────────────┘                                │
│                          │                                      │
│                          ▼                                      │
│                  ┌─────────────┐                                │
│                  │ SuperMemory │  ← Cloud backup (optional)     │
│                  │    API      │                                │
│                  └─────────────┘                                │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

The 5 Memory Layers

Layer 1: HOT RAM (SESSION-STATE.md)

From: bulletproof-memory

Active working memory that survives compaction. Write-Ahead Log protocol.

# SESSION-STATE.md — Active Working Memory

## Current Task
[What we're working on RIGHT NOW]

## Key Context
- User preference: ...
- Decision made: ...
- Blocker: ...

## Pending Actions
- [ ] ...

Rule: Write BEFORE responding. Triggered by user input, not agent memory.

Layer 2: WARM STORE (LanceDB Vectors)

From: lancedb-memory

Semantic search across all memories. Auto-recall injects relevant context.

# Auto-recall (happens automatically)
memory_recall query="project status" limit=5

# Manual store
memory_store text="User prefers dark mode" category="preference" importance=0.9

Layer 3: COLD STORE (Git-Notes Knowledge Graph)

From: git-notes-memory

Structured decisions, learnings, and context. Branch-aware.

# Store a decision (SILENT - never announce)
python3 memory.py -p $DIR remember '{"type":"decision","content":"Use React for frontend"}' -t tech -i h

# Retrieve context
python3 memory.py -p $DIR get "frontend"

Layer 4: CURATED ARCHIVE (MEMORY.md + daily/)

From: OpenClaw native

Human-readable long-term memory. Daily logs + distilled wisdom.

workspace/
├── MEMORY.md              # Curated long-term (the good stuff)
└── memory/
    ├── 2026-01-30.md      # Daily log
    ├── 2026-01-29.md
    └── topics/            # Topic-specific files

Layer 5: CLOUD BACKUP (SuperMemory) — Optional

From: supermemory

Cross-device sync. Chat with your knowledge base.

export SUPERMEMORY_API_KEY="your-key"
supermemory add "Important context"
supermemory search "what did we decide about..."

Layer 6: AUTO-EXTRACTION (Mem0) — Recommended

NEW: Automatic fact extraction

Mem0 automatically extracts facts from conversations. 80% token reduction.

npm install mem0ai
export MEM0_API_KEY="your-key"

const { MemoryClient } = require('mem0ai');
const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });

// Conversations auto-extract facts
await client.add(messages, { user_id: "user123" });

// Retrieve relevant memories
const memories = await client.search(query, { user_id: "user123" });

Benefits:

• Auto-extracts preferences, decisions, facts
• Deduplicates and updates existing memories
• 80% reduction in tokens vs raw history
• Works across sessions automatically

Quick Setup

1. Create SESSION-STATE.md (Hot RAM)

cat > SESSION-STATE.md << 'EOF'
# SESSION-STATE.md — Active Working Memory

This file is the agent's "RAM" — survives compaction, restarts, distractions.

## Current Task
[None]

## Key Context
[None yet]

## Pending Actions
- [ ] None

## Recent Decisions
[None yet]

---
*Last updated: [timestamp]*
EOF

2. Enable LanceDB (Warm Store)

In ~/.openclaw/openclaw.json:

{
  "memorySearch": {
    "enabled": true,
    "provider": "openai",
    "sources": ["memory"],
    "minScore": 0.3,
    "maxResults": 10
  },
  "plugins": {
    "entries": {
      "memory-lancedb": {
        "enabled": true,
        "config": {
          "autoCapture": false,
          "autoRecall": true,
          "captureCategories": ["preference", "decision", "fact"],
          "minImportance": 0.7
        }
      }
    }
  }
}

3. Initialize Git-Notes (Cold Store)

cd ~/clawd
git init  # if not already
python3 skills/git-notes-memory/memory.py -p . sync --start

4. Verify MEMORY.md Structure

# Ensure you have:
# - MEMORY.md in workspace root
# - memory/ folder for daily logs
mkdir -p memory

5. (Optional) Setup SuperMemory

export SUPERMEMORY_API_KEY="your-key"
# Add to ~/.zshrc for persistence

Agent Instructions

On Session Start

1. Read SESSION-STATE.md — this is your hot context
2. Run memory_search for relevant prior context
3. Check memory/YYYY-MM-DD.md for recent activity

During Conversation

1. User gives concrete detail? → Write to SESSION-STATE.md BEFORE responding
2. Important decision made? → Store in Git-Notes (SILENTLY)
3. Preference expressed? → memory_store with importance=0.9

On Session End

1. Update SESSION-STATE.md with final state
2. Move significant items to MEMORY.md if worth keeping long-term
3. Create/update daily log in memory/YYYY-MM-DD.md

Memory Hygiene (Weekly)

1. Review SESSION-STATE.md — archive completed tasks
2. Check LanceDB for junk: memory_recall query="*" limit=50
3. Clear irrelevant vectors: memory_forget id=<id>
4. Consolidate daily logs into MEMORY.md

The WAL Protocol (Critical)

Write-Ahead Log: Write state BEFORE responding, not after.

Why? If you respond first and crash/compact before saving, context is lost. WAL ensures durability.

Example Workflow

User: "Let's use Tailwind for this project, not vanilla CSS"

Agent (internal):
1. Write to SESSION-STATE.md: "Decision: Use Tailwind, not vanilla CSS"
2. Store in Git-Notes: decision about CSS framework
3. memory_store: "User prefers Tailwind over vanilla CSS" importance=0.9
4. THEN respond: "Got it — Tailwind it is..."

Maintenance Commands

# Audit vector memory
memory_recall query="*" limit=50

# Clear all vectors (nuclear option)
rm -rf ~/.openclaw/memory/lancedb/
openclaw gateway restart

# Export Git-Notes
python3 memory.py -p . export --format json > memories.json

# Check memory health
du -sh ~/.openclaw/memory/
wc -l MEMORY.md
ls -la memory/

Why Memory Fails

Understanding the root causes helps you fix them:

Solutions (Ranked by Effort)

1. Quick Win: Enable memory_search

If you have an OpenAI key, enable semantic search:

openclaw configure --section web

This enables vector search over MEMORY.md + memory/*.md files.

2. Recommended: Mem0 Integration

Auto-extract facts from conversations. 80% token reduction.

npm install mem0ai

const { MemoryClient } = require('mem0ai');

const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY });

// Auto-extract and store
await client.add([
  { role: "user", content: "I prefer Tailwind over vanilla CSS" }
], { user_id: "ty" });

// Retrieve relevant memories
const memories = await client.search("CSS preferences", { user_id: "ty" });

3. Better File Structure (No Dependencies)

memory/
├── projects/
│   ├── strykr.md
│   └── taska.md
├── people/
│   └── contacts.md
├── decisions/
│   └── 2026-01.md
├── lessons/
│   └── mistakes.md
└── preferences.md

Keep MEMORY.md as a summary (<5KB), link to detailed files.

Immediate Fixes Checklist

Troubleshooting

Agent keeps forgetting mid-conversation: → SESSION-STATE.md not being updated. Check WAL protocol.

Irrelevant memories injected: → Disable autoCapture, increase minImportance threshold.

Memory too large, slow recall: → Run hygiene: clear old vectors, archive daily logs.

Git-Notes not persisting: → Run git notes push to sync with remote.

memory_search returns nothing: → Check OpenAI API key: echo $OPENAI_API_KEY → Verify memorySearch enabled in openclaw.json

---

Links

• bulletproof-memory: https://clawdhub.com/skills/bulletproof-memory
• lancedb-memory: https://clawdhub.com/skills/lancedb-memory
• git-notes-memory: https://clawdhub.com/skills/git-notes-memory
• memory-hygiene: https://clawdhub.com/skills/memory-hygiene
• supermemory: https://clawdhub.com/skills/supermemory

---

Built by @NextXFrontier — Part of the Next Frontier AI toolkit