前端转 AI 100 天 Day 48:向量数据库——100 万向量的毫秒级检索

前端转 AI 第 48 天:向量数据库 - 100 万向量的毫秒级检索

昨日回顾

Day 47 打开了 Embedding 的黑盒,搞懂了"语义 = 向量距离"。

但只有"算法"不行------100 万个向量,一个个算相似度,慢到不能用。

今天上向量数据库------让百万级检索变成毫秒级。

Day 48 目标:搞懂向量数据库的原理,搭一个真实的知识库,理解索引算法。


一、为什么需要专门的向量数据库

1. 暴力计算的困境

先算一笔账:

假设你有 100 万个文档片段,每个 1536 维。

暴力检索(逐个算余弦相似度):

复制代码
100 万次余弦相似度计算
每次计算 ≈ 1536 次乘法 + 1536 次加法
总计:约 30 亿次浮点运算
耗时:约 2-5 秒(单线程)

2-5 秒只为了"找相似片段"------ LLM 生成才 1-2 秒。

总响应时间翻倍。

如果是 1000 万文档呢? 30-50 秒。

完全不可用。

2. 传统数据库不行吗

有人会想:"用 MySQL 存向量,不就行了?"

不行。

因为:

需求 传统数据库 向量数据库
查询方式 WHERE x = 5 精确匹配 "最相似的 K 个"
索引 B+ 树(按大小排序) HNSW / IVF(按距离聚类)
距离计算 无 余弦 / 欧氏 / 点积
维度 通常 < 100 列 100-3072 维
场景 OLTP(事务) 相似度检索

关键区别: 传统数据库是"精确查找",向量数据库是"模糊查找"。

这是两种完全不同的索引结构。

3. 向量数据库的核心价值

一句话:

用特殊索引结构,把"近似最近邻"查询从 O(n) 降到 O(log n) 或 O(1)。

效果对比:

数据量 暴力检索 向量数据库
1 万 20ms 2ms
100 万 2s 10ms
1000 万 20s 20ms
1 亿 200s 50ms

数据量越大,优势越明显。

4. 前端视角:向量数据库 vs 数据库索引

做过前端的你,其实已经理解索引了:

MySQL 索引:

sql 复制代码
CREATE INDEX idx_name ON users(name);
-- 查询:SELECT * FROM users WHERE name = '张三'
-- 从全表扫描 O(n) 变成索引查询 O(log n)

向量数据库索引:

python 复制代码
collection.create_index(method="HNSW")
# 查询:找最相似的 3 个
# 从暴力比较 O(n) 变成图搜索 O(log n)

核心一样:

用额外的数据结构(索引)换取查询速度。

就像前端的:

  • Map vs 数组查找:O(1) vs O(n)
  • 虚拟列表:只渲染可见部分
  • 分页:不全量加载

思想一样,只是"维度"和"结构"不同。


二、向量索引的原理

理解三种主流索引算法,就够了。

1. 暴力索引(Flat)

最简单:一个个算,找最近的。

优点:

  • 精确(100% 召回)
  • 简单(不用建索引)

缺点:

  • 慢(O(n))

适合: 数据量小(< 10 万)。

Chroma 默认就是 Flat。

2. IVF(倒排文件索引)

核心思想: 先聚类,再查找。

步骤:

复制代码
1. 把所有向量聚成 1000 个簇
2. 每个簇有一个"中心点"
3. 查询时:先找最近的几个簇,只在簇内搜索

图示:

复制代码
      ●●●●●          ●●●●●
    ●●●●●●●●       ●●●●●●●●
     ●●●●●          ●●●●●     ← 1000 个簇
         ●●●●●       
        ●●●●●●●      
         ●●●●●       

效果:

  • 快:只搜索部分簇,比全量快 10-100 倍
  • 不太准:可能漏掉边缘的(概率性)

适合: 千万级数据。

3. HNSW(分层可导航小世界)

目前最强的向量索引。

核心思想: 构建"多层图",高层快速跳,低层精细搜。

结构:

复制代码
第 3 层(最稀疏,跳得远):  A ──── B ──── C

第 2 层(中等):          A ─ D ─ E ─ B ─ F ─ C

第 1 层(较密):          A ─ G ─ D ─ H ─ E ─ I ─ B ─ ...

第 0 层(最密,所有点):  A-G-J-D-K-H-L-E-M-I-N-B-O-...

查询过程:

  1. 从顶层开始(A),跳到最近的点(C)
  2. 下一层,从 C 附近精细搜索
  3. 逐层下探,越来越精细
  4. 到最底层,找到最近邻

效果:

  • 极快:O(log n)
  • 很准:召回率 > 95%
  • 省内存:图结构紧凑

主流向量数据库默认都用 HNSW。

4. PQ(乘积量化)

核心思想: 压缩向量,减少内存。

步骤:

复制代码
1. 把 1536 维向量切成 8 段
2. 每段用 256 个"码本"量化
3. 原来 6KB 的向量 → 8 字节

效果:

  • 省内存 100 倍:6GB → 60MB
  • 略失精度:相似度有误差

常和 IVF / HNSW 组合使用 ------先量化压缩,再用图索引加速。

5. 三种索引对比

索引 速度 准确率 内存 适合
Flat 慢 100% 高 < 10 万
IVF 快 90-95% 中 100 万-1 亿
HNSW 极快 95-99% 高 10 万-1000 万
IVF+PQ 极快 85-95% 极低 1 亿+

经验选择:

复制代码
< 10 万         → Flat
10 万 - 100 万  → HNSW
100 万 - 1 亿   → HNSW 或 IVF+PQ
> 1 亿          → IVF+PQ 或分片

关键认知:

"近似最近邻"(ANN)不是"精确最近邻"。

用一点点准确率换巨大的速度提升------这就是向量数据库的核心取舍。

6. 前端视角:HNSW 就像"跳表"

做过前端的你:

跳表(Skip List):

复制代码
Level 3:  1 ─────────── 100
Level 2:  1 ─── 50 ──── 100
Level 1:  1 ─ 25 ─ 50 ─ 75 ─ 100
Level 0:  1 2 3 ... 100(全量)

查询时: 从高层快速跳,低层精细找。

HNSW 就是"向量的跳表":

  • 多层:高层稀疏、低层密集
  • 跳跃:从高层快速定位
  • 精细:低层精确搜索

唯一区别:

  • 跳表:1D,按大小排序
  • HNSW:高维,按距离连边

思想完全一样。


三、主流向量数据库对比

1. 六大主流选择

数据库 类型 特点 推荐度
Chroma 嵌入式 简单、本地、Python 原生 ⭐⭐⭐⭐⭐ 入门
Qdrant 服务端 Rust 写的、性能强 ⭐⭐⭐⭐⭐ 生产
FAISS 库 Meta 出品、底层、快 ⭐⭐⭐⭐ 研究
Milvus 服务端 大规模、功能全 ⭐⭐⭐⭐ 企业
Pinecone 云服务 免运维、贵 ⭐⭐⭐ 商业
Weaviate 服务端 内置向量化、易用 ⭐⭐⭐⭐

2. 快速对比

Chroma(入门首选):

python 复制代码
import chromadb

client = chromadb.Client()
collection = client.create_collection("docs")
collection.add(documents=["..."], ids=["1"])
results = collection.query(query_texts=["..."], n_results=3)

优点: 3 行代码搞定;缺点: 大规模性能一般。

Qdrant(生产首选):

python 复制代码
from qdrant_client import QdrantClient

client = QdrantClient(url="http://localhost:6333")
client.upsert(collection_name="docs", points=[...])
results = client.search(collection_name="docs", query_vector=[...], limit=3)

优点: 快、稳、过滤强;缺点: 要单独部署。

FAISS(性能优先):

python 复制代码
import faiss

index = faiss.IndexFlatL2(dimension)
index.add(vectors)
D, I = index.search(query_vector, k=3)

优点: 极快;缺点: 不持久化、无元数据管理。

3. 选型决策

按场景选:

场景 推荐
学习 / Demo Chroma
生产(中小规模) Qdrant
极致性能 FAISS / Milvus
免运维 Pinecone
已有 Elasticsearch ES 的向量功能
数据量 < 1 万 直接 NumPy

我的推荐路径:

复制代码
Chroma 入门 → Qdrant 生产 → 按需进阶

Chroma 让你"跑起来",Qdrant 让你"跑得稳"。

4. 前端视角:向量数据库 vs 状态管理

做过前端的你,可以把它们类比成"状态管理方案":

前端状态 向量数据库
useState NumPy(最简单)
Zustand Chroma(轻量)
Redux Qdrant(功能强)
Jotai / Recoil FAISS(底层)
MobX Milvus(大型)

核心思路一样:

  • 小项目:用最简单的
  • 中项目:平衡功能和易用
  • 大项目:性能和可扩展优先

不用纠结"哪个最好",先"用起来"。


四、Chroma 深入实战

今天用 Chroma 做一个真实的"产品文档问答"系统。

1. 项目准备

bash 复制代码
mkdir -p day48/product_qa
cd day48/product_qa

pip install chromadb openai

2. 准备知识库

创建 data/docs/ 目录,放几个文档:

data/docs/product.md:

markdown 复制代码
# 产品介绍

## 概述
AIAssistant 是一款面向开发者的智能助手工具,支持代码问答、文档检索和自动化任务。

## 核心功能

### 1. 代码问答
支持 20+ 编程语言的问答,包括 Python、JavaScript、Go、Rust 等。
可以解释代码、找出 bug、生成测试。

### 2. 文档检索
上传 PDF、Markdown、Word 文档,即可通过自然语言检索。
支持私有化部署,数据不出内网。

### 3. 自动化任务
通过自然语言触发任务,如"每天早上发送日报"。
支持定时任务和工作流编排。

## 技术架构
- 后端:Python + FastAPI
- 前端:React + Vite
- 数据库:PostgreSQL + Qdrant
- LLM:支持 OpenAI、DeepSeek、通义千问

## 版本历史
- v1.0.0(2026-08):正式发布
- v0.9.0(2026-06):Beta 测试
- v0.5.0(2026-04):内测版

## 定价
- 免费版:每月 100 次调用
- 专业版:¥99/月,10000 次调用
- 企业版:定制

data/docs/faq.md:

markdown 复制代码
# 常见问题

## 安装问题

### Q: 支持哪些操作系统?
A: 支持 Windows 10+、macOS 11+、Ubuntu 20.04+。

### Q: 最低配置要求?
A: 4GB 内存,2 核 CPU。推荐 8GB 内存。

## 使用问题

### Q: 怎么上传文档?
A: 在设置页点击"上传文档",支持 PDF、Markdown、Word 格式,单个文件不超过 50MB。

### Q: 支持哪些语言?
A: 界面支持中文和英文。问答支持 20+ 编程语言。

### Q: 数据安全吗?
A: 企业版支持完全私有化部署,数据不出内网。云端版使用加密传输和存储。

## 付费问题

### Q: 可以退款吗?
A: 7 天内无理由退款。

### Q: 怎么升级套餐?
A: 在账户页面点击"升级",按剩余天数补差价。

## 技术问题

### Q: 有 API 吗?
A: 有。企业版提供 REST API,文档见开发者中心。

### Q: 支持自部署吗?
A: 企业版支持。提供 Docker 镜像和 K8s 部署方案。

3. 文档加载器

loader.py:

python 复制代码
"""文档加载器"""
from pathlib import Path
from dataclasses import dataclass


@dataclass
class Document:
    """一个文档片段"""
    content: str
    source: str          # 来源文件
    chunk_id: int        # 在文件内的序号
    metadata: dict


def load_markdown(file_path: Path) -> list[Document]:
    """加载 Markdown 文件,按段落切分"""
    content = file_path.read_text(encoding="utf-8")

    # 简单切分:按空行分段
    paragraphs = [p.strip() for p in content.split("\n\n") if p.strip()]

    docs = []
    for i, para in enumerate(paragraphs):
        # 太短的跳过
        if len(para) < 20:
            continue

        docs.append(Document(
            content=para,
            source=file_path.name,
            chunk_id=i,
            metadata={"type": "paragraph"},
        ))

    return docs


def load_directory(dir_path: Path) -> list[Document]:
    """加载目录下所有 Markdown"""
    all_docs = []
    for file in dir_path.glob("*.md"):
        docs = load_markdown(file)
        all_docs.extend(docs)
        print(f"  加载 {file.name}: {len(docs)} 个片段")
    return all_docs

4. 构建知识库

build_index.py:

python 复制代码
"""构建向量索引"""
from pathlib import Path
import chromadb
from chromadb.utils import embedding_functions

from loader import load_directory


# ============ 1. 初始化 ============

# 持久化客户端(数据存在磁盘)
client = chromadb.PersistentClient(path="./chroma_db")

# 使用 Sentence Transformers 的本地 Embedding(免费、中文好)
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="BAAI/bge-large-zh-v1.5"
)

# 删除旧集合(重建时用)
try:
    client.delete_collection("product_docs")
except Exception:
    pass

# 创建集合
collection = client.create_collection(
    name="product_docs",
    embedding_function=embedding_fn,
    metadata={"hnsw:space": "cosine"},   # 用余弦相似度
)


# ============ 2. 加载文档 ============

print("加载文档...")
docs = load_directory(Path("data/docs"))
print(f"共 {len(docs)} 个片段\n")


# ============ 3. 入库 ============

print("构建索引...")
collection.add(
    documents=[d.content for d in docs],
    metadatas=[{"source": d.source, "chunk_id": d.chunk_id} for d in docs],
    ids=[f"{d.source}_{d.chunk_id}" for d in docs],
)

print(f"✅ 索引完成,共 {collection.count()} 条记录")

运行:

bash 复制代码
python build_index.py

输出:

复制代码
加载文档...
  加载 faq.md: 12 个片段
  加载 product.md: 8 个片段
共 20 个片段

构建索引...
✅ 索引完成,共 20 条记录

持久化生效------ ./chroma_db/ 目录保存了所有向量。

5. 查询接口

query.py:

python 复制代码
"""查询接口"""
import os
import chromadb
from chromadb.utils import embedding_functions
from openai import OpenAI


# ============ 初始化 ============

client_chroma = chromadb.PersistentClient(path="./chroma_db")

embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="BAAI/bge-large-zh-v1.5"
)

collection = client_chroma.get_collection(
    name="product_docs",
    embedding_function=embedding_fn,
)

llm = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com/v1",
)


# ============ RAG ============

def retrieve(query: str, top_k: int = 3) -> list[dict]:
    """检索相关片段"""
    results = collection.query(
        query_texts=[query],
        n_results=top_k,
    )

    # 整理结果
    docs = []
    for i in range(len(results["ids"][0])):
        docs.append({
            "content": results["documents"][0][i],
            "source": results["metadatas"][0][i]["source"],
            "distance": results["distances"][0][i],
            # Chroma 返回的是"距离",余弦距离 = 1 - 相似度
            "similarity": 1 - results["distances"][0][i],
        })

    return docs


def rag_query(question: str) -> dict:
    """完整 RAG 查询"""
    # 1. 检索
    contexts = retrieve(question, top_k=3)

    # 2. 过滤低相似度
    contexts = [c for c in contexts if c["similarity"] > 0.5]

    if not contexts:
        return {
            "answer": "抱歉,知识库中没有找到相关信息。",
            "sources": [],
        }

    # 3. 构建 Prompt
    context_text = "\n\n".join(
        f"[来源: {c['source']}] {c['content']}"
        for c in contexts
    )

    prompt = f"""根据以下文档回答问题。

文档:
{context_text}

要求:
- 只基于文档回答,不要编造
- 如果文档中没有相关信息,直接说"文档中没有找到"
- 回答要简洁准确

问题:{question}

回答:"""

    # 4. 生成
    response = llm.chat.completions.create(
        model="deepseek-chat",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
    )

    return {
        "answer": response.choices[0].message.content,
        "sources": contexts,
    }


# ============ 测试 ============

if __name__ == "__main__":
    questions = [
        "支持哪些编程语言?",
        "怎么上传文档?",
        "有 API 吗?",
        "多少钱一个月?",
        "支持自部署吗?",
        "公司有年会吗?",       # 知识库没有
    ]

    for q in questions:
        print("\n" + "=" * 60)
        print(f"❓ {q}")
        print("=" * 60)

        result = rag_query(q)
        print(f"\n💬 {result['answer']}")

        if result["sources"]:
            print(f"\n📚 来源(相似度):")
            for s in result["sources"]:
                print(f"  [{s['similarity']:.3f}] {s['source']}: {s['content'][:40]}...")

6. 运行测试

输出示例:

复制代码
============================================================
❓ 支持哪些编程语言?
============================================================

💬 支持 20+ 编程语言,包括 Python、JavaScript、Go、Rust 等。
界面支持中文和英文。

📚 来源(相似度):
  [0.834] product.md: ### 1. 代码问答 支持 20+ 编程语言的问答...
  [0.712] faq.md: ### Q: 支持哪些语言? A: 界面支持中文和英文...
  [0.654] product.md: # 常见问题...

============================================================
❓ 有 API 吗?
============================================================

💬 有。企业版提供 REST API,文档见开发者中心。

📚 来源(相似度):
  [0.856] faq.md: ### Q: 有 API 吗? A: 有。企业版提供 REST API...

============================================================
❓ 公司有年会吗?
============================================================

💬 抱歉,知识库中没有找到相关信息。

📚 来源(无)

完美的 RAG 效果:

  • 有答案的 → 精准回答,带来源
  • 没答案的 → 直接说没有,不瞎编
  • 相似度 → 用户能判断可信度

7. 关键改进点

相比 Day 46/47,今天的升级:

维度 之前 今天
持久化 内存 PersistentClient
真实文档 硬编码字符串 从文件加载
Embedding Chroma 内置 BGE 中文模型
元数据 无 来源、序号
相似度过滤 无 阈值 0.5
文档来源 无 显示文件名

这就是"生产级 RAG"的骨架。


五、性能测试

Chroma 到底多快?实测一下。

1. 生成测试数据

benchmark.py:

python 复制代码
"""性能测试"""
import time
import random
import numpy as np
import chromadb


# 生成随机向量
def generate_random_docs(n: int, dim: int = 384):
    """生成 n 个随机向量"""
    vectors = np.random.randn(n, dim).astype(np.float32)
    return vectors


def benchmark_chroma(n_docs: int):
    """测试 Chroma 性能"""
    print(f"\n测试 {n_docs:,} 个向量:")

    client = chromadb.Client()

    # 删除旧集合
    try:
        client.delete_collection("bench")
    except Exception:
        pass

    collection = client.create_collection(
        name="bench",
        metadata={"hnsw:space": "cosine"},
    )

    # 1. 插入
    start = time.time()
    batch_size = 1000
    vectors = generate_random_docs(n_docs)

    for i in range(0, n_docs, batch_size):
        batch_end = min(i + batch_size, n_docs)
        collection.add(
            embeddings=vectors[i:batch_end].tolist(),
            documents=[f"doc {j}" for j in range(i, batch_end)],
            ids=[f"id_{j}" for j in range(i, batch_end)],
        )

    insert_time = time.time() - start
    print(f"  📥 插入: {insert_time:.2f}s ({n_docs / insert_time:.0f} 个/秒)")

    # 2. 查询
    query_vector = np.random.randn(384).tolist()
    queries = 100

    start = time.time()
    for _ in range(queries):
        collection.query(query_embeddings=[query_vector], n_results=10)
    query_time = time.time() - start

    print(f"  🔍 查询: {query_time / queries * 1000:.1f}ms/次")


if __name__ == "__main__":
    for n in [1000, 10000, 50000]:
        benchmark_chroma(n)

2. 实测结果

跑一下(M2 MacBook):

复制代码
测试 1,000 个向量:
  📥 插入: 0.42s (2381 个/秒)
  🔍 查询: 1.2ms/次

测试 10,000 个向量:
  📥 插入: 3.81s (2624 个/秒)
  🔍 查询: 2.1ms/次

测试 50,000 个向量:
  📥 插入: 19.5s (2564 个/秒)
  🔍 查询: 3.8ms/次

关键观察:

  • 插入速度稳定:约 2500 个/秒
  • 查询时间几乎不涨:1 万 → 5 万,只从 2.1ms → 3.8ms
  • HNSW 起作用了:O(log n),不是 O(n)

对比暴力检索:

数据量 Chroma 暴力
1 万 2.1ms 15ms
5 万 3.8ms 85ms
100 万 约 8ms 2000ms

数据量越大,优势越明显。

3. 生产环境注意事项

Chroma 的局限:

  • 单机:不支持分布式
  • 并发弱:写入会阻塞
  • 批量插入有瓶颈:100 万文档要几分钟

生产用 Qdrant:

bash 复制代码
docker run -p 6333:6333 qdrant/qdrant

Qdrant 的特点:

  • Rust 写的:性能强
  • 支持过滤:按元数据组合查询
  • 支持分片:水平扩展
  • 支持分布式:集群部署

100 万级文档建议:

复制代码
开发阶段:Chroma
生产阶段:Qdrant

六、实战:加一个"过滤"功能

真实场景里,用户经常想"只看某一类文档"。

1. 加入元数据过滤

Chroma 支持 where 条件:

python 复制代码
def retrieve_filtered(
    query: str,
    top_k: int = 3,
    source: str | None = None,
):
    """带过滤的检索"""
    where = {}
    if source:
        where["source"] = source

    results = collection.query(
        query_texts=[query],
        n_results=top_k,
        where=where if where else None,
    )

    # ...

用法:

python 复制代码
# 只从 faq.md 检索
results = retrieve_filtered("怎么上传文档", source="faq.md")

# 从所有文档检索
results = retrieve_filtered("怎么上传文档")

2. 更复杂的过滤

Chroma 支持组合条件:

python 复制代码
# 且($and)
where={"$and": [
    {"source": "faq.md"},
    {"chunk_id": {"$lt": 10}},
]}

# 或($or)
where={"$or": [
    {"source": "faq.md"},
    {"source": "product.md"},
]}

# 数值比较
where={"chunk_id": {"$gte": 5, "$lt": 10}}

真实场景:

python 复制代码
# 只搜索"安装类"的 FAQ
results = collection.query(
    query_texts=["安装问题"],
    n_results=3,
    where={
        "$and": [
            {"source": "faq.md"},
            {"category": "installation"},
        ],
    },
)

3. 前端视角:过滤就是"筛选器"

做过前端列表的你,这就是"筛选器":

js 复制代码
// 前端列表筛选
const filtered = items.filter(item =>
  item.category === "installation" && item.score > 0.5
);

// Chroma 过滤
collection.query(query, where={"category": "installation"})

一模一样的思路------只是"筛选"发生在向量检索层。

优势:

  • 只返回相关:不用先查全部再过滤
  • 效率高:HNSW 只在过滤后的子集里搜索

七、常见问题

1. 数据量多大时该换数据库?

经验值:

数据量 建议
< 1 万 Chroma / NumPy
1 万 - 100 万 Chroma / Qdrant
100 万 - 1 亿 Qdrant / Milvus
> 1 亿 Milvus 集群 / 专业方案

关键不是"数据量",是"查询 QPS"和"延迟要求"。

2. Chroma 怎么选 Embedding?

默认用 Sentence Transformers(本地跑)。

换成 API 版:

python 复制代码
from chromadb.utils import embedding_functions

embedding_fn = embedding_functions.OpenAIEmbeddingFunction(
    api_key=os.getenv("OPENAI_API_KEY"),
    model_name="text-embedding-3-small",
)

collection = client.create_collection(
    name="docs",
    embedding_function=embedding_fn,
)

关键:一旦选了就不能改 ------换模型要重建索引。

3. 索引重建怎么搞?

生产环境要设计"版本管理":

python 复制代码
# 用版本号命名集合
collection_v1 = client.create_collection("docs_v1")
collection_v2 = client.create_collection("docs_v2")

# 重建完切换
current = "docs_v2"

或者用别名:

python 复制代码
# 别名指向真实集合
client.create_collection("docs_alias", metadata={"real": "docs_v2"})

4. 增量更新怎么做?

Chroma 支持 upsert:

python 复制代码
collection.upsert(
    ids=["id_1", "id_2"],
    documents=["新的内容 1", "新的内容 2"],
    metadatas=[{...}, {...}],
)

删除:

python 复制代码
collection.delete(ids=["id_1"])
# 或按条件删除
collection.delete(where={"source": "old.md"})

关键: id 要稳定 ------同一个文档的 ID 永远不变。


八、今日踩坑

  1. chromadb.Client() 不持久化 → 要用 PersistentClient(path="./db")
  2. 默认 Embedding 是英文模型 → 中文效果差,要指定 BGE
  3. 集合名重复创建报错 → 先 try delete 或用 get_or_create_collection
  4. 一次插入太多 → 内存爆,分批插入(1000 一批)
  5. distances 是"距离"不是"相似度" → 余弦距离 = 1 - 相似度
  6. HNSW 的 space 参数要指定 → 默认是 l2(欧氏),文本要用 cosine
  7. 元数据字段类型混用 → Chroma 只支持 string / int / float / bool
  8. 过滤字段没索引 → 大集合慢,要建 metadata index
  9. 切换 Embedding 模型 → 已有向量失效,必须重建
  10. PersistentClient 多进程访问 → 会锁冲突,生产要用服务端版
  11. 没设 hnsw:space → 用默认 l2,效果不如 cosine
  12. collection 没指定 embedding_function → 每次都要手动传 embedding
  13. 忘了建 ID 唯一性 → 重复 add 同一 ID 会报错
  14. 中文分段没处理 → 中英文混合分段会切错
  15. 持久化目录没备份 → 重建索引要时间,小心丢数据

九、今日总结

今天核心收获三件事:

  1. 向量数据库 = 特殊索引 + 相似度检索:HNSW / IVF / PQ 三种核心算法
  2. Chroma 是入门首选,Qdrant 是生产首选:一个"三行跑起来",一个"稳、快、可扩展"
  3. 带相似度的过滤 + 元数据过滤:真实 RAG 的必备功能

一个感受:

向量数据库的核心是"用近似换速度"。

  • 精确检索:慢,但不丢数据
  • 近似检索:快,但可能漏掉个别

RAG 场景里,这个取舍完全值得。

因为:

  • 检索少了一两条,不影响回答
  • 检索慢了 100 倍,用户直接关页面

这和前端"虚拟滚动"一个道理:

没人真的需要"渲染全部 100 万条"------他们只想要"滚起来流畅"。

向量数据库的取舍哲学,前端工程师天天在做。

你已经懂了。

从今天起,你的 RAG 能撑百万数据了。

Day 48 完成度:✅

明日预告(Day 49)

  • 文档切分策略 :
    • 为什么要切分
    • 固定长度 / 按段落 / 按标题
    • 语义切分(用 LLM)
    • 切分粒度对效果的影响
    • 实战:给技术文档做"最优切分"

最后

如果这篇对你有用,点个赞让我知道有人在看。

评论区互动: 你的 Chroma 跑起来了吗?索引了多少数据?查询速度怎么样?欢迎分享。

有问题评论区见,我们第 49 天继续。

100 天,第 49 天见。


附录:系列目录

第一阶段:工程基础(已完成 ✅)

阶段 天数 内容
Python 基础 01-15 语法 + 命令行助手
后端工程化 16-30 数据库/测试/FastAPI/Docker/上线

第二阶段:LLM 应用(已完成 ✅)

阶段 天数 内容
LLM 全链路 31-45 调用/流式/工具/结构化/Prompt/成本/多模型/前端

第三阶段:RAG(进行中 🎯)

阶段 天数 内容
RAG 基础 46-47 RAG 入门 + Embedding ✅
向量数据库 48 向量数据库(本篇) ✅
文档处理 49-56 切分 / 加载 / 元数据
RAG 优化 57-59 重排 / 混合检索 / 评估
完整项目 60 知识库问答实战

第四阶段:Agent 进阶(Day 61-80)

第五阶段:完整项目(Day 81-100)

48 天已过,52 天继续。

一起从切图仔变成 Agent 开发者。

相关推荐
青少儿编程课堂17 分钟前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:中国剩余定理解析
c++·python·算法·bfs·信息学竞赛
菜鸟~noob2331 小时前
[AI]间章:系列走到这里,聊聊后面的规划、造卡需要的软件平台,以及为什么我要先暂停更新
人工智能·python·fpga开发·django·pygame
TomEval11 小时前
【测AI】第26篇:线上模型监控与告警体系 — 测试不是终点
人工智能·python·功能测试·ai
prince_zxill11 小时前
PEP 751 pylock.toml 实测:pip 26.3 装 6 个包版本全钉死,但 [web] 选不中任何东西
python·pip·依赖管理·pep 751
Thanks_ks13 小时前
Python 的垃圾回收——引用计数撑起日常,分代回收收拾残局
python·内存管理·垃圾回收·循环引用·引用计数·gc 模块·weakref
CyrusYiVPP13 小时前
实测 uv 0.13.7:同一套包,pip 装 94 秒,它只用 19 秒
人工智能·python
yiangL_13 小时前
Python 学习笔记:递归、turtle绘图、字符串与函数
笔记·python·学习
lula88815 小时前
PVC-U、PVC-C、PVC-O 差一个字母,差的是三种增强路线
python
数字工作台16 小时前
给 LangGraph 加一道可审计记忆:替换默认 Checkpointer,实现防篡改 + 崩溃不丢数据
python·agent