前端转 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)
核心一样:
用额外的数据结构(索引)换取查询速度。
就像前端的:
Mapvs 数组查找: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-...
查询过程:
- 从顶层开始(A),跳到最近的点(C)
- 下一层,从 C 附近精细搜索
- 逐层下探,越来越精细
- 到最底层,找到最近邻
效果:
- 极快: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 永远不变。
八、今日踩坑
chromadb.Client()不持久化 → 要用PersistentClient(path="./db")- 默认 Embedding 是英文模型 → 中文效果差,要指定 BGE
- 集合名重复创建报错 → 先
try delete或用get_or_create_collection - 一次插入太多 → 内存爆,分批插入(1000 一批)
distances是"距离"不是"相似度" → 余弦距离 =1 - 相似度- HNSW 的
space参数要指定 → 默认是 l2(欧氏),文本要用cosine - 元数据字段类型混用 → Chroma 只支持 string / int / float / bool
- 过滤字段没索引 → 大集合慢,要建 metadata index
- 切换 Embedding 模型 → 已有向量失效,必须重建
PersistentClient多进程访问 → 会锁冲突,生产要用服务端版- 没设
hnsw:space→ 用默认 l2,效果不如 cosine - collection 没指定 embedding_function → 每次都要手动传 embedding
- 忘了建 ID 唯一性 → 重复 add 同一 ID 会报错
- 中文分段没处理 → 中英文混合分段会切错
- 持久化目录没备份 → 重建索引要时间,小心丢数据
九、今日总结
今天核心收获三件事:
- 向量数据库 = 特殊索引 + 相似度检索:HNSW / IVF / PQ 三种核心算法
- Chroma 是入门首选,Qdrant 是生产首选:一个"三行跑起来",一个"稳、快、可扩展"
- 带相似度的过滤 + 元数据过滤:真实 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 开发者。