企业AI应用实践合集：企业AI应用实践 系列（63/501）2026-02-04

告别 Moltbook：如何搭建私有的 Agent 知识库

告别 Moltbook：如何搭建私有的 Agent 知识库

Moltbook 的数据泄露让很多人意识到了"数据主权"的重要性。

我们希望 Agent 能记住我们的喜好、历史任务、常用指令。我们希望它越用越懂我们，变成真正的"私人助理"。但我们不希望这些记忆存在别人的服务器上，更不希望这些记忆和 150 万人的数据一起被泄露。

好消息是：OpenClaw 完全可以搭配本地知识库使用。你不需要上传任何数据，也能拥有一个"懂你"的贾维斯。

这篇文章会手把手教你搭建一套私有的 Agent 记忆系统。

为什么需要知识库？

先理解一下问题。

LLM（大语言模型）本身是"无状态"的。每次对话，它都是从零开始。昨天你告诉它你喜欢吃川菜，今天它就忘了。上周你让它帮你整理了一份报告，这周问它要，它一脸懵逼。

解决这个问题的方法是给 Agent 加一个"外部记忆"——知识库。

知识库的工作原理：

  1. 存储：把每次对话、重要信息转换成向量（embedding），存到数据库里
  2. 检索：下次对话时，根据当前话题，从数据库里找出相关的历史信息
  3. 注入：把检索到的信息作为上下文，和当前问题一起发给 LLM

这就是所谓的 RAG（Retrieval-Augmented Generation）。

方案选择：本地向量数据库

市面上有很多向量数据库，我们要选择可以完全本地部署的：

方案 优点 缺点 推荐场景
ChromaDB 轻量、Python 原生、易上手 功能相对简单 个人使用、快速原型
Qdrant 功能强大、性能好、有 Web UI 配置稍复杂 中大规模部署
Milvus 企业级、高性能、分布式 重量级、资源消耗大 大规模生产环境
LanceDB 新项目、嵌入式、零配置 生态较新 嵌入式应用
pgvector PostgreSQL 扩展、熟悉的 SQL 需要 PostgreSQL 已有 PG 的环境

对于个人用户，我推荐 ChromaDB 或 Qdrant。下面分别介绍。

方案一：ChromaDB（最简单）

ChromaDB 是一个轻量级的向量数据库，特别适合 Python 生态。

安装和运行

# 方式一：直接用 Docker
docker run -p 8000:8000 chromadb/chroma

# 方式二：Python 包（嵌入式使用）
pip install chromadb

基础使用示例

import chromadb
from chromadb.config import Settings

# 创建客户端，数据持久化到本地目录
client = chromadb.Client(Settings(
    chroma_db_impl="duckdb+parquet",
    persist_directory="./chroma_data"
))

# 创建或获取一个 collection
collection = client.get_or_create_collection(
    name="agent_memory",
    metadata={"description": "OpenClaw Agent 的记忆存储"}
)

# 添加记忆
def add_memory(content, metadata=None):
    import uuid
    doc_id = str(uuid.uuid4())
    collection.add(
        documents=[content],
        metadatas=[metadata or {}],
        ids=[doc_id]
    )
    return doc_id

# 搜索相关记忆
def search_memory(query, n_results=5):
    results = collection.query(
        query_texts=[query],
        n_results=n_results
    )
    return results

# 示例：存储用户偏好
add_memory(
    "用户喜欢吃川菜，尤其是麻婆豆腐和水煮鱼。不能吃太辣的。",
    metadata={"type": "preference", "category": "food", "date": "2026-02-01"}
)

add_memory(
    "用户的工作是软件工程师，主要使用 Python 和 TypeScript。",
    metadata={"type": "profile", "category": "work", "date": "2026-02-01"}
)

# 示例：检索
results = search_memory("推荐一家餐厅吃饭")
print(results)
# 会返回关于饮食偏好的记忆

持久化配置

# 确保数据持久化
client = chromadb.Client(Settings(
    chroma_db_impl="duckdb+parquet",
    persist_directory="/path/to/your/data",  # 指定持久化目录
    anonymized_telemetry=False  # 关闭遥测
))

# 定期调用 persist() 确保数据写入磁盘
client.persist()

Docker Compose 部署

# docker-compose.yml
version: '3.8'

services:
  chroma:
    image: chromadb/chroma:latest
    container_name: chroma
    ports:
      - "127.0.0.1:8000:8000"
    volumes:
      - ./chroma_data:/chroma/chroma  # 数据持久化
    environment:
      - ANONYMIZED_TELEMETRY=false
    restart: unless-stopped
  
  openclaw:
    image: openclaw/openclaw:latest
    depends_on:
      - chroma
    environment:
      - MEMORY_BACKEND=chroma
      - CHROMA_HOST=chroma
      - CHROMA_PORT=8000
    # ...其他配置

方案二：Qdrant（更强大）

Qdrant 是一个用 Rust 写的向量数据库，性能出色，功能完善。

Docker 部署

docker run -p 6333:6333 -p 6334:6334 \
    -v ./qdrant_data:/qdrant/storage \
    qdrant/qdrant

基础使用示例

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
import uuid

# 连接到 Qdrant
client = QdrantClient(host="localhost", port=6333)

# 创建 collection
client.create_collection(
    collection_name="agent_memory",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
    # 1536 是 OpenAI text-embedding-ada-002 的维度
)

# 生成 embedding（使用 OpenAI 或本地模型）
def get_embedding(text):
    import openai
    response = openai.Embedding.create(
        model="text-embedding-ada-002",
        input=text
    )
    return response['data'][0]['embedding']

# 添加记忆
def add_memory(content, metadata=None):
    point_id = str(uuid.uuid4())
    embedding = get_embedding(content)
    
    client.upsert(
        collection_name="agent_memory",
        points=[
            PointStruct(
                id=point_id,
                vector=embedding,
                payload={
                    "content": content,
                    **(metadata or {})
                }
            )
        ]
    )
    return point_id

# 搜索
def search_memory(query, limit=5):
    query_embedding = get_embedding(query)
    
    results = client.search(
        collection_name="agent_memory",
        query_vector=query_embedding,
        limit=limit
    )
    
    return [
        {
            "content": hit.payload["content"],
            "score": hit.score,
            "metadata": {k: v for k, v in hit.payload.items() if k != "content"}
        }
        for hit in results
    ]

使用本地 Embedding 模型

如果你不想把文本发给 OpenAI 来生成 embedding，可以用本地模型：

from sentence_transformers import SentenceTransformer

# 加载本地模型
model = SentenceTransformer('all-MiniLM-L6-v2')  # 384 维
# 或者中文模型
# model = SentenceTransformer('shibing624/text2vec-base-chinese')

def get_local_embedding(text):
    return model.encode(text).tolist()

# 注意：创建 collection 时要改成对应的维度
client.create_collection(
    collection_name="agent_memory",
    vectors_config=VectorParams(size=384, distance=Distance.COSINE)
)

Docker Compose 完整配置

version: '3.8'

services:
  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant
    ports:
      - "127.0.0.1:6333:6333"  # REST API
      - "127.0.0.1:6334:6334"  # gRPC
    volumes:
      - ./qdrant_data:/qdrant/storage
    environment:
      - QDRANT__SERVICE__GRPC_PORT=6334
    restart: unless-stopped
  
  openclaw:
    image: openclaw/openclaw:latest
    depends_on:
      - qdrant
    environment:
      - MEMORY_BACKEND=qdrant
      - QDRANT_HOST=qdrant
      - QDRANT_PORT=6333
    volumes:
      - ./data:/app/data
    ports:
      - "127.0.0.1:3000:3000"
    restart: unless-stopped

与 OpenClaw 集成

假设 OpenClaw 支持自定义记忆后端（或者你可以修改代码），以下是集成思路：

# memory_adapter.py - OpenClaw 的记忆适配器

class LocalMemoryAdapter:
    def __init__(self, backend="chroma"):
        if backend == "chroma":
            import chromadb
            self.client = chromadb.Client(...)
            self.collection = self.client.get_or_create_collection("agent_memory")
        elif backend == "qdrant":
            from qdrant_client import QdrantClient
            self.client = QdrantClient(...)
    
    def store(self, content, metadata=None):
        """存储一条记忆"""
        # ...
    
    def recall(self, query, limit=5):
        """检索相关记忆"""
        # ...
    
    def forget(self, memory_id):
        """删除一条记忆"""
        # ...
    
    def summarize_and_compress(self):
        """定期总结和压缩旧记忆"""
        # 防止记忆库无限增长
        # ...


# 在 OpenClaw 的配置中使用
# config.json
{
  "memory": {
    "enabled": true,
    "backend": "local",
    "adapter": "memory_adapter.LocalMemoryAdapter",
    "options": {
      "backend": "qdrant",
      "host": "localhost",
      "port": 6333
    }
  }
}

记忆管理最佳实践

1. 分类存储

不要把所有东西混在一起。按类型分 collection：

collections = {
    "conversations": "对话历史",
    "user_preferences": "用户偏好",
    "knowledge": "知识库（文档、笔记）",
    "tasks": "任务记录",
    "feedback": "用户反馈"
}

for name, description in collections.items():
    client.get_or_create_collection(
        name=name,
        metadata={"description": description}
    )

2. 设置 TTL（过期时间）

旧的记忆可能不再相关，设置过期机制：

import time

def add_memory_with_ttl(content, ttl_days=30):
    expiry = time.time() + ttl_days * 86400
    add_memory(content, metadata={"expiry": expiry})

def cleanup_expired():
    # 定期清理过期记忆
    current_time = time.time()
    # 查询并删除过期的记录
    # ...

3. 定期备份

#!/bin/bash
# backup_memory.sh

BACKUP_DIR="/backup/agent_memory"
DATE=$(date +%Y%m%d_%H%M%S)

# 停止服务（可选，确保数据一致性）
docker-compose stop qdrant

# 备份数据目录
tar -czvf "${BACKUP_DIR}/qdrant_${DATE}.tar.gz" ./qdrant_data

# 重启服务
docker-compose start qdrant

# 保留最近 7 天的备份
find ${BACKUP_DIR} -name "qdrant_*.tar.gz" -mtime +7 -delete

echo "Backup completed: qdrant_${DATE}.tar.gz"

加入 crontab：

# 每天凌晨 3 点备份
0 3 * * * /path/to/backup_memory.sh >> /var/log/memory_backup.log 2>&1

4. 加密敏感记忆

对于特别敏感的信息，存储前先加密：

from cryptography.fernet import Fernet

# 生成密钥并安全保存
key = Fernet.generate_key()
cipher = Fernet(key)

def add_encrypted_memory(content, is_sensitive=False):
    if is_sensitive:
        encrypted = cipher.encrypt(content.encode()).decode()
        add_memory(encrypted, metadata={"encrypted": True})
    else:
        add_memory(content, metadata={"encrypted": False})

def search_and_decrypt(query, limit=5):
    results = search_memory(query, limit)
    for result in results:
        if result.get("metadata", {}).get("encrypted"):
            result["content"] = cipher.decrypt(result["content"].encode()).decode()
    return results

完整的部署示例

# docker-compose.yml
version: '3.8'

services:
  # 向量数据库
  qdrant:
    image: qdrant/qdrant:latest
    container_name: agent-memory
    ports:
      - "127.0.0.1:6333:6333"
    volumes:
      - qdrant_data:/qdrant/storage
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:6333/"]
      interval: 30s
      timeout: 10s
      retries: 3
  
  # Embedding 服务（可选，如果用本地模型）
  embedding:
    image: ghcr.io/huggingface/text-embeddings-inference:cpu-1.0
    container_name: embedding-service
    ports:
      - "127.0.0.1:8080:80"
    volumes:
      - embedding_cache:/data
    environment:
      - MODEL_ID=BAAI/bge-small-en-v1.5
    restart: unless-stopped
  
  # OpenClaw
  openclaw:
    image: openclaw/openclaw:latest
    container_name: openclaw
    depends_on:
      - qdrant
      - embedding
    ports:
      - "127.0.0.1:3000:3000"
    volumes:
      - openclaw_data:/app/data
      - ./config:/app/config:ro
    environment:
      - MEMORY_ENABLED=true
      - QDRANT_URL=http://qdrant:6333
      - EMBEDDING_URL=http://embedding:80
    restart: unless-stopped

volumes:
  qdrant_data:
  embedding_cache:
  openclaw_data:

总结

搭建私有知识库的要点：

  1. 选择合适的向量数据库：个人用户推荐 ChromaDB 或 Qdrant
  2. 数据永不离开本地：配置持久化目录，绑定到 localhost
  3. 考虑使用本地 Embedding：避免把文本发给 OpenAI
  4. 做好备份：定期备份数据目录
  5. 必要时加密：敏感信息存储前先加密

这样做的体验差异几乎为零，但安全性天差地别。你的 Agent 依然聪明，记得你上次让它写的代码风格，记得你讨厌吃香菜。但这些信息物理上从未离开过你的控制范围。

对于那些敏感的笔记、代码片段、私人对话，本地知识库是唯一的归宿。既然选择了 Local Agent 这条路，那就把"Local"贯彻到底吧。Moltbook 的悲剧，不应该在你身上重演。

合集导航回到合集目录 →
上一章
← 你的 Agent 真的需要 Root 权限吗？聊聊 Docker 权限管理
下一章
网络层防御：用 Cloudflare Tunnel 给 OpenClaw 加把锁 →
← 返回博客列表