RAG 向量数据库设计指南：从入门到生产

关系库 LIKE: SELECT * FROM chunks WHERE content LIKE '%代码质量%'
→ 只能命中包含"代码质量"的文本，找不到 "提高程序可维护性的方法"

向量库 ANN: SEARCH(embedding("如何提升代码质量"), topK=5)
→ 通过语义相似度找到：
  "提高程序可维护性的方法"     (cosine=0.92)
  "代码重构的最佳实践"         (cosine=0.88)
  "编写高质量 Go 代码的技巧"    (cosine=0.85)

// ChunkVector 向量数据库中的分片记录结构
type ChunkVector struct {
    // 主键
    ID string// varchar(36), 与关系库 chunk.id 一致

    // 向量字段
    DenseVector  []float32// 稠密向量，语义检索
    SparseVector []float32// 稀疏向量，关键词检索（可选）

    // 标量过滤字段（检索前预过滤）
    KnowledgeBaseID string// 分区键，按知识库隔离
    DocumentID      string// 支持按文档过滤
    TenantID        string// 多租户隔离
    Enabled         bool   // 禁用标记

    // 辅助返回字段
    Content  string// 原文内容，省去回关系库查询
    Position int32// 文档内排序，用于上下文窗口扩展
}

应该存入向量库:
├── id                  → 桥接关系库
├── vector              → 核心检索能力
├── knowledge_base_id   → 几乎每次检索都需要过滤
├── document_id         → 按文档范围检索
├── tenant_id           → 多租户安全隔离
├── enabled             → 排除已禁用分片
├── content             → 省去回关系库取原文
└── position            → 上下文窗口扩展

不需要存入向量库:
├── token_count         → 管理统计用，检索不需要
├── word_count          → 同上
├── metadata (JSON)     → 复杂结构，向量库处理效率低
├── created_at          → 审计字段
└── updated_at          → 同上

Layer 2（最稀疏，长距离连接）:  ● ─────────────── ●
Layer 1（中等密度）:           ● ── ● ─────────── ●
Layer 0（最底层，所有节点）:     ● ─ ● ─ ● ─ ● ─ ● ─ ● ─ ●

Step 1 标量过滤: knowledge_base_id="kb_001" AND enabled=true → 100万→5万
Step 2 向量搜索: 在 5 万条上做 ANN → 返回 Top 5

chunks Collection
  ├── Partition: kb_001 → 独立 HNSW 图（10万向量）
  ├── Partition: kb_002 → 独立 HNSW 图（50万向量）
  └── Partition: kb_003 → 独立 HNSW 图（2万向量）

检索 kb_002: 只搜索 50 万向量的 HNSW 图，而非全部 62 万

输入: "机器学习是人工智能的一个子领域"

输出（1024维）: [0.23, -0.45, 0.67, 0.12, ..., -0.01]
                 每一维都有非零值 → "稠密"

特征:
• 维度固定（768/1024/1536），由模型决定
• 几乎每一维都是非零值
• 每一维含义隐式，不可解释
• 擅长：同义词、上下位关系、语义类比
• 存储：1024 维 × 4 bytes = 4 KB / 条

词表有 250,000 个词，输入: "机器学习是人工智能的一个子领域"

输出（只展示非零部分）:
{机器:2.3, 学习:1.8, 人工智能:3.5, 领域:2.1, 子:0.8, ...}
其余 249,993 维都是 0 → "稀疏"

特征:
• 维度 = 词表大小（3万~25万），大部分为 0
• 非零维度通常只有几十个
• 每一维含义明确（第 N 维 = 第 N 个词的权重）
• 只存非零位置和权重 → ~50 × 8 bytes ≈ 400 bytes / 条

                    用户 Query
                        │
             ┌──────────┴──────────┐
             ▼                     ▼
      Embedding 模型          BM25/SPLADE
             │                     │
             ▼                     ▼
       稠密向量检索            稀疏向量检索
       (语义相似度)            (关键词匹配)
             │                     │
             └──────────┬──────────┘
                        ▼
                  融合排序 (RRF)
                        ▼
                  Rerank 重排序（可选）
                        ▼
                   最终 Top K

公式: RRF_score(d) = Σ 1/(k + rank_i(d))     k=60（平滑常数）

举个例子:
  文档 X: 稠密排第1, 稀疏排第5 → RRF = 1/61 + 1/65 = 0.03177
  文档 Y: 稠密排第3, 稀疏排第2 → RRF = 1/63 + 1/62 = 0.03200
  → Y 排前面（两边都靠前 > 一边极前一边较后）

Embedding 模型（Bi-Encoder）:  分别编码 Query 和 Chunk → 速度快，精度有限
Cross-Encoder（Reranker）:    同时编码 Query+Chunk   → 速度慢，精度更高

流程: 混合检索取 Top 20 → Rerank 精排 → 输出 Top 5

// HybridSearchWithRerank 混合检索 + 重排序
func (s *SearchService) HybridSearchWithRerank(
    ctx context.Context,
    knowledgeBaseID string,
    query string,
    topK int,
) ([]*SearchResult, error) {
    denseVec, err := s.embedder.EmbedDense(ctx, query)
    if err != nil {
        returnnil, fmt.Errorf("embed dense: %w", err)
    }
    sparseVec, err := s.embedder.EmbedSparse(ctx, query)
    if err != nil {
        returnnil, fmt.Errorf("embed sparse: %w", err)
    }

    // 取 4 倍候选量供 Rerank 筛选
    candidates, err := s.vectorRepo.HybridSearch(
        ctx, knowledgeBaseID, denseVec, sparseVec, topK*4,
    )
    if err != nil {
        returnnil, fmt.Errorf("hybrid search: %w", err)
    }

    reranked, err := s.reranker.Rerank(ctx, query, candidates, topK)
    if err != nil {
        return candidates[:topK], nil// 降级：Rerank 挂了就用原始结果
    }
    return reranked, nil
}

ef = 10:  搜索范围小 → ~2ms  → 召回率 ~85%
ef = 64:  搜索范围中 → ~5ms  → 召回率 ~95%  ← RAG 推荐
ef = 256: 搜索范围大 → ~15ms → 召回率 ~99%
ef = N:   等价暴力搜索        → 召回率 100%

文档上传
  → [关系库] 创建 Document (status=pending)
  → [异步任务] 解析 → 切片
  → [关系库] 批量创建 Chunks
  → [Embedding] 调用模型批量向量化
  → [向量库] 批量 Upsert（每批 500 条）
  → [关系库] 更新 Document.status=completed

func (r *VectorRepo) UpsertChunks(ctx context.Context, chunks []*ChunkVectorData) error {
    const batchSize = 500
    for i := 0; i < len(chunks); i += batchSize {
        end := min(i+batchSize, len(chunks))
        batch := chunks[i:end]
        // 构建列数据并 Upsert...
        if _, err := r.client.Upsert(ctx, "chunks", "", columns...); err != nil {
            return fmt.Errorf("upsert batch %d: %w", i/batchSize, err)
        }
    }
    return nil
}

// 按文档删除
func (r *VectorRepo) DeleteByDocumentID(ctx context.Context, docID string) error {
    return r.client.Delete(ctx, "chunks", "", fmt.Sprintf(`document_id == "%s"`, docID))
}

// 更新内容：需要重新向量化
// 1. 更新关系库（Source of Truth）
// 2. 重新 Embedding
// 3. Upsert 到向量库

func (s *ChunkService) UpdateContent(ctx context.Context, chunkID, newContent string) error {
    if err := s.chunkRepo.UpdateContent(ctx, chunkID, newContent); err != nil {
        return fmt.Errorf("update db: %w", err)
    }
    newVec, err := s.embedder.Embed(ctx, newContent)
    if err != nil {
        _ = s.chunkRepo.MarkNeedResync(ctx, chunkID) // 标记待同步
        return fmt.Errorf("re-embed: %w", err)
    }
    if err := s.vectorRepo.Upsert(ctx, chunkID, newVec, newContent); err != nil {
        _ = s.chunkRepo.MarkNeedResync(ctx, chunkID)
        return fmt.Errorf("upsert vector: %w", err)
    }
    returnnil
}

单条向量内存估算（HNSW, M=16, 1024维）:
  向量数据:  1024 × 4 bytes              = 4,096 bytes
  HNSW 图:  2 × M × 4 bytes × layers     ≈ 512 bytes
  标量字段: ~200 bytes（ID + 过滤字段）
  ──────────────────────────────────────
  合计: ~5 KB / 条

  100 万条 ≈ 5 GB 内存
  1000 万条 ≈ 50 GB 内存