一、问题背景

我们团队在做企业内部的文档问答系统,原始文档经过切分和嵌入后大约有1000万条chunk,向量维度768(bge-base-zh-v1.5)。检索侧的要求是:单次查询返回Top-20,QPS峰值约50,需要支持按部门ID、文档类型做标量过滤后再做向量检索。

一开始用的是FAISS,但FAISS本质是个库不是服务,多进程共享索引、增量更新、过滤能力都很别扭。于是决定换成真正的向量数据库。候选就是社区里讨论最多的两个:Milvus和Qdrant。

选型不能只看GitHub star数或者benchmark排行榜,那些数字跟我们的实际场景差太远。所以我花了两天时间,在相同的机器上把两个都部署起来,用同一批数据做了实测。这篇文章就是记录。

二、环境与版本

  • 机器:阿里云ECS,8 vCPU / 32GB RAM / 500GB ESSD,Ubuntu 22.04
  • Docker:24.0.7,docker-compose v2.23
  • Milvus:2.4.4(standalone模式,含etcd + minio依赖)
  • Qdrant:1.9.0(单节点)
  • 客户端:pymilvus 2.4.4,qdrant-client 1.9.0
  • 数据集:1000万条,768维float32,另有3个标量字段(dept_id int、doc_type int、ts int64)

需要说明的是,Milvus standalone和Qdrant单节点不是完全对等的架构——Milvus天生是分布式的,standalone只是把组件塞进一个进程。但对我们这种量级,单机就是现实选择,所以按单机对比。

三、方案设计

两边的索引配置尽量对齐:

项目 Milvus Qdrant
索引类型 HNSW HNSW
M 16 16
efConstruction 200 200
查询ef 64 hnsw_ef=64
距离度量 COSINE Cosine
标量索引 INVERTED(dept_id) integer payload index

测试分三块:
1. 写入性能:批量插入1000万条,batch=2000,记录总耗时
2. 查询性能:1000次查询,分纯向量Top-20、带过滤Top-20两组,记录P50/P95/P99
3. 资源占用:稳定运行后 docker stats 采样的内存和CPU

四、部署步骤与核心实现

4.1 Milvus部署

Milvus standalone用官方脚本拉配置:

wget https://github.com/milvus-io/milvus/releases/download/v2.4.4/milvus-standalone-docker-compose.yml -O docker-compose.yml
docker compose up -d

这会起三个容器:milvus-standalone、milvus-etcd、milvus-minio。启动后等大约40秒健康检查通过,端口19530。

4.2 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.9.0

6333是HTTP/REST,6334是gRPC。生产环境建议走gRPC,性能更好。

4.3 写入与查询代码

Milvus这边:

from pymilvus import MilvusClient
import numpy as np, time, random

client = MilvusClient(uri="http://localhost:19530")
COLL = "kb_chunks"

if client.has_collection(COLL):
    client.drop_collection(COLL)

client.create_collection(
    collection_name=COLL,
    dimension=768,
    metric_type="COSINE",
    auto_id=True,
)

index_params = client.prepare_index_params()
index_params.add_index(
    field_name="vector",
    index_type="HNSW",
    metric_type="COSINE",
    params={"M": 16, "efConstruction": 200},
)
client.create_index(COLL, index_params)

# 标量字段索引(dept_id)
# 注意:MilvusClient 快速模式对动态字段索引支持有限,生产建议用 ORM 接口显式建 schema
client.load_collection(COLL)

def gen_batch(n=2000):
    vecs = np.random.rand(n, 768).astype(np.float32)
    return [
        {"vector": vecs[i].tolist(),
         "dept_id": random.randint(1, 50),
         "doc_type": random.randint(1, 5),
         "ts": random.randint(1600000000, 1720000000)}
        for i in range(n)
    ]

t0 = time.time()
for i in range(5000):          # 5000 * 2000 = 1000万
    client.insert(COLL, gen_batch())
    if i % 500 == 0:
        print(f"inserted {(i+1)*2000} rows, {time.time()-t0:.1f}s")
print(f"Milvus 写入完成,总耗时 {time.time()-t0:.1f}s")

查询部分:

q = np.random.rand(768).astype(np.float32).tolist()
# 纯向量
res = client.search(COLL, data=[q], limit=20,
                    search_params={"metric_type": "COSINE", "params": {"ef": 64}})
# 带过滤
res_f = client.search(COLL, data=[q], limit=20,
                      filter='dept_id in [3, 7, 12] and doc_type == 1',
                      search_params={"metric_type": "COSINE", "params": {"ef": 64}})

Qdrant这边:

from qdrant_client import QdrantClient
from qdrant_client.models import (VectorParams, Distance, PointStruct,
                                  HnswConfigDiff, PayloadSchemaType)
import numpy as np, random, time

client = QdrantClient(host="localhost", port=6333, prefer_grpc=True)
COLL = "kb_chunks"

client.recreate_collection(
    collection_name=COLL,
    vectors_config=VectorParams(size=768, distance=Distance.COSINE),
    hnsw_config=HnswConfigDiff(m=16, ef_construct=200),
)
client.create_payload_index(COLL, "dept_id", PayloadSchemaType.INTEGER)

def gen_points(start_id, n=2000):
    vecs = np.random.rand(n, 768).astype(np.float32)
    return [PointStruct(
        id=start_id + i,
        vector=vecs[i].tolist(),
        payload={"dept_id": random.randint(1, 50),
                 "doc_type": random.randint(1, 5),
                 "ts": random.randint(1600000000, 1720000000)}
    ) for i in range(n)]

t0 = time.time()
for i in range(5000):
    client.upsert(COLL, points=gen_points(i * 2000))
    if i % 500 == 0:
        print(f"upserted {(i+1)*2000} points, {time.time()-t0:.1f}s")
print(f"Qdrant 写入完成,总耗时 {time.time()-t0:.1f}s")

查询用 client.search,过滤用 Filter + FieldCondition,这里不展开,逻辑等价。

五、踩坑与优化

坑1:Milvus写入时的内存尖峰。 1000万条批量插入过程中,Milvus standalone的RSS一度冲到约18GB,触发了机器swap,写入速度断崖式下降。原因是数据先写内存再flush到对象存储(minio)。解决办法是控制batch大小到2000以内,并且每50万条手动 client.flush(COLL) 一次,内存峰值降到约12GB。

坑2:Qdrant的payload索引没建等于白建。 第一轮测试带过滤查询时Qdrant P99高达380ms,排查发现是忘了建payload索引,过滤走的是全量扫描。补上 create_payload_index 后降到120ms级别。这个索引必须在灌数据之前或之后显式创建,不会自动建。

坑3:Milvus的load必须显式调用。 用快速模式建完collection后如果不 load_collection,查询直接报collection not loaded。而Qdrant没有这个概念,建完就能查,心智负担小不少。

优化: 两边都把 ef 从默认值调到64,Recall@20在自建测试集上约0.96,延迟和召回的平衡点比较合适。ef再往上加,延迟线性涨,召回提升有限。

六、效果数据

写入1000万条(batch=2000):

指标 Milvus 2.4.4 Qdrant 1.9.0
总耗时 约 41 分钟 约 94 分钟
写入吞吐 ~4060 条/s ~1770 条/s

查询1000次,Top-20:

场景 Milvus P50/P95/P99 (ms) Qdrant P50/P95/P99 (ms)
纯向量 18 / 34 / 52 11 / 21 / 31
带过滤 26 / 48 / 79 15 / 27 / 42

资源占用(稳定态,docker stats 采样10次取均值):

指标 Milvus Qdrant
内存 ~11.8 GB ~7.6 GB
CPU(空闲) ~4% ~1%
磁盘 ~14 GB ~12 GB

数字很清楚了:写入Milvus快2倍多,查询Qdrant延迟低约35%~45%,内存省约35%。带过滤查询两者都没崩,但Qdrant的优势更明显——它的过滤是在HNSW图遍历中做的,Milvus的过滤路径相对更重一些。

七、总结

选哪个,取决于你的瓶颈在哪。

我们这个场景是读多写少(写入是一次性灌库,查询是持续高频),所以最终选了Qdrant:单容器部署省心、内存占用低、查询延迟更好,payload过滤能力也够用。如果反过来是持续高吞吐写入、或者未来要上分布式集群、需要多租户和更成熟的生态,Milvus更合适——它的写入吞吐和分布式架构是实打实的优势。

最后提醒一句:这两个项目版本迭代都很快,本文数据基于Milvus 2.4.4和Qdrant 1.9.0,换版本务必自己复测。benchmark只能帮你缩小范围,最终决策还得靠跑在自己数据上的数字。