我把 4176 个商业判断点做成 RAG 决策引擎后

⛏️ 模块 7：知识原子挖矿

我把 4176 个商业判断点做成 RAG 决策引擎后

——用 atoms.jsonl + RAG 技术，把 4,176 个商业判断点变成你的「可查询决策引擎」

写在前面：为什么你的「知识积累」没有产生「判断力」？

先做一个测试。

你已经读了很多书、做了很多笔记、用过很多框架。现在有一个真实的商业决策摆在你面前：

「我要不要接这个客户？他愿意付钱，但要求定制开发，账期 60 天。」

你的系统能在 60 秒内给你一个有依据的判断吗？

不是「让我想想」，不是「感觉不太对」，而是：「根据我积累的知识，这个情况符合哪种已知模式，历史上这种模式的结果是什么，我应该注意哪些信号？」

大多数人做不到。

不是因为他们知识不够多，而是因为他们的知识是**「存进去的」，不是「可检索的」**。

笔记在 Obsidian 里，但要用的时候想不起来找。书中的框架在脑子里，但面对具体场景时想不起来用。诊断工具用过，但历史案例没有被结构化存储，无法在下次遇到相似情况时自动触发。

这就是「知识积累」和「判断力」之间那道墙的本质：检索能力的缺失。

模块 7 要解决的，就是这道墙。

把 知识库/原子库/atoms.jsonl 导入你的向量数据库，4,176 条结构化知识点，自带主题标签，天然适合检索。这不只是在说一个技术操作，而是在说一种新的知识使用方式——从「我记得读过」到「系统帮我找到」。

一、理解 atoms.jsonl：这不是普通的知识库

1.1 原子库的来源与规模

dbskill 的知识库是完全开放的，你不需要安装整套 Skill 才能用——可以只拿走你需要的部分。 1 ^[1] 知识库的完整目录结构是：知识库/原子库/atoms.jsonl（4,176 个知识原子，全量），atoms_2024Q4.jsonl、atoms_2025Q1.jsonl 等按季度拆分的文件。

按季度分布：

2024Q4：740 条，2025Q1：586 条，2025Q2：742 条，2025Q3：689 条，2025Q4：665 条。

每个季度的原子，反映的是那个时段被验证过的商业判断——不是理论推演，是从真实推文和实际案例中提炼的经验。

1.2 完整的知识库目录

知识库的完整结构包括：原子库（结构化知识数据库）和 Skill 知识包（提炼后的方法论文档），Skill 知识包包含：diagnosis_公理与诊断框架.md、diagnosis_问题消解案例库.md、benchmark_对标方法论.md、benchmark_平台运营知识.md、content_内容创作方法论.md、content_平台特性与案例.md、action_心理诊断框架.md、action_信号案例库.md、deconstruct_语言与概念框架.md、deconstruct_解构案例库.md，以及高频概念词典.md。

两个层次，两种用途：

text

知识库/
├── 原子库/              ← 用于 RAG 检索（结构化数据）
│   ├── atoms.jsonl      ← 全量（本模块重点）
│   ├── atoms_2024Q4.jsonl
│   ├── atoms_2025Q1.jsonl
│   └── README.md        ← 字段说明
│
└── Skill知识包/         ← 用于 System Prompt 注入（方法论文档）
    ├── diagnosis_公理与诊断框架.md   ← 6条公理+消解漏斗
    ├── diagnosis_问题消解案例库.md
    ├── action_心理诊断框架.md
    └── ...（共12个方法论文档）

关键区分：

两者配合，才是完整的「商业判断引擎」——方法论告诉 AI 怎么思考，原子库给 AI 提供具体案例和判断依据。

1.3 单个原子的完整结构解析

atoms.jsonl 中每个原子的结构示例是：{"id": "2024Q4_042", "knowledge": "判断一个生意能不能做，必要条件之一是你能不能说出这个产品的颜色", "original": "判断一个生意能不能做，必要条件之一是你能不能说出这个产品的颜色...", "url": "https://x.com/dontbesilent/status/..."}

完整的字段结构（基于 README.md 说明）：

JSON

{
  "id": "2024Q4_042",
  "knowledge": "提炼后的核心洞见（简洁版，适合向量化）",
  "original": "原始推文的完整文字（保留语境）",
  "url": "https://x.com/dontbesilent/status/...",
  "topics": ["商业模式与定价", "需求判断"],
  "skills": ["dbs-diagnosis", "dbs-deconstruct"],
  "type": "insight",
  "confidence": "high"
}

每个字段的实际作用：

1.4 四种原子类型的深度理解

type 字段是原子库最重要的分类维度，直接决定你如何使用检索到的原子：

text

type: "insight"       → 正向洞见（某件事是什么，怎么做是对的）
type: "anti-pattern"  → 反模式（什么做法会失败，为什么）
type: "framework"     → 可操作框架（步骤、公式、决策树）
type: "case"          → 真实案例（有具体场景和结果的案例）

只看 type: "case" 或 type: "anti-pattern" 的原子，大约有 700+ 条真实商业案例和反面案例。

四种类型的实际用途：

二、知识库的三种使用方式

不需要安装整套 Skill 才能用，可以只拿走你需要的部分。具体有三种模式：

模式 A：System Prompt 注入（最轻量）

把 知识库/Skill知识包/diagnosis_公理与诊断框架.md 的内容粘贴到你的 system prompt 里，你的 AI 就有了 6 条公理 + 消解漏斗。

适用场景：不想搭建任何技术基础设施，但想让 AI 按照 dbskill 的方法论思考。

Bash

# 在任意 AI 工具里（ChatGPT、Claude、Kimi等）
# 把以下文件的内容粘贴到 System Prompt：
cat ~/.claude/skills/dbskill/知识库/Skill知识包/diagnosis_公理与诊断框架.md
# 之后你的 AI 就会用 dbskill 的诊断逻辑回答问题
# 不需要 Claude Code，任何 AI 都可以

模式 B：直接过滤查询（中等复杂度）

用 jq 对 atoms.jsonl 做精确过滤，不需要向量数据库，适合一次性的深度研究。

模式 C：RAG 向量检索（完整方案）

把 知识库/原子库/atoms.jsonl 导入你的向量数据库，用 Skill 知识包里的方法论作为 system prompt，用原子库做 RAG 增强，不需要安装 Claude Code。

适用场景：想要构建一个持久化的「个人商业判断引擎」，每次提问自动召回最相关的原子。

本模块三种模式都会讲，从易到难，你可以根据自己的技术背景选择深度。

三、课节 7-1：读懂 atoms.jsonl 的结构

Step 0：获取原子库

Bash

# 如果已安装 dbskill
ls ~/.claude/skills/dbskill/知识库/原子库/
# → 应看到 atoms.jsonl、atoms_2024Q4.jsonl 等文件
# 如果没有安装，单独克隆知识库
git clone https://github.com/dontbesilent2025/dbskill.git ~/dbskill-local
cd ~/dbskill-local/知识库/原子库/
# 查看文件大小
wc -l atoms.jsonl
# → 4176（每行一个原子）

Step 1：安装 jq，开始精确过滤

jq 是 JSON 命令行处理器，是解析 atoms.jsonl 的最简单工具：

Bash

# macOS
brew install jq
# Ubuntu/Debian
apt-get install jq
# 验证安装
jq --version

Step 2：基础查询操作

操作 A：查看第一个原子的完整结构

Bash

head -1 atoms.jsonl | jq '.'

操作 B：按类型过滤——只看反模式

Bash

cat atoms.jsonl | \
  jq 'select(.type == "anti-pattern")' | \
  head -20

操作 C：按主题过滤——只看「定价」相关原子

Bash

cat atoms.jsonl | \
  jq 'select(.topics[] | contains("定价"))' | \
  jq '{id, knowledge, type}'

操作 D：按关联 Skill 过滤——找所有 dbs-diagnosis 使用的原子

Bash

cat atoms.jsonl | \
  jq 'select(.skills[] | contains("dbs-diagnosis"))' | \
  jq '{id, knowledge, confidence}' | \
  head -30

操作 E：只看高置信度的原子

Bash

cat atoms.jsonl | \
  jq 'select(.confidence == "high")' | \
  jq '.knowledge' | \
  head -20

操作 F：组合过滤——高置信度的商业模式反模式

Bash

cat atoms.jsonl | \
  jq 'select(
    .confidence == "high" and
    .type == "anti-pattern" and
    (.topics[] | contains("商业模式"))
  )' | \
  jq '{id, knowledge}'

Step 3：统计分析——了解原子库的全貌

Bash

# 统计各类型原子数量
echo "=== 按类型统计 ==="
cat atoms.jsonl | \
  jq -r '.type' | \
  sort | uniq -c | sort -rn
# 统计各置信度分布
echo "=== 按置信度统计 ==="
cat atoms.jsonl | \
  jq -r '.confidence' | \
  sort | uniq -c | sort -rn
# 提取所有主题标签，统计频率
echo "=== Top 20 高频主题 ==="
cat atoms.jsonl | \
  jq -r '.topics[]' | \
  sort | uniq -c | sort -rn | \
  head -20
# 统计各季度原子数量
echo "=== 按季度统计 ==="
cat atoms.jsonl | \
  jq -r '.id' | \
  grep -o '20[0-9][0-9]Q[1-4]' | \
  sort | uniq -c

预期输出示例：

text

=== 按类型统计 ===
2100 insight
  780 anti-pattern
  740 case
  556 framework
=== 按置信度统计 ===
2890 high
1050 medium
 236 low
=== Top 20 高频主题 ===
 890 商业模式与定价
 720 用户需求与痛点
 680 执行力与心理
 560 内容创作与分发
 480 流量与变现
 ...

Step 4：建立「每日原子阅读」工作流

Bash

# 创建每日随机阅读脚本
cat > ~/scripts/daily-atom.sh << 'EOF'
#!/bin/bash
ATOMS_FILE="$HOME/.claude/skills/dbskill/知识库/原子库/atoms.jsonl"
DATE=$(date +%Y-%m-%d)
WEEKDAY=$(date +%u)  # 1=周一 ... 7=周日
echo "═══════════════════════════════════════"
echo "📖 今日原子阅读 · $DATE"
echo "═══════════════════════════════════════"
# 根据星期选择不同类型
case $WEEKDAY in
  1|2) TYPE="insight" ;;    # 周一二：洞见
  3|4) TYPE="anti-pattern" ;; # 周三四：反模式
  5)   TYPE="framework" ;;  # 周五：框架
  6|7) TYPE="case" ;;       # 周末：案例
esac
echo "📌 今日类型：$TYPE"
echo ""
# 随机抽取3个原子
cat "$ATOMS_FILE" | \
  jq -c "select(.type == \"$TYPE\" and .confidence == \"high\")" | \
  shuf | head -3 | \
  jq -r '"─────────────────────────────\n原子 ID: \(.id)\n\n\(.knowledge)\n\n来源: \(.url // "内部原子")\n"'
echo "═══════════════════════════════════════"
EOF
chmod +x ~/scripts/daily-atom.sh
# 运行测试
~/scripts/daily-atom.sh

把每日原子阅读写入 Obsidian：

Bash

# 读3个原子，写入今日笔记
~/scripts/daily-atom.sh | \
  obsidian daily:append content="$(cat)"

四、课节 7-2：用原子库做 RAG 知识问答

这是本模块的核心技术实践。

RAG（检索增强生成）是一种让大型语言模型能够从外部数据源中检索并整合新信息的技术。使用 RAG，LLM 首先参考一组指定的文档，然后再响应用户查询。

4.1 为什么 atoms.jsonl 是理想的 RAG 语料？

传统 RAG 面临的最大问题是：6 ^[2]查询通常在寻找语料块中的特定信息片段，而语料块的嵌入表示可以看作是其中所有不同信息片段的平均表示。同一个语料块中的不同信息往往是不同的，这可能导致查询嵌入与目标语料块嵌入之间的距离变大。

atoms.jsonl 天然解决了这个问题——每个原子本身就是最小信息单元，不需要再做 chunking（分块）处理。每个原子的 knowledge 字段：

• 长度控制在 50-200 字

• 只包含一个核心洞见

• 自带 topics 标签，可以做混合检索（向量 + 关键词）

原子化检索的核心逻辑是：将语料块文本划分为一组原子陈述，然后将查询嵌入与原子嵌入进行比较，最接近的原子嵌入用于识别要检索的对应内容。

atoms.jsonl 已经完成了这一步——你不需要自己做原子化，直接用就是了。

4.2 方案 A：轻量 RAG（ChromaDB + Python，无需服务器）

ChromaDB 是本地化向量数据库，无需服务器，适合个人使用。

环境安装：

Bash

pip install chromadb anthropic python-dotenv tqdm

Step 1：构建向量索引

Python

# build_atoms_index.py
import json
import chromadb
from chromadb.utils import embedding_functions
from tqdm import tqdm
# 初始化 ChromaDB（本地存储）
client = chromadb.PersistentClient(
    path=os.path.expanduser("~/.atom-rag/chroma-db")
)
# 使用 sentence-transformers 做中文嵌入
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="paraphrase-multilingual-MiniLM-L12-v2"  # 支持中文的多语言模型
)
# 创建集合
collection = client.get_or_create_collection(
    name="dbskill_atoms",
    embedding_function=embedding_fn,
    metadata={"description": "dbskill 知识原子库"}
)
# 加载 atoms.jsonl
atoms_path = os.path.expanduser(
    "~/.claude/skills/dbskill/知识库/原子库/atoms.jsonl"
)
atoms = []
with open(atoms_path, 'r', encoding='utf-8') as f:
    for line in f:
        atom = json.loads(line.strip())
        atoms.append(atom)
print(f"总计加载 {len(atoms)} 个原子")
# 批量插入向量数据库
BATCH_SIZE = 100
for i in tqdm(range(0, len(atoms), BATCH_SIZE), desc="构建索引"):
    batch = atoms[i:i+BATCH_SIZE]

    collection.add(
        ids=[a['id'] for a in batch],
        documents=[a['knowledge'] for a in batch],  # 向量化 knowledge 字段
        metadatas=[{
            'type': a.get('type', 'unknown'),
            'confidence': a.get('confidence', 'medium'),
            'topics': ','.join(a.get('topics', [])),
            'skills': ','.join(a.get('skills', [])),
            'url': a.get('url', ''),
            'original': a.get('original', '')[:500]  # 截断避免过长
        } for a in batch]
    )
print(f"✅ 索引构建完成！共 {collection.count()} 个原子已向量化")

Bash

# 执行索引构建（首次运行约 3-5 分钟）
python build_atoms_index.py

Step 2：构建查询引擎

Python

# query_atoms.py
import chromadb
from chromadb.utils import embedding_functions
import anthropic
import json
import sys
# ─── 初始化 ───────────────────────────────────────
client = chromadb.PersistentClient(
    path=os.path.expanduser("~/.atom-rag/chroma-db")
)
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="paraphrase-multilingual-MiniLM-L12-v2"
)
collection = client.get_collection(
    name="dbskill_atoms",
    embedding_function=embedding_fn
)
claude = anthropic.Anthropic()
# ─── 核心查询函数 ──────────────────────────────────
def query_atoms(
    question: str,
    n_results: int = 8,
    filter_type: str = None,
    filter_confidence: str = None
):
    """
    从原子库检索相关原子，并用 Claude 生成有依据的回答
    """

    # 构建过滤条件
    where = {}
    if filter_type:
        where["type"] = filter_type
    if filter_confidence:
        where["confidence"] = filter_confidence

    # 向量检索
    results = collection.query(
        query_texts=[question],
        n_results=n_results,
        where=where if where else None,
        include=['documents', 'metadatas', 'distances']
    )

    # 格式化检索到的原子
    retrieved_atoms = []
    for i, (doc, meta, dist) in enumerate(zip(
        results['documents'][0],
        results['metadatas'][0],
        results['distances'][0]
    )):
        atom_text = f"""
原子 {i+1}（相关度：{1-dist:.2f}）
类型：{meta['type']} | 置信度：{meta['confidence']}
主题：{meta['topics']}
核心洞见：{doc}
来源：{meta.get('url', '无')}
"""
        retrieved_atoms.append(atom_text)

    atoms_context = "\n---\n".join(retrieved_atoms)

    # 加载方法论 System Prompt
    with open(
        os.path.expanduser(
            "~/.claude/skills/dbskill/知识库/Skill知识包/diagnosis_公理与诊断框架.md"
        ), 'r'
    ) as f:
        methodology = f.read()

    # 构建 RAG 提示
    system_prompt = f"""你是一个商业判断助手。
你的回答必须：
1. 严格基于下方「检索到的知识原子」中的内容
2. 用 dontbesilent 的诊断方法论来组织答案（方法论见下方）
3. 每个核心判断，都要标注来自哪个原子（用原子编号）
4. 如果检索到的原子不足以回答问题，直接说「当前原子库中没有足够的依据」
=== 诊断方法论 ===
{methodology[:2000]}  # 截取关键部分
=== 检索到的知识原子 ===
{atoms_context}
"""

    # 调用 Claude 生成回答
    response = claude.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=2000,
        system=system_prompt,
        messages=[{"role": "user", "content": question}]
    )

    return {
        'question': question,
        'answer': response.content[0].text,
        'atoms_used': len(retrieved_atoms),
        'retrieved_atoms': retrieved_atoms
    }
# ─── 命令行接口 ────────────────────────────────────
if __name__ == "__main__":
    question = " ".join(sys.argv[1:]) if len(sys.argv) > 1 else \
               input("请输入你的问题：")

    print(f"\n🔍 检索问题：{question}\n")

    result = query_atoms(question, n_results=8)

    print("═══════════════════════════════════════")
    print("💡 基于原子库的判断：")
    print("═══════════════════════════════════════")
    print(result['answer'])
    print(f"\n📚 共参考了 {result['atoms_used']} 个知识原子")

Bash

# 测试查询
python query_atoms.py "要不要接一个要求定制开发、账期60天的客户？"

输出示例：

text

═══════════════════════════════════════
💡 基于原子库的判断：
═══════════════════════════════════════
基于检索到的 8 个相关原子，以下是判断依据：
【信号识别】
原子3（insight，高置信度）指出：「定制开发」通常意味着
你在用自己的时间和资源补贴客户的特殊需求——
除非定制费远超标准产品，否则这是一笔隐形亏损。
原子6（anti-pattern，高置信度）揭示了一个常见陷阱：
「账期60天」对于服务型生意是系统性风险——
资金占用成本往往被创业者低估，实际成本是账面价格的1.2-1.5倍。
【消解漏斗】
在回答「要不要接」之前，应先消解以下问题：
1. 这个定制化需求有没有可能变成标准产品？
2. 如果60天账期，你的现金流能撑多久？
3. 这个客户的续约/推荐概率是多少？
【判断】
基于原子1的框架：
「印钞机检验」→ 这个客户能不能自动续约、自动带来新客户？
如果不能，定制+长账期的组合几乎必然是一笔亏钱的好生意。
📚 共参考了 8 个知识原子

Step 3：专项查询模式

针对不同场景，建立专项查询函数：

Python

# specialized_queries.py
def find_anti_patterns(scenario: str):
    """专找这个场景的反模式——避坑用"""
    return query_atoms(
        question=f"在「{scenario}」这个场景下，最常见的错误和陷阱是什么？",
        n_results=6,
        filter_type="anti-pattern",
        filter_confidence="high"
    )
def find_frameworks(problem: str):
    """专找解决某类问题的框架"""
    return query_atoms(
        question=f"如何处理「{problem}」？有没有可操作的框架或步骤？",
        n_results=5,
        filter_type="framework"
    )
def find_similar_cases(situation: str):
    """找类似情况的真实案例"""
    return query_atoms(
        question=f"有没有「{situation}」类似情况的真实案例和结果？",
        n_results=6,
        filter_type="case"
    )
def challenge_assumption(assumption: str):
    """挑战你的假设——找反直觉洞见"""
    return query_atoms(
        question=f"关于「{assumption}」，有什么反直觉的判断或洞见？",
        n_results=8,
        filter_type="insight"
    )
# 使用示例
if __name__ == "__main__":
    # 避坑：接定制客户的陷阱
    print(find_anti_patterns("接定制开发客户")['answer'])

    # 找框架：如何定价
    print(find_frameworks("知识付费产品定价")['answer'])

    # 找案例：账期风险
    print(find_similar_cases("服务型生意账期管理")['answer'])

    # 挑战假设：「用户越多越好」
    print(challenge_assumption("用户越多越好")['answer'])

4.3 方案 B：混合检索（向量 + 关键词，精度更高）

为每个文档添加元数据，例如来源、作者、最后修改日期和置信度评分。这些元数据就像知识库的 DNA，实现精确过滤和面向未来的扩展。

atoms.jsonl 自带的 topics 字段，天然支持混合检索——向量检索找「语义相似」，关键词过滤找「主题精确」：

Python

def hybrid_query(
    question: str,
    required_topics: list = None,    # 精确匹配的主题
    required_skills: list = None,    # 必须关联的 skill
    n_results: int = 8,
    min_confidence: str = "medium"
):
    """
    混合检索：向量相似度 + 元数据精确过滤
    """
    # 构建复合过滤条件
    where_conditions = []

    if min_confidence == "high":
        where_conditions.append({"confidence": "high"})

    # ChromaDB 的元数据过滤（基于字符串匹配）
    # topics 存储为逗号分隔的字符串
    if required_topics:
        for topic in required_topics:
            where_conditions.append(
                {"topics": {"$contains": topic}}
            )

    where = {"$and": where_conditions} if len(where_conditions) > 1 \
            else where_conditions[0] if where_conditions else None

    results = collection.query(
        query_texts=[question],
        n_results=n_results,
        where=where
    )

    return results
# 使用示例：只找「定价 + 商业模式」主题，且置信度高的原子
results = hybrid_query(
    question="知识付费如何定价才不会后悔？",
    required_topics=["定价"],
    min_confidence="high"
)

五、合并你的原子库与 dbskill 原子库

这是本模块最进阶、也最有个人价值的步骤——把你从模块 1-6 中积累的个人原子，和 dbskill 的 4,176 个原子合并成一个统一的 RAG 知识库。

Step 1：把 Obsidian 原子笔记转化为 atoms.jsonl 格式

Python

# obsidian_to_atoms.py
import os
import json
import yaml
import re
from datetime import date
ATOMS_DIR = os.path.expanduser("~/Documents/My-Vault/02-Skills/atoms/")
OUTPUT_FILE = os.path.expanduser("~/.atom-rag/my_atoms.jsonl")
def parse_obsidian_atom(filepath: str) -> dict:
    """解析 Obsidian 原子笔记，转化为 atoms.jsonl 格式"""
    with open(filepath, 'r', encoding='utf-8') as f:
        content = f.read()

    # 提取 frontmatter
    fm_match = re.match(r'^---\n(.*?)\n---\n(.*)', content, re.DOTALL)
    if not fm_match:
        return None

    try:
        frontmatter = yaml.safe_load(fm_match.group(1))
        body = fm_match.group(2)
    except:
        return None

    # 提取「核心观点」段落
    core_match = re.search(
        r'## 核心观点（一句话）\n(.*?)(?=\n##|\Z)',
        body, re.DOTALL
    )
    knowledge = core_match.group(1).strip() if core_match else \
                body[:100].strip()

    # 提取「展开说明」
    expand_match = re.search(
        r'## 展开说明\n(.*?)(?=\n##|\Z)',
        body, re.DOTALL
    )
    original = expand_match.group(1).strip() if expand_match else knowledge

    # 构建标准原子格式
    atom = {
        "id": frontmatter.get('id', f"MY_{date.today().strftime('%Y%m')}_{os.path.basename(filepath)[:8]}"),
        "knowledge": knowledge,
        "original": original,
        "url": "",
        "topics": frontmatter.get('topics', []),
        "skills": frontmatter.get('skills', []),
        "type": frontmatter.get('atom-type', 'insight'),
        "confidence": frontmatter.get('confidence', 'medium'),
        "source": frontmatter.get('source', '个人提炼'),
        "is_personal": True  # 标记为个人原子，区别于 dbskill 原子
    }

    return atom
# 批量处理所有 Obsidian 原子笔记
personal_atoms = []
for filename in os.listdir(ATOMS_DIR):
    if filename.endswith('.md'):
        filepath = os.path.join(ATOMS_DIR, filename)
        atom = parse_obsidian_atom(filepath)
        if atom:
            personal_atoms.append(atom)
print(f"提取了 {len(personal_atoms)} 个个人原子")
# 写入 my_atoms.jsonl
with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
    for atom in personal_atoms:
        f.write(json.dumps(atom, ensure_ascii=False) + '\n')
print(f"已保存到 {OUTPUT_FILE}")

Step 2：合并个人原子 + dbskill 原子，重建统一索引

Python

# merge_and_rebuild.py
import json
import chromadb
from chromadb.utils import embedding_functions
DBSKILL_ATOMS = os.path.expanduser(
    "~/.claude/skills/dbskill/知识库/原子库/atoms.jsonl"
)
PERSONAL_ATOMS = os.path.expanduser("~/.atom-rag/my_atoms.jsonl")
client = chromadb.PersistentClient(
    path=os.path.expanduser("~/.atom-rag/chroma-db-merged")
)
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="paraphrase-multilingual-MiniLM-L12-v2"
)
# 删除旧集合，重建
try:
    client.delete_collection("merged_atoms")
except:
    pass
collection = client.create_collection(
    name="merged_atoms",
    embedding_function=embedding_fn
)
def load_and_insert(filepath, source_tag):
    atoms = []
    with open(filepath, 'r', encoding='utf-8') as f:
        for line in f:
            try:
                atom = json.loads(line.strip())
                atom['source_tag'] = source_tag  # 标记来源
                atoms.append(atom)
            except:
                continue

    BATCH_SIZE = 100
    for i in range(0, len(atoms), BATCH_SIZE):
        batch = atoms[i:i+BATCH_SIZE]
        collection.add(
            ids=[f"{source_tag}_{a['id']}" for a in batch],
            documents=[a['knowledge'] for a in batch],
            metadatas=[{
                'type': a.get('type', 'insight'),
                'confidence': a.get('confidence', 'medium'),
                'topics': ','.join(a.get('topics', [])) \
                          if isinstance(a.get('topics'), list) \
                          else str(a.get('topics', '')),
                'source_tag': source_tag,
                'is_personal': str(a.get('is_personal', False))
            } for a in batch]
        )

    print(f"✅ {source_tag}：插入 {len(atoms)} 个原子")
    return len(atoms)
# 分别插入
n_dbskill = load_and_insert(DBSKILL_ATOMS, "dbskill")
n_personal = load_and_insert(PERSONAL_ATOMS, "personal")
print(f"\n📊 合并知识库统计：")
print(f"   dbskill 原子：{n_dbskill}")
print(f"   个人原子：   {n_personal}")
print(f"   总计：      {collection.count()}")

Step 3：在查询时区分来源，建立「个人判断 vs 系统判断」对比

Python

def compare_query(question: str):
    """
    对同一个问题，分别从 dbskill 原子和个人原子中检索，
    对比两者的判断——找到共鸣点和分歧点
    """

    # dbskill 原子的判断
    dbskill_results = collection.query(
        query_texts=[question],
        n_results=5,
        where={"source_tag": "dbskill"}
    )

    # 个人原子的判断
    personal_results = collection.query(
        query_texts=[question],
        n_results=5,
        where={"source_tag": "personal"}
    )

    print("═══ dbskill 视角 ═══")
    for doc in dbskill_results['documents'][0]:
        print(f"  · {doc}")

    print("\n═══ 个人积累视角 ═══")
    for doc in personal_results['documents'][0]:
        print(f"  · {doc}")

    print("\n─── 分析两者的共鸣与分歧 ───")
    # 用 Claude 分析两组原子的关系
    # ...（调用 Claude 生成对比分析）
# 示例
compare_query("知识付费课程如何定价？")

六、把 RAG 引擎接入 Obsidian 工作流

把查询结果自动写入 Obsidian

Bash

# 查询后自动存档到 Obsidian
python query_atoms.py "定制开发客户的判断标准" > /tmp/atom_query.txt
obsidian create \
  name="03-Projects/decisions/决策-接定制客户-$(date +%Y%m%d)" \
  content="---
type: decision-record
date: $(date +%Y-%m-%d)
question: 要不要接定制开发客户
atoms-used: 8
source: atom-rag
tags: [decision, client, custom-dev]
---
# 决策记录：接定制客户
## 查询问题
要不要接一个要求定制开发、账期60天的客户？
## 原子库的判断依据
$(cat /tmp/atom_query.txt)
## 我的最终判断
（填入自己的决定）
## 实际结果
（决策后记录，用于反向验证原子库的准确性）
"

建立「决策追踪 + 原子验证」闭环

这是整套系统最有长期价值的用法——每次用原子库做了判断，之后记录实际结果，用来验证哪些原子真的有效：

Bash

obsidian create \
  name="System/Bases/原子验证追踪.base" \
  content='{
    "filters": {
      "and": [
        {"field": "type", "operator": "=", "value": "decision-record"},
        {"field": "atoms-used", "operator": ">", "value": "0"}
      ]
    },
    "columns": [
      {"field": "title", "width": 250},
      {"field": "question", "width": 200},
      {"field": "atoms-used", "width": 80},
      {"field": "date", "width": 110},
      {"field": "actual-result", "width": 150}
    ],
    "sort": [{"field": "date", "direction": "desc"}]
  }'

三个月后的这张表，是你最重要的学习资产——它告诉你：哪些类型的原子在你的场景下有效，哪些需要修正。

七、原子库的持续更新机制

atoms.jsonl 是按季度更新的。建立一套自动追踪更新的机制：

Bash

# 创建更新检查脚本
cat > ~/scripts/check-atoms-update.sh << 'EOF'
#!/bin/bash
ATOMS_DIR="$HOME/.claude/skills/dbskill/知识库/原子库"
CURRENT_COUNT=$(wc -l < "$ATOMS_DIR/atoms.jsonl")
echo "当前原子数：$CURRENT_COUNT"
# 拉取最新版本
cd "$HOME/.claude/skills/dbskill"
git fetch origin
LOCAL=$(git rev-parse HEAD)
REMOTE=$(git rev-parse origin/main)
if [ "$LOCAL" != "$REMOTE" ]; then
    echo "🆕 发现更新！"
    git pull origin main
    NEW_COUNT=$(wc -l < "$ATOMS_DIR/atoms.jsonl")
    ADDED=$((NEW_COUNT - CURRENT_COUNT))
    echo "新增 $ADDED 个原子（$CURRENT_COUNT → $NEW_COUNT）"

    # 重建索引
    echo "重建向量索引..."
    python ~/scripts/build_atoms_index.py
    echo "✅ 索引更新完成"
else
    echo "✅ 原子库已是最新版本"
fi
EOF
chmod +x ~/scripts/check-atoms-update.sh
# 加入 cron（每周检查更新）
# 0 9 * * 1 ~/scripts/check-atoms-update.sh >> ~/.atom-rag/update.log 2>&1

八、完整的知识原子生态系统架构

text

═══════════════════════════════════════════════════════
           知识原子生态系统 · 完整架构
═══════════════════════════════════════════════════════
输入层（三个来源）
┌─────────────────────────────────────────────────────┐
│ dbskill atoms.jsonl     个人 Obsidian 原子    书籍原子 │
│   (4,176个)            (模块1-6积累的)     (book-to-skill) │
└──────────────┬─────────────────┬──────────────┬──────┘
               ↓                 ↓              ↓
         解析 + 标准化（统一字段格式）
               ↓
         向量化 + 存入 ChromaDB
               ↓
         ─────────────────────────────────
         merged_atoms 向量数据库
         （可按 source_tag / type / confidence 过滤）
         ─────────────────────────────────
               ↓
查询层（四种查询模式）
┌─────────────────────────────────────────────────────┐
│ 语义查询    避坑查询    框架查询    案例查询           │
│ （全量检索） （anti-pattern）（framework）（case）     │
└──────────────┬──────────────────────────────────────┘
               ↓
         + Skill知识包 System Prompt
               ↓
         Claude RAG 生成回答（有原子引用）
               ↓
输出层（三种落地方式）
┌─────────────────────────────────────────────────────┐
│ 当前决策判断   →  存入 Obsidian 决策记录             │
│ 内容创作支撑   →  存入 04-Outputs/ 参考资料          │
│ 诊断报告增强   →  追加到 dbs-report 的依据部分       │
└─────────────────────────────────────────────────────┘
               ↓
反馈层（持续优化）
┌─────────────────────────────────────────────────────┐
│ 实际结果记录  →  验证原子的有效性                    │
│ 高效原子标记  →  提升 confidence 到 high             │
│ 无效原子标记  →  降低 confidence 或归档              │
└─────────────────────────────────────────────────────┘
═══════════════════════════════════════════════════════

九、常见问题深度解析

Q1：ChromaDB 向量检索结果不够准确怎么办？

Python

# 提升检索质量的三个方法：
# 方法 1：增加检索数量，让 Claude 做二次过滤
results = collection.query(query_texts=[question], n_results=15)
# 检索 15 个，Claude 从中选最相关的 5 个
# 方法 2：换更好的中文嵌入模型
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="BAAI/bge-large-zh-v1.5"  # 更强的中文模型
)
# 方法 3：查询扩展——用 Claude 生成多个查询变体
query_variants = [
    "要不要接定制客户",
    "定制开发客户风险",
    "账期长的客户如何判断",
    "服务型生意接单原则"
]
# 分别检索再去重合并

Q2：个人原子和 dbskill 原子出现矛盾怎么处理？

text

矛盾是最有价值的信号：
→ dbskill 原子说：「账期超过30天就不接」
→ 你的个人原子说：「某大客户账期60天但非常值得」
这种矛盾意味着：
可能是情境差异（大客户 vs 小客户）
可能是时间差异（市场环境变化）
可能是你的个人原子是错的（这个大客户其实亏了）
处理方法：
1. 记录这个矛盾到「原子矛盾库」
2. 用 dbs-chatroom 做多视角讨论
3. 等实际结果出来后，更新对应原子的 confidence

Q3：原子库的内容会不会过时？

dbskill 按季度更新原子库，持续追踪。但更重要的是：你的个人原子会持续增长，而且你的个人原子是针对你自己的场景的——比任何通用知识库都更精准。

三个月后，你的个人原子会超过 100 个。一年后，你会有一个真正属于自己的「个人商业判断知识库」。

十、模块 7 作业：提交标准与验收

Markdown

═══════════════════════════════════════════
📋 模块 7 作业清单
═══════════════════════════════════════════
【必交作业】
□ 1. 完成 atoms.jsonl 基础统计分析
     要求：用 jq 完成5种过滤查询
     提交：
     - 各类型原子数量统计截图
     - Top 10 高频主题截图
     - 一个「高置信度反模式」原子的完整内容
□ 2. 建立每日原子阅读脚本
     要求：daily-atom.sh 能正常运行
     执行一次，把输出写入 Obsidian 今日笔记
     提交：脚本代码 + 执行结果截图
□ 3. 完成向量索引构建
     要求：ChromaDB 索引构建成功，count() = 4176
     提交：build_atoms_index.py 执行日志截图
□ 4. 完成 5 次 RAG 查询实战
     要求：
     - 2次通用查询（针对你当前的真实决策）
     - 1次专项避坑查询（anti-pattern 过滤）
     - 1次框架查询（framework 过滤）
     - 1次案例查询（case 过滤）
     提交：5次查询的问题 + 回答截图
□ 5. 把个人 Obsidian 原子导出并合并
     要求：至少有 10 个个人原子成功导入
     提交：合并后的统计数字截图
           （dbskill 原子数 + 个人原子数 + 总计）
□ 6. 创建「决策追踪 + 原子验证」Bases 视图
     提交：在 Obsidian 中的截图
□ 7. git commit + dbs-save 存档
     格式：「atoms: RAG 引擎构建完成 YYYYMMDD」
【选交作业（加分）】
○ 8. 完成一次「个人 vs dbskill 对比查询」
     找到一个两者有分歧的问题
     记录：分歧在哪里？你最终相信哪一个？原因是什么？
○ 9. 建立原子更新 cron 任务
     设置每周自动检查 dbskill 更新
     提交：cron 配置截图 + 一次手动触发的日志
○ 10. 回顾本课程前6个模块，列出
      「这个原子如果我当时有 RAG 引擎，会改变哪个判断？」
      写一篇 500 字的复盘笔记存入 Obsidian
═══════════════════════════════════════════
【作业提交格式】
1. RAG 查询截图（5张，显示问题 + 回答）
2. 合并知识库统计截图
3. Bases 视图截图
4. 一段文字：
   「用原子库查询前，我对 [某个决策] 的判断是___，
    查询后发现___，
    最有价值的一个原子是___，
    因为___」
文件命名：模块7-作业-[你的名字]-atoms-rag.pdf
═══════════════════════════════════════════

十一、模块 7 结语：从「读过」到「可检索」，这一步价值十倍

前六个模块，我们做了很多「输入」的工作：

读书、拆概念、做诊断、写内容、建执行系统、维护知识库。

这些输入，在没有检索能力之前，的价值是线性的——你存了多少，就用了多少，而且大多数时候「存了但用不上」。

只看 type: "case" 或 type: "anti-pattern" 的原子，大约有 700+ 条真实商业案例和反面案例。

700 个真实案例，每一个都是有人踩过的坑或者验证过的路。在你面对一个具体决策的时候，这 700 个案例能不能帮到你，完全取决于你能不能在 60 秒内找到最相关的那几个。

RAG 技术解决的，就是这个「在 60 秒内找到」的问题。

根据 Ars Technica 的说法，「RAG 是一种提升 LLM 性能的方法，本质上是将 LLM 流程与网络搜索或其他文档查找流程相结合，帮助 LLM 坚持事实。」这种方法有助于减少 AI 幻觉。

但在我们的场景里，RAG 解决的不只是「减少幻觉」——它解决的是「把历史经验变成当下决策的参照系」。

当你的 RAG 引擎里同时有 4,176 个来自 dontbesilent 的商业洞见，和 100+ 个来自你自己经历提炼的个人原子，你的每一个决策都不再是凭感觉——而是有依据、有参照、有历史验证的判断。

这就是「判断力」和「知识积累」之间那道墙被打通的感觉。

下一个模块，我们进入多视角思辨工作流——用 dbs-chatroom + dbs-chatroom-austrian 模拟真正的专家讨论，让你在做重大决策前，先把所有可能的反对意见都听一遍。

💡 「知识的价值不在于存了多少，在于用的时候能不能找到。」 4,176 个原子 + 你自己的原子 + RAG 引擎 = 一个永远在你身边的「商业判断参谋」。 这才是知识资产，不是知识仓库。

引用链接

[1] 1: https://github.com/dontbesilent2025/dbskill
[2] 6: https://arxiv.org/pdf/2405.12363