一、问题背景:为什么要在 Milvus 和 Qdrant 之间做选择

我们做的是一个企业知识库检索系统,数据规模约 1000 万条文档切片,向量维度 768(bge-base-zh 模型),查询模式是"向量相似度 + 元数据过滤"(按租户 ID、文档类型、时间范围过滤),要求 QPS 200、P99 延迟 100ms 以内,且要支持按租户做数据隔离。

一开始团队内部有两个声音:一派认为 Milvus 生态成熟、社区大、支持分布式,是"正统选择";另一派认为 Qdrant 单机性能强、Rust 实现内存效率高、部署运维简单,适合我们这种中等规模场景。争不出结果,索性做一次同硬件同数据集的实测。

本文所有数据均来自我们自己的测试环境,不是官方 benchmark 的搬运。硬件为单台云主机:16 vCPU(Intel Xeon Platinum 8269CY)、64GB 内存、500GB ESSD、Ubuntu 22.04。两个数据库都跑在同一台机器上,但分时复用,避免资源争抢影响数据。

二、环境与版本

  • 操作系统:Ubuntu 22.04.3 LTS,内核 5.15
  • Docker:24.0.7,Docker Compose v2.23.0
  • Milvus:2.4.4(standalone 模式,etcd + MinIO 依赖)
  • Qdrant:1.10.1(单节点)
  • Python 客户端:pymilvus 2.4.4、qdrant-client 1.10.1
  • 压测工具:自写 asyncio 压测脚本 + locust 交叉验证

Milvus 部署步骤

Milvus standalone 官方推荐用 docker-compose 拉起,注意 2.4.x 版本对 etcd 和 MinIO 有版本要求:

# docker-compose.yml(节选自官方 standalone 配置,已裁剪)
version: '3.5'
services:
  etcd:
    image: quay.io/coreos/etcd:v3.5.5
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
    command: etcd -advertise-client-urls=http://127.0.0.1:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /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"
  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 ps 应看到三个容器,curl http://localhost:9091/healthz 返回 OK 即可。注意 Milvus 冷启动较慢,实测约 25-40 秒才 ready,脚本里务必加重试。

Qdrant 部署步骤

Qdrant 简单得多,单容器即可,这是它的一大优势:

docker run -d --name qdrant \
  -p 6333:6333 -p 6334:6334 \
  -v $(pwd)/qdrant_storage:/qdrant/storage \
  -e QDRANT__SERVICE__GRPC_PORT=6334 \
  qdrant/qdrant:v1.10.1

curl http://localhost:6333/healthz 返回 healthz check passed 即完成,冷启动约 2 秒。就部署体验而言,Qdrant 对中小团队友好太多——不用维护 etcd 和对象存储。

三、方案设计

数据集:1000 万条 768 维 float32 向量,随机生成但做了聚类(模拟真实 embedding 分布),附带 4 个标量字段:tenant_id(1000 个租户)、doc_type(8 类)、created_at(时间戳)、is_deleted(布尔)。

索引配置:
- Milvus:IVF_FLAT,nlist=4096,metric=IP;标量字段建倒排索引;开启 mmap 降低内存。
- Qdrant:HNSW,m=16,ef_construct=200,metric=InnerProduct;标量字段建 payload index。

查询分为三组:
1. 纯向量 TopK=10;
2. 向量 + 单标量过滤(tenant_id);
3. 向量 + 多条件过滤(tenant_id + doc_type + 时间范围)。

每组各跑 5 万次请求,统计 P50/P95/P99 和 QPS。

四、核心实现(含代码)

Milvus 写入与查询

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

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

fields = [
    FieldSchema("id", DataType.INT64, is_primary=True, auto_id=False),
    FieldSchema("tenant_id", DataType.INT64),
    FieldSchema("doc_type", DataType.INT32),
    FieldSchema("created_at", DataType.INT64),
    FieldSchema("is_deleted", DataType.BOOL),
    FieldSchema("embedding", DataType.FLOAT_VECTOR, dim=768),
]
schema = CollectionSchema(fields, description="kb_docs")
if not utility.has_collection("kb_docs"):
    col = Collection("kb_docs", schema)
    col.create_index("embedding", {
        "index_type": "IVF_FLAT", "metric_type": "IP", "params": {"nlist": 4096}
    })
    col.create_index("tenant_id", {"index_type": "INVERTED"})
    col.create_index("doc_type", {"index_type": "INVERTED"})
    col.create_index("created_at", {"index_type": "STL_SORT"})
else:
    col = Collection("kb_docs")
col.load()

# 分批写入,每批 5000 条
BATCH = 5000
rng = np.random.default_rng(42)
for start in range(0, 10_000_000, BATCH):
    n = min(BATCH, 10_000_000 - start)
    vecs = rng.random((n, 768), dtype=np.float32)
    rows = [[start + i for i in range(n)],
            [int(x) for x in rng.integers(0, 1000, n)],
            [int(x) for x in rng.integers(0, 8, n)],
            [1700000000 + int(x) for x in rng.integers(0, 30_000_000, n)],
            [False] * n,
            vecs.tolist()]
    col.insert(rows)
col.flush()

# 带过滤的查询
q = rng.random(768, dtype=np.float32).tolist()
res = col.search(
    data=[q], anns_field="embedding", param={"metric_type": "IP", "params": {"nprobe": 32}},
    limit=10,
    expr='tenant_id == 123 && doc_type in [1,3] && created_at > 1710000000 && is_deleted == false',
    output_fields=["tenant_id", "doc_type"],
)
print(res[0][0].distance, res[0][0].entity.get("tenant_id"))

Qdrant 写入与查询

from qdrant_client import QdrantClient
from qdrant_client.models import (VectorParams, Distance, PointStruct,
                                  Filter, FieldCondition, MatchValue, MatchAny, Range)
import numpy as np

client = QdrantClient(host="127.0.0.1", port=6333)

if not client.collection_exists("kb_docs"):
    client.create_collection(
        collection_name="kb_docs",
        vectors_config=VectorParams(size=768, distance=Distance.DOT),
        hnsw_config={"m": 16, "ef_construct": 200},
    )
    for f, schema in [("tenant_id", "integer"), ("doc_type", "integer"),
                      ("created_at", "integer"), ("is_deleted", "bool")]:
        client.create_payload_index("kb_docs", f, field_schema=schema)

rng = np.random.default_rng(42)
BATCH = 5000
for start in range(0, 10_000_000, BATCH):
    n = min(BATCH, 10_000_000 - start)
    vecs = rng.random((n, 768), dtype=np.float32)
    points = [
        PointStruct(
            id=start + i,
            vector=vecs[i].tolist(),
            payload={"tenant_id": int(rng.integers(0, 1000)),
                     "doc_type": int(rng.integers(0, 8)),
                     "created_at": 1700000000 + int(rng.integers(0, 30_000_000)),
                     "is_deleted": False},
        ) for i in range(n)
    ]
    client.upsert("kb_docs", points=points, wait=False)

# 带过滤的查询
q = rng.random(768, dtype=np.float32).tolist()
hits = client.search(
    collection_name="kb_docs",
    query_vector=q,
    limit=10,
    query_filter=Filter(must=[
        FieldCondition(key="tenant_id", match=MatchValue(value=123)),
        FieldCondition(key="doc_type", match=MatchAny(any=[1, 3])),
        FieldCondition(key="created_at", range=Range(gt=1710000000)),
        FieldCondition(key="is_deleted", match=MatchValue(value=False)),
    ]),
    search_params={"hnsw_ef": 128},
)
print(hits[0].score, hits[0].payload["tenant_id"])

五、踩坑与优化

坑 1:Milvus 写入不 flush 会丢数据。 我们第一次压测前只 insert 没 flush,num_entities 显示有数据但 search 返回空。Milvus 的 insert 是先进 growing segment,flush 后才持久化并进入可搜索状态。生产环境建议开 growing segment 的自动 flush 策略,别手动每批 flush(性能会掉一半以上)。Qdrant 的 wait=False 是异步落盘,读己之写场景要设 wait=True 或用 consistency 参数。

坑 2:Qdrant 的 payload index 不建,过滤查询会全表扫。 我们一开始漏了 create_payload_index,带 tenant_id 过滤的查询 P99 直接飙到 800ms。建索引后降到 45ms。这个坑很隐蔽,因为纯向量查询完全看不出问题。

坑 3:Milvus 的 nprobe 和 Qdrant 的 hnsw_ef 直接决定召回与延迟的平衡。 nprobe 从 16 调到 32,P99 从 41ms 涨到 68ms,但 recall@10 从 0.91 涨到 0.97。最终我们线上取 nprobe=24、hnsw_ef=96,做折中。

优化:Milvus 开启 queryNode.mmap 相关配置后内存从 38GB 降到 26GB,代价是 P99 增加约 8ms;Qdrant 开启 on_disk_payload=true 可进一步降内存,但我们的场景内存够用就没开。

六、效果数据

指标 Milvus 2.4.4 Qdrant 1.10.1
纯向量 TopK P99 41ms 28ms
单标量过滤 P99 55ms 42ms
多条件过滤 P99 68ms 47ms
峰值 QPS(P99<100ms) 约 320 约 480
常驻内存(加载后) 26GB(开 mmap) 17GB
磁盘占用 约 62GB 约 41GB
冷启动到 ready 32s 2s
索引构建 1000w 条 约 21 分钟 约 14 分钟

结论很清晰:单机中等规模场景,Qdrant 在延迟、内存、磁盘、启动速度上全面占优,尤其是多条件过滤场景领先约 30%。Milvus 的优势在于分布式扩展(百万级 QPS、十亿级向量)、丰富的索引类型(DISKANN、GPU 索引)和成熟的生态。我们最终选了 Qdrant 作为当前阶段方案,但保留了 Milvus 的迁移预案(两者都支持标准 REST/gRPC,向量数据可导出重灌)。

七、总结

选型没有银弹。如果数据量在千万级、团队没有专职运维、对延迟敏感,Qdrant 是更务实的选择;如果预期数据会到十亿级、需要多副本高可用和 GPU 加速,Milvus 的分布式架构更值得投入。建议选型时一定用自己的真实数据和过滤模式压测,别只看官方 benchmark——我们这次最大的收获就是发现"多条件过滤"才是真实业务的瓶颈点,而这一点在大部分对比文章里都被忽略了。