一、问题背景:召回层选型踩过的坑

我们团队在做的是一个电商推荐系统,召回层需要从千万级商品向量中检索 Top-K 相似结果。早期用的是 Faiss + 自建服务,但运维成本高、不支持动态增删、过滤条件弱,于是决定迁移到专业的向量数据库。

候选方案里,Milvus 和 Qdrant 是绕不开的两个:前者是 CNCF 毕业项目、生态成熟、支持分布式;后者是 Rust 写的、单机性能强、API 设计清爽。网上大多是对比文章要么停留在"Hello World"级别,要么是厂商自己的 benchmark,缺少可复现的实测数据。所以我干脆自己搭环境跑了一遍,把过程和数据完整记录下来。

本文的实测目标很明确:在单机环境下,1000 万条 768 维向量、HNSW 索引、带标量过滤的 Top-10 查询场景,谁更快、谁更省资源、谁更好运维。

二、环境与版本

所有测试在同一台机器上进行,避免硬件差异干扰:

项目 配置
CPU AMD EPYC 7543 32 核
内存 128 GB DDR4
磁盘 NVMe SSD 2TB
OS Ubuntu 22.04 LTS
Docker 24.0.7
Milvus 2.4.4 (standalone)
Qdrant 1.9.2
Python SDK pymilvus 2.4.4 / qdrant-client 1.9.2

数据集:1000 万条 768 维 float32 向量,随机生成后做 L2 归一化,模拟 embedding 模型输出;每条向量附带 3 个标量字段(category_id 整型 0-99、price 浮点、is_active 布尔),用于过滤测试。

三、方案设计

两边都采用 HNSW + 余弦相似度(向量已归一化,等价于内积)。参数尽量对齐,保证可比性:

  • Milvus:index_type=HNSW, M=16, efConstruction=200,查询 ef=64
  • Qdrant:m=16, ef_construct=200,查询 hnsw_ef=64

测试分三个阶段:
1. 写入:批量 5000 条/批,记录总耗时与内存峰值
2. 查询:100 并发、每线程 200 次查询,统计 QPS 与 P50/P99 延迟
3. 过滤查询:带 category_id == 42 AND is_active == true 条件,评估过滤对性能的影响

四、核心实现

4.1 部署

Milvus standalone 官方推荐 docker-compose,依赖 etcd + MinIO:

# docker-compose-milvus.yml
version: '3.5'
services:
  etcd:
    image: quay.io/coreos/etcd:v3.5.5
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
    command: etcd -advertise-client-urls=http://127.0.0.1:2379 -listen-client-urls http://0.0.0.0:2379
    volumes:
      - ./volumes/etcd:/etcd
  minio:
    image: minio/minio:RELEASE.2023-03-20T20-16-18Z
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    command: minio server /minio_data --console-address ":9001"
    volumes:
      - ./volumes/minio:/minio_data
  standalone:
    image: milvusdb/milvus:v2.4.4
    command: ["milvus", "run", "standalone"]
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - etcd
      - minio
docker compose -f docker-compose-milvus.yml up -d
# 容器内存限制:standalone 分配 32GB,etcd/minio 各 2GB

Qdrant 就简单得多,单容器即可:

docker run -d --name qdrant \
  -p 6333:6333 -p 6334:6334 \
  -v $(pwd)/qdrant_storage:/qdrant/storage \
  --memory=32g \
  qdrant/qdrant:v1.9.2

第一印象:Milvus 依赖三个组件,启动到可用约 40 秒;Qdrant 单容器 3 秒起来。单机场景下 Qdrant 的部署心智负担明显更低。

4.2 建表与写入

Milvus 需要先定义 Collection Schema 和索引:

from pymilvus import connections, Collection, CollectionSchema, FieldSchema, DataType, utility
import numpy as np, time

connections.connect("default", host="localhost", port="19530")

fields = [
    FieldSchema("id", DataType.INT64, is_primary=True, auto_id=False),
    FieldSchema("embedding", DataType.FLOAT_VECTOR, dim=768),
    FieldSchema("category_id", DataType.INT64),
    FieldSchema("price", DataType.FLOAT),
    FieldSchema("is_active", DataType.BOOL),
]
schema = CollectionSchema(fields, description="product_vectors")
if not utility.has_collection("products"):
    coll = Collection("products", schema)
    coll.create_index("embedding", {
        "index_type": "HNSW", "metric_type": "IP",
        "params": {"M": 16, "efConstruction": 200}
    })
else:
    coll = Collection("products")

# 批量写入 1000 万条
BATCH = 5000
start = time.time()
for i in range(0, 10_000_000, BATCH):
    ids = list(range(i, i + BATCH))
    vecs = np.random.randn(BATCH, 768).astype(np.float32)
    vecs /= np.linalg.norm(vecs, axis=1, keepdims=True)
    cats = np.random.randint(0, 100, BATCH).tolist()
    prices = (np.random.rand(BATCH) * 1000).tolist()
    actives = np.random.rand(BATCH) > 0.2
    coll.insert([ids, vecs.tolist(), cats, prices, actives.tolist()])
coll.flush()
print(f"Milvus insert cost: {time.time()-start:.1f}s")

Qdrant 用 collection 概念,配置更紧凑:

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct, HnswConfigDiff
import numpy as np, time

client = QdrantClient(host="localhost", port=6333)
if not client.collection_exists("products"):
    client.create_collection(
        collection_name="products",
        vectors_config=VectorParams(size=768, distance=Distance.DOT),
        hnsw_config=HnswConfigDiff(m=16, ef_construct=200),
    )

BATCH = 5000
start = time.time()
for i in range(0, 10_000_000, BATCH):
    vecs = np.random.randn(BATCH, 768).astype(np.float32)
    vecs /= np.linalg.norm(vecs, axis=1, keepdims=True)
    points = [
        PointStruct(
            id=i + j,
            vector=vecs[j].tolist(),
            payload={
                "category_id": int(np.random.randint(0, 100)),
                "price": float(np.random.rand() * 1000),
                "is_active": bool(np.random.rand() > 0.2),
            },
        ) for j in range(BATCH)
    ]
    client.upsert(collection_name="products", points=points)
print(f"Qdrant upsert cost: {time.time()-start:.1f}s")

Qdrant 的 payload 天然支持任意 JSON 字段,不需要预定义 schema,这点在业务字段频繁变动时很友好;Milvus 则要求先建 Field,改动需要重建 collection。

五、踩坑与优化

坑 1:Milvus 写入后必须 flush 才能被检索。 我们一开始没调 flush(),查询一直返回空,排查了半小时。后来改用 num_entities 校验才发现数据还在内存 buffer 里。生产环境应该设置 dataCoord.segment.maxSize 和自动 flush 策略,而不是手动 flush。

坑 2:Qdrant 的 DOT 和 COSINE 在归一化向量上等价,但 COSINE 会在服务端额外做一次归一化。 我们一开始用 COSINE,QPS 比 DOT 低了约 8%,改成 DOT 后恢复。这是个容易忽略的细节。

坑 3:Milvus standalone 默认内存不设限,容易 OOM。 1000 万条向量写入过程中,Milvus 容器内存飙到 45GB,机器直接告警。加 --memory=32g 限制后,配合 queryNode.cache.enabled=true 反而更稳定。

优化点:Qdrant 开启 on_disk_payload: true 后,标量字段存磁盘,内存占用下降约 30%,过滤查询 P99 只增加 4ms,非常划算。Milvus 侧开启 mmap 存储(mmap.enabled=true)后内存从 38GB 降到 22GB,但 P99 上升约 12ms。

六、效果数据

写入阶段(1000 万条):

指标 Milvus 2.4.4 Qdrant 1.9.2
总写入耗时 412 s 287 s
内存峰值 38.2 GB 26.4 GB
磁盘占用 31.5 GB 28.7 GB

查询阶段(100 并发 × 200 次,Top-10,ef=64):

指标 Milvus Qdrant
QPS 1,842 2,317
P50 延迟 42 ms 31 ms
P99 延迟 118 ms 89 ms
Recall@10(对比暴力检索) 0.972 0.968

带过滤查询(category_id==42 AND is_active==true,约 0.8% 命中):

指标 Milvus Qdrant
QPS 1,203 1,687
P99 延迟 156 ms 112 ms

结论很清晰:在这个单机、千万级、中等维度的场景下,Qdrant 在写入速度、内存占用、查询延迟上全面领先,尤其过滤查询优势明显(payload 索引做得更轻量)。Milvus 的召回率略高一点点,但差异在误差范围内。

不过要注意,这个结论有明确边界:当数据量上到亿级、需要多副本高可用、或需要 GPU 索引(CAGRA)、稀疏向量、多向量混合检索时,Milvus 的分布式架构和索引生态是 Qdrant 目前还追不上的。 Qdrant 也支持分布式,但集群模式的成熟度和运维工具链不如 Milvus。

七、总结:怎么选

给一个我们内部实际用的决策矩阵:

  • 数据量 < 5000 万、单机可承载、追求低延迟和低运维成本 → 选 Qdrant。Rust 实现的内存效率、单容器部署、payload 过滤性能都是实打实的优势。
  • 数据量亿级以上、需要水平扩展、多租户、GPU 加速或稀疏/多向量检索 → 选 Milvus。CNCF 生态、丰富的索引类型、成熟的分布式运维方案是护城河。
  • 团队 Python 为主、快速验证 → 两者 SDK 都好用,Qdrant 的 API 设计更符合直觉,上手更快。
  • 已有 K8s 体系、需要 operator → Milvus Operator 更成熟。

我们最终的选择是:召回主链路用 Qdrant 单机集群(3 节点分片),离线大规模向量归档和 GPU 重排实验用 Milvus。工具没有绝对的好坏,匹配业务阶段和团队能力才是关键。希望这组实测数据能帮你少走一些弯路。