万字深度解析 claude-mem：当 AI 编程遇见跨会话记忆革命——从自动上下文捕获到 AI 压缩注入、从 TypeScript 实现到多平台兼容的完整技术指南（2026）

Claude Code 最被诟病的痛点是什么？不是代码质量，不是推理速度，而是失忆。每次新会话开始，AI 助手就像得了阿尔茨海默症，昨天一起调了三小时的 Bug 忘得一干二净。claude-mem 的出现，正在从根本上重塑这一局面。

一、背景：AI 编程助手的"失忆症"到底有多痛？

1.1 问题的本质：Context Window 不是记忆

每一位深度使用 AI 编程助手的开发者，都会遇到一个看似无解的矛盾：

• Claude Code 的 context window 有 200K tokens，理论上可以装下整个中型项目的代码库；
• 但实际开发中，每次新会话都是一张白纸，上一会话的决策、尝试过的方案、踩过的坑，全部归零；
• 手动粘贴上下文？ 既低效又不可持续，而且浪费大量 tokens 在重复解释上。

这个问题的本质，不是 context window 不够大，而是缺少跨会话的持久化记忆层。

1.2 现有方案的局限

在 claude-mem 出现之前，开发者们尝试过各种 workaround：

这些方案的核心问题是：记忆的生成、压缩、检索都没有自动化，完全依赖开发者的主动管理。

1.3 claude-mem 的破局思路

claude-mem 的作者 Alex Newman（@thedotmack）提出了一个根本性的范式转变：

让 AI 自己管理自己的记忆。

核心思路只有三步，但每一步都经过精心设计：

1. 自动捕获：在 AI 编程助手的生命周期关键节点，自动截取工具调用和输出的原始数据；
2. AI 压缩：用 Claude Agent SDK 把 1000~10000 tokens 的原始观察，压缩成约 500 tokens 的结构化语义摘要；
3. 智能注入：新会话启动时，根据当前上下文，自动检索并注入最相关的历史记忆。

结果：78,000+ stars，成为 Claude Code 生态最热门的插件，没有之一。

二、核心概念：claude-mem 到底是什么？

2.1 一句话定义

claude-mem 是一个为 Claude Code（及 OpenClaw、Gemini CLI、Codex 等多平台）设计的持久化记忆压缩系统。它在你编程时自动工作，不需要任何手动操作，让 AI 助手在跨会话、跨设备重连后仍能延续对项目的理解。

2.2 核心架构组件

claude-mem 的架构可以用"一库、一服务、七个钩子"来概括：

┌─────────────────────────────────────────────────────────────┐
│                    Claude Code 会话                         │
│                                                           │
│  用户输入 → Claude 推理 → 工具调用 → 观察结果 → 输出    │
│                    ↓                                      │
│            【7 个生命周期钩子】                           │
│  Setup → SessionStart → UserPromptSubmit → PreToolUse     │
│        → PostToolUse → Stop → SessionEnd                   │
│                    ↓                                      │
│            【Worker Service (Port 37777)】                │
│  HTTP API + SSE 实时流 + React Viewer UI                 │
│                    ↓                                      │
│            【SQLite + FTS5 全文搜索】                     │
│  sessions 表 / observations 表 / summaries 表             │
│                    ↓                                      │
│            【Claude Agent SDK 压缩】                      │
│  原始观察 (1000~10000 tokens) → AI 压缩 → 摘要 (~500 tokens) │
│                    ↓                                      │
│            【下一会话的 Context Hook】                     │
│  检索相关记忆 → 注入新会话 → Claude 获得"长期记忆"       │
└─────────────────────────────────────────────────────────────┘

2.3 关键特性解读

2.3.1 渐进式披露（Progressive Disclosure）

这是 claude-mem 最精妙的设计之一。传统方案要么注入全部历史（token 爆炸），要么不注入（没有记忆）。claude-mem 用了一种分层策略：

• 第一层（Session Start）：只注入最近 N 条摘要的标题和 ID（约 200~500 tokens）；
• 第二层（按需搜索）：Claude 通过 mem-search skill 或 MCP 工具，用自然语言查询历史记忆；
• 第三层（精确获取）：对搜索结果感兴趣，再按需拉取完整内容（约 500~1000 tokens/条）。

这种"先索引、后详情"的模式，节省了约 10 倍的 token 开销。

2.3.2 隐私控制：<private> 标签

在企业环境或敏感项目中，不是所有内容都适合持久化。claude-mem 支持用 <private>...</private> 标签标记不想被记录的内容：

// 在提示词或对话中使用
用户: 我的数据库密码是 <private>my-secret-password</private>，帮我配置连接
// claude-mem 会自动剥离 private 标签内的内容后再存储

2.3.3 多平台兼容

claude-mem 最初是为 Claude Code 开发的，但架构设计上采用了插件化思路，目前已支持：

三、架构深度剖析：从钩子到向量搜索的完整数据链路

3.1 钩子系统：六个生命周期事件

Claude Code 的插件系统基于生命周期钩子（lifecycle hooks）。claude-mem 利用了其中 6 个（加 1 个 Setup 检查），在每个关键节点自动触发：

3.1.1 Setup → version-check.js（~20ms 执行）

// version-check.js 核心逻辑（简化版）
import { readFileSync } from 'fs';
import { resolve } from 'path';

const markerPath = resolve(process.env.HOME, '.claude-mem', '.install-version');
const currentVersion = readFileSync(markerPath, 'utf-8').trim();

if (currentVersion !== EXPECTED_VERSION) {
  console.error(`[claude-mem] Version mismatch. Run: npx claude-mem repair`);
  // 注意：exit(0) 而非 exit(1)，避免阻断用户会话
}

设计精妙之处：这个检查在每次命令执行前触发，但耗时不到 20ms，用户完全无感知。如果发现版本不匹配（比如用户更新了 claude-mem），会提示修复，但不会强制中断工作流。

3.1.2 SessionStart → 启动 Worker + 注入上下文

这是整个系统中最关键的钩子。它做两件事：

// hooks/session-start.ts（核心逻辑）
export async function sessionStartHook(): Promise<void> {
  // 1. 确保 Worker Service 正在运行
  await ensureWorkerRunning();
  
  // 2. 从数据库读取相关记忆，注入到新会话
  const recentObservations = await db.getRecentObservations({
    project: getCurrentProject(),
    limit: 10,  // 可配置，默认 10 条
  });
  
  const contextPrompt = formatAsContext(recentObservations);
  // 输出到 stdout，Claude Code 会将其作为系统消息注入会话
  console.log(contextPrompt);
}

注入的上下文长什么样？

## 📝 近期项目记忆（自动注入，基于 claude-mem）

最近你在这个项目中：
- 修复了 OAuth 回调地址配置错误（观察 #128，2 天前）
- 将 session store 从 in-memory 迁移到了 Redis（观察 #119，3 天前）
- 发现并绕过了 Node 22 的 fetch API 与代理环境的兼容性问题（观察 #115，4 天前）

如果需要回顾详情，用 /mem-search 搜索 "OAuth" 或 "Redis 迁移"。

3.1.3 PostToolUse → 捕获工具执行结果（最高频）

这是整个系统中触发最频繁的钩子（一次会话可能触发 100+ 次）。每次 Claude 调用工具（Read、Write、Edit、Bash 等），这个钩子都会执行：

// hooks/post-tool-use.ts（核心逻辑）
export async function postToolUseHook(toolName: string, toolInput: any, toolOutput: any): Promise<void> {
  // 1. 构造"观察记录"
  const observation = {
    toolName,
    input: JSON.stringify(toolInput).slice(0, 2000),  // 截断，避免超大输入
    output: JSON.stringify(toolOutput).slice(0, 5000), // 核心：保留足够多的输出
    timestamp: Date.now(),
    project: getCurrentProject(),
    sessionId: getCurrentSessionId(),
  };
  
  // 2. 写入 SQLite（同步，快速返回，不阻塞用户）
  db.insertObservation(observation);
  
  // 3. 异步通知 Worker Service 处理这条观察
  fetch('http://localhost:37777/api/observation/new', {
    method: 'POST',
    body: JSON.stringify({ id: observation.id }),
  }).catch(() => {}); // 失败不阻塞
}

为什么写入数据库后还要通知 Worker？ 因为 AI 压缩是异步的——不能在钩子执行期间等待 Claude API 调用（那样会让用户卡住）。Worker Service 会在后台批量处理。

3.1.4 Stop → 生成会话摘要

当 Claude 准备给出最终回复时，Stop 钩子触发，生成这次会话的结构化摘要：

// hooks/stop.ts（核心逻辑）
export async function stopHook(conversationHistory: Message[]): Promise<string> {
  // 用 Claude Agent SDK 生成摘要
  const summary = await sdk.processConversation({
    messages: conversationHistory,
    prompt: `请总结本次会话的核心内容：
    1. 解决了什么问题？
    2. 做了哪些关键决策？
    3. 有哪些值得下次会话参考的要点？
    输出为结构化 JSON，每个要点不超过 100 字。`,
  });
  
  // 写入数据库
  db.insertSummary({
    sessionId: getCurrentSessionId(),
    content: summary,
    tokens: estimateTokens(summary),
  });
  
  return summary;
}

3.2 Worker Service：系统的"大脑"

Worker Service 是一个运行在后台的 Express.js HTTP 服务（默认端口 37777），它是 claude-mem 的异步处理引擎。

3.2.1 为什么需要独立的 Worker？

3.2.2 Worker 的 HTTP API 设计

// src/services/worker-service.ts（路由核心）
import express from 'express';
const app = express();

// 观察记录相关
app.post('/api/observation/new', async (req, res) => { /* 接收新观察，加入处理队列 */ });
app.get('/api/observation/:id', (req, res) => { /* 获取单条观察详情 */ });

// 搜索相关（FTS5 全文搜索）
app.get('/api/search/observations', (req, res) => { /* FTS5 搜索观察记录 */ });
app.get('/api/search/sessions', (req, res) => { /* 搜索会话 */ });

// SSE 实时流（Web Viewer 用）
app.get('/api/stream/observations', (req, res) => { /* SSE 推送新观察 */ });

// 管理相关
app.post('/api/worker/restart', (req, res) => { /* 重启 Worker */ });
app.get('/api/status', (req, res) => { /* 健康检查和统计 */ });

app.listen(37777);

3.2.3 AI 压缩的 Prompt 工程

Worker 中最核心的逻辑，是用 Claude Agent SDK 把原始观察压缩成结构化摘要。这部分 prompt 设计直接决定了记忆质量：

// src/sdk/process-observation.ts
const COMPRESSION_PROMPT = `
你正在为 AI 编程助手构建长期记忆系统。
下面是一条工具调用的原始记录，请提取其中的结构化信息。

原始记录：
工具名称：{toolName}
工具输入：{input}
工具输出：{output}

请输出严格的 JSON（不要加 \`\`\`json 标记）：
{
  "summary": "一句话描述这条观察的核心内容（≤100字）",
  "type": "bugfix | feature | refactor | debug | config | other",
  "keyDecisions": ["决策1", "决策2"],
  "filesChanged": ["src/foo.ts", "test/foo.test.ts"],
  "lessonsLearned": "如果下次遇到类似问题，有什么值得参考的经验？",
  "relatedIssue": "如果关联了 GitHub Issue，填入编号"
}

要求：
1. summary 要有信息密度，想象你是 3 天后回来继续开发的自己，你希望看到什么？
2. lessonsLearned 是最重要的字段，要有真正可复用的洞察，不要写废话。
3. 如果工具输出中含有错误信息，务必在 summary 中体现错误特征和解决思路。
`;

3.3 数据库层：SQLite + FTS5 的全文搜索魔法

3.3.1 表结构设计

-- ~/.claude-mem/claude-mem.db

-- 会话表：记录每次 Claude Code 会话
CREATE TABLE sessions (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  session_id TEXT UNIQUE NOT NULL,  -- Claude Code 的会话 UUID
  project_path TEXT NOT NULL,        -- 项目绝对路径（用于跨会话关联）
  project_name TEXT,                 -- 项目名（从 package.json 或 git 目录名提取）
  start_time INTEGER NOT NULL,
  end_time INTEGER,
  summary TEXT,                      -- Stop 钩子生成的会话摘要
  token_count INTEGER DEFAULT 0      -- 本次会话消耗的 token 估算
);

-- 观察记录表：每次工具调用的原始记录
CREATE TABLE observations (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  session_id INTEGER NOT NULL REFERENCES sessions(id),
  tool_name TEXT NOT NULL,           -- Read | Write | Edit | Bash | etc.
  tool_input TEXT,                   -- JSON 字符串
  tool_output TEXT,                  -- JSON 字符串（已截断到合理大小）
  compressed_summary TEXT,           -- AI 压缩后的摘要（异步填充）
  observation_type TEXT,             -- bugfix | feature | ...
  created_at INTEGER NOT NULL,
  project_path TEXT NOT NULL,
  FULLTEXT_KEY TEXT,                -- FTS5 外键
  FOREIGN KEY (FULLTEXT_KEY) REFERENCES observations_fts(rowid)
);

-- FTS5 虚拟表：启用全文搜索
CREATE VIRTUAL TABLE observations_fts USING fts5(
  tool_name,
  tool_input,
  tool_output,
  compressed_summary,
  content='observations',
  content_rowid='id'
);

3.3.2 FTS5 搜索实战

// src/services/sqlite/session-search.ts
export function searchObservations(query: string, options: {
  type?: string;
  project?: string;
  dateAfter?: number;
  limit?: number;
}): Observation[] {
  const db = getDatabase();
  
  // FTS5 查询：支持中文分词（通过 Unicode61 分词器）
  const sql = `
    SELECT o.* FROM observations o
    JOIN observations_fts fts ON o.id = fts.rowid
    WHERE observations_fts MATCH $query
    ${options.type ? 'AND o.observation_type = $type' : ''}
    ${options.project ? 'AND o.project_path LIKE $project' : ''}
    ORDER BY rank
    LIMIT $limit
  `;
  
  return db.query(sql, {
    $query: tokenizeQuery(query),  // 查询词分词
    $type: options.type,
    $project: `%${options.project}%`,
    $limit: options.limit ?? 20,
  });
}

FTS5 的一个坑：默认分词器对中文支持不好。claude-mem 的解决方案是——在写入 FTS5 之前，用简单的 Unicode 字符级分词：

function tokenizeForFTS(text: string): string {
  // 英文：按空格/标点分词（FTS5 默认行为）
  // 中文：每个字作为独立 token（简单但有效）
  return text.split('').filter(c => c.trim().length > 0).join(' ');
}

3.4 向量搜索：当 FTS5 不够用时

FTS5 擅长关键词匹配，但不理解语义。比如你搜索"认证问题"，FTS5 匹配不到记录了"auth bug"的观察。

claude-mem v5 引入了可选的 Chroma 向量数据库来解决这个问题：

// src/services/sync/chroma-sync.ts
export async function syncToChroma(observation: Observation): Promise<void> {
  // 1. 获取 observation 的 embedding
  const embedding = await getEmbedding(observation.compressed_summary);
  
  // 2. 写入 Chroma
  await chromaClient.add({
    collection: 'claude-mem-observations',
    ids: [String(observation.id)],
    embeddings: [embedding],
    metadatas: [{
      tool_name: observation.tool_name,
      type: observation.observation_type,
      project: observation.project_path,
      created_at: observation.created_at,
    }],
  });
}

// 语义搜索
export async function semanticSearch(query: string, topK: number = 5): Promise<Observation[]> {
  const queryEmbedding = await getEmbedding(query);
  const results = await chromaClient.query({
    collection: 'claude-mem-observations',
    queryEmbeddings: [queryEmbedding],
    nResults: topK,
  });
  
  // 根据 Chroma 返回的 IDs，从 SQLite 取出完整记录
  return db.getObservationsByIds(results.ids[0]);
}

混合搜索策略（v5.4 引入）：

// 先 FTS5 粗筛（快速），再向量重排（精准）
export async function hybridSearch(query: string, limit: number = 10) {
  // Step 1: FTS5 全文搜索，取 3 倍于 limit 的结果
  const ftsResults = searchObservations(query, { limit: limit * 3 });
  
  // Step 2: 对 FTS 结果做语义重排序
  const reranked = await rerankBySemanticSimilarity(query, ftsResults);
  
  // Step 3: 返回 top-K
  return reranked.slice(0, limit);
}

四、代码实战：从安装到深度定制

4.1 安装：一条命令背后的工程细节

npx claude-mem install

这条看起来简单的命令，背后其实做了很多事：

// scripts/install.ts（核心逻辑，已简化）
export async function install() {
  const steps = [
    { name: '检查 Node.js 版本', fn: checkNodeVersion },
    { name: '安装 Bun 运行时', fn: installBun },        // Bun 用于运行 Worker
    { name: '安装 uv（Python 包管理器）', fn: installUv }, // 向量搜索依赖
    { name: '注册 Claude Code 插件钩子', fn: registerHooks },
    { name: '启动 Worker Service', fn: startWorker },
    { name: '运行健康检查', fn: healthCheck },
  ];
  
  for (const step of steps) {
    console.log(`[${step.name}] 开始...`);
    await step.fn();
    console.log(`[${step.name}] ✅ 完成`);
  }
}

为什么需要 Bun？ 因为 Worker Service 需要用 Bun 的进程管理能力（自动重启、日志管理、端口分配）。Claude-Mem 选择 Bun 而非 PM2 或 systemd，是因为 Bun 是纯 JavaScript 运行时，跨平台一致性更好。

4.2 配置详解：~/.claude-mem/settings.json

{
  // Worker 服务端口（默认自动分配：37700 + uid % 100）
  "CLAUDE_MEM_WORKER_PORT": 37777,
  
  // AI 压缩使用的模型（默认用 Claude Code 自身的 API Key）
  "CLAUDE_MEM_AI_MODEL": "claude-sonnet-4-20250514",
  
  // 观察记录的保留策略
  "CLAUDE_MEM_RETENTION_DAYS": 90,  // 超过 90 天的观察会被归档
  
  // 新会话启动时注入的回忆条数
  "CLAUDE_MEM_CONTEXT_INJECT_COUNT": 10,
  
  // 是否启用 Chroma 向量搜索（需要额外安装）
  "CLAUDE_MEM_ENABLE_CHROMA": false,
  
  // 隐私：是否在存储前剥离 <private> 标签内容
  "CLAUDE_MEM_STRIP_PRIVATE_TAGS": true,
  
  // 语言（影响 AI 压缩时生成摘要的语言）
  "CLAUDE_MEM_MODE": "code--zh",  // code--zh | code--ja | code | ...
  
  // 高级：PostToolUse 钩子的采样率（1.0 = 记录所有工具调用）
  "CLAUDE_MEM_TOOL_SAMPLING_RATE": 1.0
}

4.3 实战案例：用 mem-search 找回三天前的调试思路

场景：你三天前调试了一个棘手的内存泄漏问题，今天类似症状出现了，但你不记得具体排查步骤了。

用户: /mem-search 内存泄漏 排查步骤

Claude:
📝 找到 3 条相关记忆：

[#89] 2026-06-30 - 修复用户信息接口的内存泄漏
  问题：/api/user/:id 接口在高并发下内存持续增长
  根因：未正确关闭 MongoDB 游标（cursor）
  解决：在 finally 块中显式调用 cursor.close()
  经验：Node.js 的 MongoDB 驱动不会自动回收游标，高并发时特别容易泄漏
  
  相关文件：src/routes/user.ts
  
[#92] 2026-07-01 - 用 heapdump 定位内存泄漏
  使用了 heapdump + Chrome DevTools Memory Profiler
  发现泄漏点在 LRU 缓存的实现上（没有正确设置 maxSize）
  
  相关文件：src/utils/lru-cache.ts

要查看完整细节吗？我可以获取观察 #89 和 #92 的完整记录。

4.4 高级定制：编写自定义 Mode

claude-mem 的观察压缩行为是通过"Mode"来定制的。如果你想让 AI 在压缩时更关注某些特定维度，可以编写自定义 Mode：

# 查看内置 Modes
ls ~/.claude/plugins/marketplaces/thedotmack/plugin/modes/

# 创建自定义 Mode：code--security-focus
mkdir -p ~/.claude/plugins/marketplaces/thedotmack/plugin/modes/code--security-focus

// ~/.claude/plugins/marketplaces/thedotmack/plugin/modes/code--security-focus/mode.json
{
  "name": "code--security-focus",
  "description": "安全审计模式：压缩观察时重点关注安全相关决策",
  "language": "zh",
  "compressionPrompt": "
    你正在为安全审计构建长期记忆。
    在压缩观察记录时，必须特别关注：
    1. 是否引入了潜在的安全漏洞（SQL 注入、XSS、不安全的反序列化等）
    2. 是否正确处理了用户输入验证和转义
    3. 敏感信息（密钥、密码、token）是否被正确保护
    4. 权限检查和授权逻辑是否完备
    
    在 lessonsLearned 字段中，务必记录安全最佳实践和相关警告。
  "
}

五、性能优化：Token 成本与检索效率的平衡艺术

5.1 Token 成本分析

使用 claude-mem 是有代价的——主要是 AI 压缩步骤消耗额外的 API 调用。让我们算一笔账：

结论：对于重度使用者（每天 50+ 工具调用），claude-mem 的 API 成本约为每天 $0.05~$0.20（按 Claude API 定价）。这个成本相比它节省的重复解释时间，是非常划算的。

5.2 渐进式披露的三层工作流（深度解析）

这是 claude-mem 在 Token 优化上最值得称道的设计：

第一层：search（获取索引）         → ~50 tokens/结果
第二层：timeline（时间线上下文）   → ~200 tokens/结果
第三层：get_observations（完整详情）→ ~800 tokens/结果

错误用法（Claude 初学会犯的错误）：

// ❌ 错误：直接获取所有观察的完整内容
const allObs = await get_observations({ limit: 50 });
// 结果：50 × 800 = 40,000 tokens！直接爆掉预算

正确用法（遵循渐进式披露）：

// ✅ 正确：三层工作流
// Step 1: 搜索索引（廉价）
const index = await search({ query: "OAuth 配置", limit: 10 });
// Token 成本：10 × 50 = 500 tokens

// Step 2: 识别相关结果，获取时间线（中等成本）
const relevantIds = [128, 131, 135]; // 从索引中人工/AI 筛选
const timeline = await timeline({ aroundIds: relevantIds });
// Token 成本：3 × 200 = 600 tokens

// Step 3: 只对真正需要的获取完整内容（昂贵但精准）
const details = await get_observations({ ids: [128] });
// Token 成本：1 × 800 = 800 tokens

// 总计：~1900 tokens，获取了精准的 1 条完整记忆

5.3 数据库查询优化

当观察记录达到万级时，FTS5 搜索可能变慢。claude-mem 用了几个优化手段：

-- 优化 1：对高频查询字段建索引
CREATE INDEX idx_observations_project ON observations(project_path);
CREATE INDEX idx_observations_type ON observations(observation_type);
CREATE INDEX idx_observations_created ON observations(created_at DESC);

-- 优化 2：定期 OPTIMIZE（合并 FTS5 碎片）
-- 每周日凌晨自动执行
INSERT INTO observations_fts(observations_fts) VALUES('optimize');

-- 优化 3：分区归档（v6 计划功能）
-- 将超过 90 天的观察移到 observations_archive 表

六、与竞品对比：claude-mem 的护城河在哪里？

6.1 功能对比矩阵

6.2 claude-mem 的技术护城河

1. 架构前瞻性：v3 → v5 的演进路径清晰，从"简单存储"到"智能检索"到"语义理解"，每一步都踩在用户真实痛点上；
2. 多平台策略：不绑定单一 AI 助手，这是比其他插件高明的地方；
3. OpenClaw 深度集成：作为 OpenClaw 的官方推荐记忆插件，获得了大量企业用户；
4. 活跃社区：111 个 Issues、133 个 PRs（截至 2026 年 7 月），说明项目在持续迭代。

七、总结与展望：AI 记忆系统的下一次进化

7.1 claude-mem 给我们的最大启示

claude-mem 的成功，本质上是因为它解决了一个被整个行业忽视的基础设施工具链问题。

AI 编程助手的能力在过去两年里突飞猛进——从 GPT-3 到 Claude Sonnet 4，代码生成质量提升了几个数量级。但所有人都盯着"模型能力"这个显性指标，却没人认真解决"如何让 AI 真正理解你的项目"这个隐性问题。

claude-mem 用工程手段给出了答案：记忆不是模型的能力，而是系统的基础设施。

7.2 未来路线图（基于公开 Issue 和 PR 分析）

根据 claude-mem 的 GitHub Issues 和 roadmap，以下功能正在开发中：

1. Endless Mode（Beta 已可用）：生物启发式记忆架构，模拟人类记忆的"短期→长期"巩固过程；
2. 多用户协作记忆：团队共享记忆层（需要解决隐私和权限问题）；
3. 更智能的检索：用 LLM 对搜索意图进行理解，而不是简单的关键词/向量匹配；
4. 导出/导入：支持将记忆迁移到新机器，或分享给团队成员；
5. 与 IDE 深度集成：不限于 Claude Code，未来可能支持 VSCode 插件直连。

7.3 给开发者的建议

如果你还没用过 claude-mem，现在就去装。一条命令，改变你的 AI 编程体验：

npx claude-mem install

如果你已经在用，但感觉"记忆不够准"，检查一下：

1. 是否用了最新版？（npx claude-mem repair 更新）
2. 是否配置了正确的 Mode？（中文用户务必设置 CLAUDE_MEM_MODE: "code--zh"）
3. 是否给了足够的观察时间？（记忆系统需要积累，用得越久越精准）

附录：快速参考

A. 常用命令速查

# 安装/修复
npx claude-mem install
npx claude-mem repair

# 查看 Worker 状态
curl http://localhost:37777/api/status

# 打开 Web Viewer
open http://localhost:37777

# 查看数据库统计
sqlite3 ~/.claude-mem/claude-mem.db "SELECT COUNT(*) FROM observations;"

B. 故障排查 Checklist

C. 延伸阅读

• 官方文档：https://docs.claude-mem.ai/
• GitHub 仓库：https://github.com/thedotmack/claude-mem
• OpenClaw 集成指南：https://docs.claude-mem.ai/openclaw-integration
• Context Engineering 指南：https://docs.claude-mem.ai/context-engineering

本文基于 claude-mem v13.4.0 撰写，发布时请确认使用最新版本。