MemPalace on Kalend's Blog

知识库搭完就完了？加上这两招，效率翻倍

Fri, 29 May 2026 10:00:00 +0800

备选标题①：别再用 RAG 从零搜了！3 步搭出互联知识库 + 接入 AI 助手备选标题②：99% 的人卡在"知识库能搜"就停了——你还能再做两步备选标题③：知识库入门容易精通难：两个进阶玩法效率直接翻倍

上篇我们用 MemPalace + ChromaDB + Ollama 搭好了基础知识库。安装、嵌入、搜索、定时扫描，一条龙跑通。

但说实话，能搜只是起点。

搜索是"每次从零发现"，你问一次它找一次，找不到就是找不到。知识之间的关系？没有。知识的沉淀和演化？也没有。

今天讲两个进阶玩法，直接把知识库从"能用"拉到"好用"：

第一，LLM Wiki 互联知识库。

第二，接入 AI 助手，让记忆自动流转。

一、LLM Wiki：从"搜文档"到"用知识"

传统 RAG 的致命问题

每次提问，RAG 都要重新检索、重新理解、重新组织答案。同一个知识点问了十遍，它就检索了十遍，没有任何积累。

这就像每次考试都从头翻课本，从不做笔记。

LLM Wiki 的思路不一样：一次编译知识，持续更新，互联引用。

它源自 Karpathy 的 LLM Wiki 模式，用互联的 Markdown 文件构建一个持久化的知识网络。

三层架构

LLM Wiki 的核心是三层分离：

Layer 1：raw/ —— 不可变原始资料。

放文章、论文、对话记录等原材料。

一旦放进去就不改，作为知识源头。

Layer 2：Wiki Pages —— AI 拥有的知识页面。

这是核心产出层。

包含实体页、概念页、对比页、查询页。

每个页面都是经过消化的结构化知识。

Layer 3：SCHEMA.md —— 结构规则和标签分类法。

定义整个 wiki 的域配置、标签体系、页面阈值。

是整个系统的"宪法"。

三层分离的好处：原始数据不动，知识页面持续演化，规则独立维护。

实操：5 分钟搭骨架

先创建目录结构：

1

mkdir -p ~/wiki/{raw/{articles,papers,transcripts,assets},entities,concepts,comparisons,queries}

创建 SCHEMA.md：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


# Wiki Schema

## Domain
AI Engineering & Knowledge Management

## Taxonomy Tags
- #architecture
- #embedding
- #retrieval
- #integration
- #rag
- #vector-db
- #workflow

## Page Thresholds
- entity_min_references: 2
- concept_min_sections: 3
- comparison_min_axes: 3
- query_max_age_days: 90

## Naming Convention
- lowercase-with-hyphens.md

创建 index.md（导航中心）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# Wiki Index

## Entities
<!-- entities listed here -->

## Concepts
<!-- concepts listed here -->

## Comparisons
<!-- comparisons listed here -->

## Queries
<!-- queries listed here -->

创建 log.md（操作日志）：

1
2
3
4


# Wiki Log

| Date | Action | Target | Notes |
|------|--------|--------|-------|

完成。这就是一个完整的 LLM Wiki 骨架。

三个核心操作

LLM Wiki 围绕三个操作展开：

Ingest（摄入）：把原材料变成知识。

流程是：捕获原始源 → 讨论要点 → 检查已有页面 → 创建或更新页面 → 更新导航。

不是简单存文件，而是消化、提取、关联、索引一条龙。

Query（查询）：基于已有知识回答。

关键区别：查完之后，有价值的答案会写回 wiki。知识越用越丰富。

Lint（检查）：保持知识库健康。

检测孤儿页面、断裂链接、索引完整性等六类问题。超过 100 个页面后，不跑 Lint 就是给自己埋雷。

Obsidian 兼容

LLM Wiki 原生兼容 Obsidian。[[页面名]] 的 wikilinks 语法直接可用。

Graph View 可以可视化知识网络。

把 ~/wiki 当作 Vault 打开就行，零迁移成本。

二、接入 AI 助手：让知识自动流转

知识库搭好了，但每次手动查还是很累。

更合理的做法是：把知识库变成 AI 助手的长期记忆，对话时自动存取。

方式 A：MemoryProvider 深度集成（推荐）

MemPalace 直接作为 AI 助手框架的 memory provider，对话时自动同步记忆。

在框架配置文件中设置：

1
2
3
4
5
6
7
8


memory:
 memory_enabled: true
 user_profile_enabled: true
 memory_char_limit: 2200
 user_char_limit: 1375
 provider: mempalace
 nudge_interval: 10
 flush_min_turns: 6

再创建 mempalace.json 配置自动提取：

1
2
3
4


{
 "auto_extract": true,
 "extract_model": "glm-4-flash"
}

这里 extract_model 用轻量模型做记忆提取，成本极低。

配置完成后，框架自动注册 6 个工具：

mempalace_recall（语义搜索）、mempalace_store（精准存储）、mempalace_knowledge（查询知识图谱）。

mempalace_kg_add（添加三元组）。

mempalace_kg_invalidate（标记过期）、mempalace_status（记忆总览）。

三个自动钩子

集成后，三个钩子自动工作：

sync_turn() —— 每轮对话结束，自动把消息持久化到 MemPalace。你不用手动存。

on_memory_write() —— 框架内置记忆写入时，自动镜像到 MemPalace。双写，不丢。

on_session_end() —— 对话结束时，自动提取三类记忆：Persona、Episodic、Instruction。提取完直接存入，下次对话自动加载。

去重机制：新记忆与已有记忆做 cosine similarity，超过 0.92 视为重复，跳过存储。防止记忆膨胀。

方式 B：MCP Server（备选）

如果框架不支持 MemoryProvider，可以用 MCP 协议接入：

1
2
3
4


mcp_servers:
 mempalace:
 command: python
 args: ["-m", "mempalace.mcp_server"]

功能一样，但没有自动钩子方便，适合过渡。

三、多实例隔离：别让并发写炸了你的数据库

同时跑多个 Agent（主助手 + OpenClaw 定时挖掘 + 其他实验），它们都写同一个 ChromaDB，迟早出问题。

ChromaDB 不是为高并发写入设计的。多进程同时写，数据损坏只是时间问题。

解决方案：每个 Agent 用独立的 MemPalace 实例。

实例	路径	使用者
主实例	`~/.mempalace/palace/`	AI 助手主程序
第二实例	`~/.mempalace/palace-openclaw/`	OpenClaw 定时挖掘
第三实例	`~/.mempalace/palace-yuan/`	其他 Agent

路径不同，ChromaDB 实例不同，互不干扰。

OpenClaw 定时挖掘脚本示例：

1
2
3
4
5
6


#!/bin/bash

PALACE_DB="/root/.mempalace/palace-openclaw"
PALACE_PATH="/root/.openclaw/workspace-main"

mempalace --palace "$PALACE_DB" mine "$PALACE_PATH" --limit 500

然后配置定时执行。用 OpenClaw 自己的 cron，不要用系统 crontab。

踩坑清单

1. ChromaDB 并发写必挂。 多 Agent 共享一个实例是"能跑"但"迟早崩"。老老实实隔离。

2. 记忆提取模型别用大模型。 extract_model 用轻量模型就够了。用大模型做提取，成本是收益的十倍。

3. LLM Wiki 的 Lint 别偷懒。 知识库超过 100 个页面后，孤儿页面和矛盾内容会越来越多。

4. wiki 路径别用中文。 文件名和目录名都用英文加连字符。中文路径在 wikilinks 中会出奇怪问题。

5. MemPalace 去重阈值 0.92 不要调低。 调到 0.85 以下，相似但不同的记忆会被误判为重复丢弃。宁可多存，不可误删。

6. flush_min_turns 别设太大。 设成 20 的话，对话在第 15 轮断了，那 15 轮的记忆都没存。建议 6-8 轮。

总结

上篇解决了"知识库能存能搜"。

这篇解决了两个更关键的问题：

第一，知识库能互联、能演化。LLM Wiki 的三层架构让知识从"孤立文档"变成"互联网络"，越用越丰富。

第二，知识库能和 AI 助手自动协同。MemPalace 作为 MemoryProvider，对话即存储，查询即回忆，全程自动化。

加上多实例隔离，多 Agent 并行也不会打架。

三步走：基础搭建 → 互联知识库 → AI 助手集成。到这步，你的知识库系统才算真正完成。

3个命令搭知识库：你的笔记终于能"搜懂意思"了

Fri, 29 May 2026 07:36:00 +0800

我搭了个跑在自己机器上的知识库，能自动扫描文件、语义搜索、定时更新，全程零 API 费用。

之前试过关键词搜索笔记，搜"AI怎么记住对话"，0 结果。换成语义搜索，秒命中。下面是完整搭建过程，每一步都能直接复制执行。

为什么你需要一个知识库

笔记越积越多，Ctrl+F 搜不到东西了。关键词匹配只认字面，不认意思。

“AI怎么记住之前的对话"搜不到"记忆系统架构”，但语义上是一回事。这就是关键词搜索的致命缺陷。

第一步：装 MemPalace（5分钟）

MemPalace 是本地优先的 AI 记忆系统，底层用 ChromaDB 存向量数据。

1
2
3
4
5


# 一行安装
pip install mempalace

# 验证
mempalace status

输出类似这样说明成功：

1
2
3


Palace Status:
 Drawers filed: 0
 Total memories: 0

安装完自动创建 ~/.mempalace/ 目录。默认嵌入模型是 all-MiniLM-L6-v2（英文模型，384维），后面会换成中文模型。

第二步：装 Ollama + 中文嵌入模型（10分钟）

默认英文模型对中文命中率约 50%。换成中文模型，实测 100%。

1
2
3
4
5
6
7
8


# 1. 装 Ollama（本地推理引擎）
curl -fsSL https://ollama.com/install.sh | sh

# 2. 启动服务
ollama serve &

# 3. 拉中文嵌入模型（约4.7GB）
ollama pull qwen3-embedding

验证 Ollama 在跑：

1
2


curl http://localhost:11434/api/embeddings \
 -d '{"model":"qwen3-embedding","prompt":"测试中文嵌入"}'

返回一个 4096 维浮点数组就对了。

踩坑提醒： Ollama 嵌入 API 用 prompt 字段，不是 input。ChromaDB 自带的 Ollama 适配器用错了字段，后面会说怎么绕过。

第三步：初始化知识库（3分钟）

编辑 ~/.mempalace/config.json：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


{
 "palace_path": "/root/.mempalace/palace",
 "collection_name": "mempalace_drawers",
 "topic_wings": [
 "project",
 "technical",
 "personal",
 "creative",
 "work"
 ]
}

topic_wings 是知识分区，相当于书架分类标签。按需修改。

写初始化脚本 init_palace.py：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#!/usr/bin/env python3
"""用 Qwen3 中文嵌入模型初始化 MemPalace 向量集合"""
import chromadb
import requests

class Qwen3Embedding:
 """绕过 ChromaDB Ollama 适配器的 prompt/input bug"""
 def __init__(self, url="http://localhost:11434", model="qwen3-embedding"):
 self.url = url
 self.model = model

 def __call__(self, texts):
 embeddings = []
 for t in texts:
 r = requests.post(
 f"{self.url}/api/embeddings",
 json={"model": self.model, "prompt": t},
 timeout=60
 )
 embeddings.append(r.json()["embedding"])
 return embeddings

client = chromadb.PersistentClient(path="/root/.mempalace/palace")
ef = Qwen3Embedding()

collection = client.get_or_create_collection(
 name="mempalace_drawers",
 embedding_function=ef,
 metadata={"hnsw:space": "cosine"}
)

print(f"集合已就绪，当前 {collection.count()} 条记录")

运行：

1

python3 init_palace.py

关键： 如果之前用默认模型创建过集合（384维），必须删掉重建。Qwen3 是 4096 维，维度不同会报错。

1
2
3
4
5
6
7
8
9


# 重建（会清空已有数据）
python3 -c "
import chromadb
client = chromadb.PersistentClient(path='/root/.mempalace/palace')
for c in client.list_collections():
 client.delete_collection(c.name)
 print(f'已删除: {c.name}')
"
# 然后重新运行 init_palace.py

第四步：存入第一条知识（2分钟）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#!/usr/bin/env python3
"""存入一条知识并验证"""
import chromadb
import hashlib
import time
import requests

client = chromadb.PersistentClient(path="/root/.mempalace/palace")
col = client.get_collection("mempalace_drawers")

text = "AI 助手的记忆系统分四层：热记忆（每轮注入）→ 用户画像 → 知识库按需检索 → 会话历史搜索"
wing = "technical"
room = "memory-architecture"

resp = requests.post("http://localhost:11434/api/embeddings",
 json={"model": "qwen3-embedding", "prompt": text}, timeout=60)
embedding = resp.json()["embedding"]

doc_id = hashlib.md5(text.encode()).hexdigest()[:16]
col.add(
 ids=[doc_id],
 embeddings=[embedding],
 documents=[text],
 metadatas=[{
 "wing": wing,
 "room": room,
 "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")
 }]
)

print(f"已存入: {text[:50]}...")
print(f"总条数: {col.count()}")

第五步：验证语义搜索（2分钟）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#!/usr/bin/env python3
"""语义搜索测试"""
import chromadb
import requests

client = chromadb.PersistentClient(path="/root/.mempalace/palace")
col = client.get_collection("mempalace_drawers")

query = "AI 怎么记住之前的对话？"

resp = requests.post("http://localhost:11434/api/embeddings",
 json={"model": "qwen3-embedding", "prompt": query}, timeout=60)
query_embedding = resp.json()["embedding"]

results = col.query(query_embeddings=[query_embedding], n_results=3)

for i, doc in enumerate(results["documents"][0]):
 dist = results["distances"][0][i]
 wing = results["metadatas"][0][i].get("wing", "?")
 print(f"[{dist:.3f}] ({wing}) {doc[:80]}...")

实测效果对比：

搜索问题	关键词匹配	语义搜索
“AI怎么记住之前的对话”	0 结果	命中"四层记忆架构"
“怎么防止模型忘东西”	0 结果	命中记忆管理策略
“中文向量模型哪个好”	0 结果	命中嵌入模型对比

第六步：自动扫描入库（核心）

写一个脚本扫描你的笔记/文档目录，自动切片 + 向量化 + 入库。

保存为 auto_index.sh：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68


#!/bin/bash
set -e

DOCS_DIR="${1:-$HOME/notes}"
PALACE_PATH="$HOME/.mempalace/palace"
LOG_FILE="$HOME/.mempalace/logs/index_$(date +%Y%m%d).log"

mkdir -p "$(dirname "$LOG_FILE")"

log() { echo "[$(date '+%H:%M:%S')] $1" | tee -a "$LOG_FILE"; }

log "开始扫描: $DOCS_DIR"

if command -v mempalace &>/dev/null; then
 mempalace mine "$DOCS_DIR" --limit 500 >> "$LOG_FILE" 2>&1
 log "MemPalace mine 完成"
else
 python3 << 'PYEOF'
import os, hashlib, time, requests, chromadb

DOCS_DIR = os.environ.get("DOCS_DIR", os.path.expanduser("~/notes"))
client = chromadb.PersistentClient(path=os.path.expanduser("~/.mempalace/palace"))
col = client.get_collection("mempalace_drawers")
existing_ids = set(col.get()["ids"]) if col.count() > 0 else set()

def embed(text):
 r = requests.post("http://localhost:11434/api/embeddings",
 json={"model": "qwen3-embedding", "prompt": text[:500]}, timeout=120)
 return r.json()["embedding"]

added = 0
for root, dirs, files in os.walk(DOCS_DIR):
 dirs[:] = [d for d in dirs if not d.startswith(".")]
 for f in files:
 if not f.endswith((".md", ".txt", ".py", ".yaml", ".json")):
 continue
 fpath = os.path.join(root, f)
 try:
 content = open(fpath, "r", errors="ignore").read()
 except:
 continue
 if len(content) < 50:
 continue

 chunks = [content[i:i+500] for i in range(0, len(content), 500)]
 for chunk in chunks:
 doc_id = hashlib.md5(chunk.encode()).hexdigest()[:16]
 if doc_id in existing_ids:
 continue

 try:
 vec = embed(chunk)
 col.add(ids=[doc_id], embeddings=[vec], documents=[chunk],
 metadatas=[{"source": fpath, "wing": "docs",
 "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S")}])
 existing_ids.add(doc_id)
 added += 1
 except Exception as e:
 print(f" 错误 {fpath}: {e}")

print(f"新增 {added} 条，总计 {col.count()} 条")
PYEOF
 log "Python 扫描完成"
fi

if command -v mempalace &>/dev/null; then
 mempalace status 2>&1 | head -10 | tee -a "$LOG_FILE"
fi

1
2


chmod +x auto_index.sh
./auto_index.sh ~/notes

CPU 推理每条约 20 秒，100 个文件大约 30 分钟。有 GPU 会快很多。

第七步：定时自动更新（2分钟）

让知识库每天自动扫描新增文件：

1
2
3
4
5


# 编辑 crontab
crontab -e

# 添加这行：每天凌晨3点自动更新
0 3 * * * ~/auto_index.sh ~/notes >> ~/.mempalace/logs/cron.log 2>&1

或者用 MemPalace 自带的命令：

1

0 3 * * * mempalace mine ~/notes --limit 500 >> ~/.mempalace/logs/cron.log 2>&1

第八步：接入 AI 助手（可选）

如果你用 AI 助手框架，可以把 MemPalace 作为记忆后端：

1
2
3
4
5
6


# AI 助手框架配置文件
memory:
 memory_enabled: true
 provider: mempalace
 memory_char_limit: 2200
 flush_min_turns: 6

这样对话中产生的关键信息会自动存入知识库，下次对话时能通过语义搜索找回。

踩坑清单（必看）

坑	症状	解决方案
嵌入模型 API 字段错误	返回空向量，ChromaDB 报 IndexError	用 `prompt` 不用 `input`
换嵌入模型后维度冲突	报 dimension mismatch	必须删旧集合重建
ChromaDB 并发写损坏	数据库报 file is not a database	不同进程用不同目录
CPU 推理太慢	几百条数据跑几小时	批量跑用 batch_size=5
中文搜索命中率低	all-MiniLM-L6-v2 只有50%命中	换 Qwen3-Embedding
Ollama 服务没启动	嵌入请求超时	`ollama serve` 或设自启
切片太粗	搜索命中但信息不精确	500字左右切一片

成本核算

项目	数据
磁盘占用	Ollama 模型约4.7GB + ChromaDB 约10MB/千条
内存占用	Ollama 常驻约150MB（CPU模式）
API 费用	0（全部本地）
首次搭建时间	约30分钟
日常维护	零（定时任务自动跑）

给Agent装个自动记忆：让AI自己记住你说过的话

Fri, 15 May 2026 20:30:00 +0800

你跟AI说"我习惯用vim，不要用nano"，下次对话它照样给你nano。每次都要重复说，烦不烦？

先说结论

核心思路就三行：

1

session结束 → 调免费LLM提取记忆 → 向量去重后存入ChromaDB

整篇文章读完，你的Agent就能在每次对话结束时自动把用户偏好、事件、工作流提取出来，下次对话自动加载。成本：¥0。

架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


┌──────────┐ session end ┌──────────────┐
│ 对话记录 │ ──────────────→ │ 已有记忆注入P2 │
└──────────┘ └──────┬───────┘
 │
 ┌──────▼───────┐
 │ 免费LLM提取P0 │
 │ 分类+结构化 │
 └──────┬───────┘
 │
 ┌──────▼───────┐
 │ 向量去重 P1 │
 │ cosine<0.15 │
 └──────┬───────┘
 │
 ┌──────▼───────┐
 │ ChromaDB │
 │ 本地存储 │
 └──────────────┘

三层防护确保不存垃圾、不存重复：

层级	机制	作用
P2 提取前	已有记忆注入prompt	模型直接跳过已知内容
P0 提取中	免费LLM分类提取	persona/episodic/instruction
P1 存入时	ChromaDB向量去重	兜底防重复存储

前置条件

ChromaDB：本地向量数据库，pip install chromadb
免费LLM API Key：在智谱开放平台注册账号，自动获得API Key。GLM-4-Flash模型永久免费，无需绑定支付方式
Python 3.9+

Step 1: 提取Prompt模板

这个prompt是整个系统的灵魂。把它加到你的MemoryProvider插件里：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


EXTRACTION_SYSTEM_PROMPT = (
 '你是一个记忆提取助手。从对话中提取值得长期记住的信息。\n'
 '严格按以下JSON格式输出，不要输出其他任何内容：\n'
 '{"persona":["字符串1","字符串2"],"episodic":["字符串1"],"instruction":["字符串1"]}\n\n'
 '分类规则：\n'
 '- persona: 用户偏好、习惯、身份、性格特征、沟通风格\n'
 '- episodic: 具体事件和行动\n'
 '- instruction: 工作流程、规则、纠正、技术方案\n\n'
 '关键规则：\n'
 '1. 只提取新的、具体的、有价值的信息\n'
 '2. 数组中每个元素必须是纯字符串，不要用对象\n'
 '3. 没有有价值的信息就全部输出空数组\n'
 '4. 每条不超过80字，用简洁陈述句\n'
 '5. 不要重复同一条信息\n'
 '6. 偏好类信息归persona，不要归episodic'
)

为什么这么设计：

temperature: 0.1 + 严格格式约束 → 输出稳定可解析
三分类覆盖了90%以上的记忆类型
“没有有价值的信息就输出空数组” → 避免硬造记忆

Step 2: on_session_end钩子

Session结束时触发提取。关键设计：后台线程异步执行，不阻塞用户。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


import threading
import json

def on_session_end(self, messages):
 # 过滤出user/assistant消息
 conversation_lines = []
 for msg in messages:
 role = msg.get('role', '')
 content = msg.get('content', '')
 if role in ('user', 'assistant') and content:
 prefix = '用户' if role == 'user' else '助手'
 conversation_lines.append(f'{prefix}：{content[:500]}')

 if len(conversation_lines) < 2:
 return # 太短不提取

 conversation_text = '\n'.join(conversation_lines)
 if len(conversation_text) > 4000:
 conversation_text = conversation_text[-4000:] # 截取最近4000字符

 # 预取已有记忆（P2缓存）
 existing_context = self._build_existing_context()

 # 后台线程执行提取
 def _extract():
 self._run_extraction(conversation_text, existing_context)

 threading.Thread(target=_extract, daemon=True).start()

注意几个细节：

每条消息截取500字符 → 控制总量
总文本超过4000字符只取末尾 → 最近的内容最有价值
对话少于2条直接跳过 → 避免无效提取
daemon=True → 主进程退出时不会卡住

Step 3: API调用实现

直接用标准库，不依赖额外包：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


def _run_extraction(self, conversation_text, existing_context=''):
 import urllib.request, urllib.error

 system_prompt = self.EXTRACTION_SYSTEM_PROMPT
 if existing_context:
 system_prompt += f'\n\n已知记忆（不要重复提取这些内容）：\n{existing_context}'

 payload = json.dumps({
 'model': 'glm-4-flash', # 免费模型
 'messages': [
 {'role': 'system', 'content': system_prompt},
 {'role': 'user', 'content': conversation_text},
 ],
 'max_tokens': 800,
 'temperature': 0.1,
 }, ensure_ascii=False).encode('utf-8')

 req = urllib.request.Request(
 'https://open.bigmodel.cn/api/paas/v4/chat/completions',
 data=payload, method='POST'
 )
 req.add_header('Authorization', f'Bearer {self._extract_api_key}')
 req.add_header('Content-Type', 'application/json')

 try:
 with urllib.request.urlopen(req, timeout=30) as resp:
 result = json.loads(resp.read().decode('utf-8'))
 except (urllib.error.URLError, json.JSONDecodeError, KeyError) as e:
 return # 静默失败，不影响主流程

 content = result['choices'][0]['message']['content']
 extracted = self._parse_extraction_json(content)
 self._store_extracted_memories(extracted)

JSON解析加个容错：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


import re

def _parse_extraction_json(self, content):
 """容错解析，处理LLM输出前后可能的多余文本"""
 try:
 return json.loads(content)
 except json.JSONDecodeError:
 # 尝试提取花括号内容
 match = re.search(r'\{[^{}]*\}', content, re.DOTALL)
 if match:
 try:
 return json.loads(match.group())
 except json.JSONDecodeError:
 pass
 return {'persona': [], 'episodic': [], 'instruction': []}

Step 4: 向量去重（P1）

这是防重复的最后防线。即使LLM没看到已有记忆，向量相似度也能拦住：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


_DEDUP_MAX_DISTANCE = 0.15 # ~92%相似度

def _is_duplicate(self, text, wing):
 results = self._col.query(
 query_texts=[text],
 n_results=3,
 where={'wing': wing},
 include=['distances'],
 )
 distances = results.get('distances', [[]])[0]
 return distances and distances[0] < self._DEDUP_MAX_DISTANCE

def _store_extracted_memories(self, extracted):
 import time
 stored = 0
 for category, items in extracted.items():
 wing_map = {
 'persona': 'user',
 'episodic': 'episodic',
 'instruction': 'instruction'
 }
 wing = wing_map.get(category, 'user')
 for item in items:
 if not item or len(item.strip()) < 5:
 continue # 跳过太短的
 if self._is_duplicate(item, wing):
 continue # 跳过重复
 self._col.add(
 documents=[item],
 metadatas=[{
 'wing': wing,
 'room': 'auto-extract',
 'added_by': 'auto-extract',
 'category': category,
 'timestamp': str(int(time.time())),
 }],
 ids=[f'extract_{category}_{int(time.time()*1000)}_{stored}']
 )
 stored += 1

为什么阈值是0.15：

实测数据——

距离阈值	相似度	去重效果	误杀率
0.10	~95%	去重80%	极低
0.15	~92%	去重90%+	<3%
0.20	~88%	去重95%	~8%

0.15是甜点。

Step 5: 已知记忆注入（P2）

在调LLM之前，把已有记忆塞进prompt。这样模型直接跳过已知内容，省token又防重复：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def _build_existing_context(self):
 parts = []
 for wing in ('user', 'instruction'):
 results = self._col.get(
 where={'wing': wing},
 include=['documents', 'metadatas'],
 limit=20
 )
 for doc, meta in zip(results['documents'], results['metadatas']):
 if meta.get('added_by') in ('auto-extract', 'hermes', 'builtin-mirror'):
 parts.append(doc[:100])
 return '；'.join(parts[:15])[:500] if parts else ''

只取最近15条、截断到500字符。控制prompt长度，别把提取请求搞得太贵。

Step 6: 配置和测试

在 mempalace.json 中启用自动提取：

1
2
3
4


{
 "auto_extract": true,
 "extract_model": "glm-4-flash"
}

验证方法

测试1：基本提取

跟Agent说几句话：

1
2
3


用户：我习惯用vim编辑器，不要给我推荐nano
用户：我的项目统一用Python 3.11
用户：代码风格遵循PEP8，docstring用Google风格

结束session，然后检查ChromaDB：

1
2
3
4
5
6


import chromadb
client = chromadb.PersistentClient(path='./mempalace_db')
col = client.get_collection('memories')
results = col.get(where={'added_by': 'auto-extract'}, include=['documents', 'metadatas'])
for doc, meta in zip(results['documents'], results['metadatas']):
 print(f"[{meta['category']}] {doc}")

预期输出类似：

1
2
3


[persona] 用户习惯使用vim编辑器
[instruction] 项目统一使用Python 3.11
[instruction] 代码风格遵循PEP8，docstring用Google风格

测试2：去重验证

同一段对话连续触发两次提取，第二次应该0条新增。

测试3：新session加载

开启新对话，问Agent：“你知道我用什么编辑器吗？"——它应该能从记忆中回答"vim”。

实测效果数据

指标	数据
提取延迟	3-7秒（后台异步，不阻塞）
Token消耗	300-500/次
成本	¥0（GLM-4-Flash免费）
分类准确率	>90%（persona/episodic/instruction）
去重拦截率	90%+（重复对话）
误存率	<2%（无效信息被存入）

三层防护机制总结

再说一遍这个设计，因为它是整个系统可靠性的关键：

1
2
3


P2 提取前：已知记忆注入 → LLM直接跳过 → 省token
P0 提取中：结构化分类 → 只保留有价值信息 → 控质量
P1 存入时：向量相似度去重 → 兜底拦截 → 防重复

三层不是冗余，是互补：

P2漏了（记忆太多超过500字符截断了）→ P1兜底
P1漏了（措辞差异太大向量没拦住）→ P2已经拦了大部分
P0是核心 → 决定提取质量

一句话总结

自动记忆不是奢侈品，是Agent的基础设施。当AI能记住你说过的每一句偏好，你就不需要每次对话都从头开始。

给 AI 装一个本地大脑：MemPalace 实战指南

Thu, 14 May 2026 00:00:00 +0800

你的 AI 助手记不住你上周说过的话。每次对话都像失忆重启。MemPalace 就是来修这个bug的。

一句话介绍

MemPalace 是一个开源的本地记忆系统，把你的项目文件、聊天记录、对话笔记"挖"进一个可搜索的知识宫殿里，让任何 AI 都能瞬间检索到你的历史上下文。

不需要 API Key，不需要云端服务，数据全部存在你自己的机器上。

GitHub: github.com/MemPalace/mempalace

为什么需要它？

大模型的 context window 再大，也装不下你半年的对话记录。你跟 AI 说过的偏好、做过的决策、踩过的坑，下一次对话它全忘了。

传统解法：

RAG 框架（LangChain、LlamaIndex）→ 重，复杂，面向开发者
云端记忆服务（Zep、Mem0）→ 要花钱，数据不在本地
自己写向量数据库 → 谁有那个闲工夫

MemPalace 的思路是：一行命令搞定，开箱即用，本地运行。

核心方法论：宫殿记忆法

MemPalace 借用了古典的"记忆宫殿"概念，把知识按空间结构组织：

1
2
3
4
5


宫殿 (Palace)
├── 侧翼 (Wing) — 项目/领域
│ ├── 房间 (Room) — 主题分类
│ │ ├── 衣柜 (Closet) — 压缩摘要（AAAK格式）
│ │ └── 抽屉 (Drawer) — 原文片段（向量索引）

这不是简单的向量数据库。它有三层结构协同工作：

① 向量索引（ChromaDB）

把每段文本变成向量，支持语义搜索。问"我们为什么换 GraphQL？“能直接定位到当时的讨论，不用记关键词。

② 知识图谱（SQLite）

存储实体关系：谁做了什么、什么时候做的、关系什么时候变了。支持时间过滤——“2025年1月时，Max 在做什么？“这种问题能回答。

③ AAAK 压缩方言

把长文本压缩成结构化符号：实体、情感标记、关键引用、权重标记。任何 LLM 都能直接读懂，不需要解码器。

四层记忆栈

MemPalace 把记忆分为四层，按需加载，不浪费 context：

层级	内容	Token 开销	加载时机
L0	身份（我是谁）	~100	始终
L1	关键事实摘要	~500-800	始终
L2	特定主题/项目	~200-500	按需
L3	全文语义搜索	无上限	按需

唤醒成本仅 600-900 tokens（L0+L1），把 95% 以上的 context 留给真正的对话。你的 128K 窗口不会被记忆塞满。

怎么用？

安装

1

pip install mempalace

导入项目文件

1
2
3
4
5


# 初始化（自动识别目录结构，生成房间）
mempalace init ~/projects/my_app

# 挖掘（把文件内容索引进宫殿）
mempalace mine ~/projects/my_app

MemPalace 会自动扫描目录，按文件夹结构生成 Wing（项目）和 Room（主题），把每个文件按段落切分成 Drawer，存入 ChromaDB。

导入聊天记录

1
2


# 支持 Claude Code、ChatGPT、Slack 导出
mempalace mine ~/.claude/projects/xxx --mode convos --wing my_app

搜索

1
2
3
4
5


# 语义搜索（不用记精确关键词）
mempalace search "为什么选 PostgreSQL 而不是 MongoDB"

# 指定范围
mempalace search "定价讨论" --wing my_app --room costs

唤醒

1
2
3
4
5


# 生成 L0+L1 上下文，注入到 AI 对话开头
mempalace wake-up

# 只唤醒特定项目
mempalace wake-up --wing my_app

压缩

1
2


# 把抽屉压缩成衣柜摘要（约30倍压缩）
mempalace compress

接入 AI 工具

1
2


# MCP 模式——暴露 19 个工具给 Claude Code / Cursor 等
mempalace mcp

支持通过 MCP 协议直接接入 Claude Code、Cursor、Windsurf 等 AI 编码工具，AI 可以自主决定何时搜索记忆。

实测数据

以下是我用 Hermes Agent（一个本地 AI 助手）的实际使用数据：

嵌入模型对比测试（18个中文查询）：

指标	all-MiniLM-L6-v2	Qwen3-Embedding-0.6B
命中率	9/18 (50%)	18/18 (100%)
平均相似度	-0.18	0.60
单次查询耗时	217ms	449ms

换上中文优化模型后，近义词、描述性查询全部命中。Ollama 本地跑 Qwen3-Embedding，不依赖任何外部 API。

OpenClaw（三省六部制 AI 系统）接入：

13 个 Agent 共享同一个 MemPalace 实例
索引了 854 个文件（195 closets + 659 drawers）
每天凌晨自动增量索引
Agent 们通过 mempalace search 检索历史上下文

优点

✅ 零配置起步：pip install + mempalace init + mempalace mine，三行命令跑起来
✅ 完全本地：数据存在你机器上，ChromaDB + SQLite，不需要网络，不需要 API Key
✅ 语义搜索：不是关键词匹配，是理解意思。说"定价讨论"能找到提到"价格策略"的内容
✅ 记忆分层：L0-L3 按需加载，不会撑爆 context window
✅ 多格式支持：项目文件、Claude Code 对话、ChatGPT 导出、Slack 记录都能吃
✅ 知识图谱：有时间线的关系数据库，知道事实"什么时候是真的”
✅ AAAK 压缩：30倍压缩比，任何 LLM 直接读懂
✅ MCP 协议：19个工具暴露给 AI，让 AI 自己管理记忆
✅ 增量索引：mine 命令幂等，只处理新文件，不重复索引
✅ 多实例隔离：支持多个 AI Agent 各用各的宫殿，互不干扰

缺点

⚠️ 嵌入模型依赖：默认用 all-MiniLM-L6-v2，中文效果很差（命中率仅50%）。中文场景必须换模型（如 Qwen3-Embedding），但换模型需要重建整个索引
⚠️ 首次索引慢：大项目首次 mine 比较耗时，尤其本地跑大嵌入模型时。我 854 条数据用 Qwen3-Embedding 跑了近 5 小时（纯 CPU）
⚠️ ChromaDB 限制：不支持多进程并发写入。多 Agent 共享一个宫殿需要做实例隔离，否则会锁冲突
⚠️ 没有内置嵌入模型管理：换模型要自己写脚本重建，没有官方的 migrate 工具（虽然有 mempalace migrate 但只处理 ChromaDB 版本升级）
⚠️ AAAK 压缩是有损的：官方文档明确说不是无损压缩，原文无法从 AAAK 输出还原。压缩前确保原始 Drawer 保留
⚠️ 文档偏少：README 够用，但深入使用（嵌入模型切换、多实例隔离、MCP 高级配置）基本靠读源码
⚠️ 单机方案：没有分布式/同步机制，不适合团队协作场景

适合谁？

个人 AI 助手用户：希望 AI 记住你的偏好、项目历史、重要决策
AI Agent 开发者：给你的 Agent 加一个持久化的长期记忆层
重度 AI 对话用户：积累了大量 ChatGPT/Claude 对话，想建立可检索的档案库
隐私敏感用户：不想把记忆数据上传到任何云端服务

不适合谁？

需要团队协作共享记忆的团队（考虑 Zep/Mem0）
只用 AI 做简单问答，不需要上下文延续
没有本地服务器或不愿意折腾 CLI

技术栈

语言：Python
向量数据库：ChromaDB（本地嵌入式）
知识图谱：SQLite
嵌入模型：可插拔（默认 all-MiniLM-L6-v2，支持 Ollama、OpenAI 兼容 API）
协议：MCP（Model Context Protocol）
协议：MIT 开源

MemPalace v3.3.3 | 作者: milla-jovovich | GitHub: github.com/MemPalace/mempalace

自动记忆提取 (Auto Memory Extraction)

Mon, 01 Jan 0001 00:00:00 +0000

自动记忆提取

定义

AI Agent 在会话结束时自动从对话中提取值得长期记住的信息，分类存入向量数据库，实现跨会话的持久记忆。

核心架构

1
2
3
4
5


对话结束 → on_session_end() → 后台线程
 ├─ P2: 预取已有记忆 → 注入prompt（减少重复提取）
 ├─ P0: 调用LLM提取 → JSON输出(persona/episodic/instruction)
 ├─ P1: 向量去重 → ChromaDB相似度检查
 └─ 存入MemPalace drawers

三类记忆分类

类型	说明	存储wing	示例
persona	用户偏好、习惯、身份	user	喜欢暗色模式
episodic	具体事件和行动	episodic	完成博客主题迁移
instruction	工作流程、规则、方案	instruction	部署前先hugo –minify测试

实施要点

提取模型选择

推荐：GLM-4-Flash — 免费、3-7秒延迟、中文理解好
不推荐GLM-4.7-Flash — 推理模型，28秒延迟
不推荐本地模型 — RAM占用高、15-25秒延迟

去重阈值

ChromaDB cosine distance < 0.15（约92%相似度）
范围：同wing内比较
效果：同对话重复提取90%+被拦截

Prompt Cache（P2）

提取前预取user和instruction wing的已有记忆
注入prompt的"已知记忆"区
上限15条、500字符，避免bloat

配置

1
2
3
4
5
6
7


// mempalace.json
{
 "auto_extract": true,
 "extract_model": "glm-4-flash",
 "extract_base_url": "https://open.bigmodel.cn/api/paas/v4",
 "extract_api_key": "" // 留空则自动从环境变量GLM_API_KEY加载
}

性能指标（实测）

指标	值
提取延迟	3-7秒（后台异步）
Token消耗	300-500/次
成本	¥0（免费模型）
分类准确率	>90%
去重有效率	>90%
预估月成本	<¥0.5（10次/天）

适用场景

有ChromaDB/MemPalace等向量存储的Agent系统
支持MemoryProvider插件架构（on_session_end钩子）
有免费LLM API可用（智谱GLM-4-Flash、Google Gemini Flash等）

扩展方向

记忆分层（未实施）：温/冷/归档，按访问频率衰减。当前20条记忆无需分层，预估到1000+条再评估
知识图谱集成：提取的记忆同步写入KG，支持关系查询
跨Agent共享：多Agent共用同一MemPalace实例