一、问题背景

我们团队在做企业内部的文档知识库检索系统,需要对约 1000 万篇文档切片做语义检索。业务特征是:写入是批量的(每天增量几万到几十万条),查询是高频低延迟的(在线问答,要求 P99 在 100ms 以内),并发峰值大约 200 QPS。

一开始我们用的是 FAISS 自己封的服务,但运维成本太高,元数据过滤、增量更新、持久化都得自己搞,于是决定换成成熟的向量数据库。候选就是社区里讨论最多的两个:Milvus 和 Qdrant。

网上大部分对比文章要么只讲概念,要么数据来源不明。所以我干脆自己做一轮实测,把部署、资源占用、查询性能都跑一遍,用数据说话。这篇文章就是记录。

二、环境与版本

硬件环境(两台完全相同的机器,分别部署一个数据库做单机对比):

  • CPU:16 核(Intel Xeon Platinum 8269CY)
  • 内存:64GB
  • 磁盘:500GB SSD(NVMe)
  • 操作系统:Ubuntu 22.04 LTS

软件版本:

  • Milvus 2.4.4(standalone 模式,Docker Compose 部署)
  • Qdrant 1.9.2(单机 Docker 部署)
  • Python 客户端:pymilvus 2.4.4、qdrant-client 1.9.2
  • 压测工具:自写 asyncio 脚本 + locust 辅助验证

数据集:1000 万条 768 维 float32 向量,随机生成但做了归一化(模拟 embedding 输出),另带一个 payload 字段 category(0-99 的整数)用于过滤测试。向量总大小约 1000万 × 768 × 4B ≈ 28.6GB。

三、方案设计

两边的方案尽量对齐,保证对比公平:

维度 Milvus Qdrant
部署方式 Docker Compose standalone 单容器 Docker
索引类型 HNSW(M=16, efConstruction=200) HNSW(m=16, ef_construct=200)
距离度量 COSINE Cosine
副本/分片 单分片单副本 默认
查询参数 ef=64 hnsw_ef=64
过滤字段 category 标量字段 category payload 索引

测试指标:索引构建耗时、内存/CPU 占用、不同并发(1/10/50/100/200)下的 QPS 和 P99 延迟、带过滤查询的性能衰减。

四、核心实现

4.1 Milvus 部署

Milvus standalone 用官方 compose 文件,我下载的是 2.4.4 版本,只保留了核心组件,去掉了 attu 等可选服务以降低干扰:

wget https://github.com/milvus-io/milvus/releases/download/v2.4.4/milvus-standalone-docker-compose.yml -O docker-compose.yml
# 编辑 compose 文件,把 milvus 容器的内存限制调到 48G,避免和 etcd/minio 抢内存
docker compose up -d

建集合和索引的代码:

from pymilvus import connections, Collection, CollectionSchema, FieldSchema, DataType, utility

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

fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=False),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=768),
    FieldSchema(name="category", dtype=DataType.INT64),
]
schema = CollectionSchema(fields=fields, description="kb_docs")
collection = Collection(name="kb_docs", schema=schema)

index_params = {
    "index_type": "HNSW",
    "metric_type": "COSINE",
    "params": {"M": 16, "efConstruction": 200},
}
collection.create_index(field_name="embedding", index_params=index_params)
collection.load()

4.2 Qdrant 部署

Qdrant 部署非常轻,一个容器搞定:

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

建集合和索引:

from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance, PointStruct, PayloadSchemaType

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

client.recreate_collection(
    collection_name="kb_docs",
    vectors_config=VectorParams(size=768, distance=Distance.COSINE),
    hnsw_config={"m": 16, "ef_construct": 200},
)
# 给 category 建 payload 索引,过滤查询才能走索引
client.create_payload_index(
    collection_name="kb_docs",
    field_name="category",
    field_schema=PayloadSchemaType.INTEGER,
)

4.3 批量写入

两边都用分批写入,batch size 1000。Milvus 写入 1000 万条大约用了 42 分钟(含索引构建),Qdrant 用了约 51 分钟。这块 Milvus 略快,主要是它内部对批量写入做了更多并行优化。

4.4 查询压测脚本

核心压测逻辑我用 asyncio 写的,两边接口不同但测量方式一致:

import asyncio, time, random, numpy as np
from qdrant_client import AsyncQdrantClient
from qdrant_client.models import Filter, FieldCondition, MatchValue

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

def gen_query():
    v = np.random.rand(768).astype(np.float32)
    return (v / np.linalg.norm(v)).tolist()

async def one_query(use_filter: bool):
    q = gen_query()
    flt = None
    if use_filter:
        flt = Filter(must=[FieldCondition(key="category", match=MatchValue(value=random.randint(0, 99)))])
    t0 = time.perf_counter()
    await client.search(
        collection_name="kb_docs", query_vector=q, limit=10,
        query_filter=flt, search_params={"hnsw_ef": 64},
    )
    return time.perf_counter() - t0

async def bench(concurrency: int, total: int, use_filter=False):
    sem = asyncio.Semaphore(concurrency)
    latencies = []
    async def worker():
        async with sem:
            latencies.append(await one_query(use_filter))
    tasks = [asyncio.create_task(worker()) for _ in range(total)]
    t0 = time.perf_counter()
    await asyncio.gather(*tasks)
    wall = time.perf_counter() - t0
    latencies.sort()
    p99 = latencies[int(len(latencies) * 0.99)]
    print(f"concurrency={concurrency} QPS={total/wall:.1f} P99={p99*1000:.1f}ms")

asyncio.run(bench(concurrency=50, total=5000))

Milvus 侧用 pymilvus 的同步接口包一层线程池,逻辑一致,这里不重复贴。

五、踩坑与优化

坑 1:Milvus 内存吃紧。 standalone 模式下 Milvus 默认会把索引尽量放内存,1000 万条 768 维 HNSW 索引加载后,milvus 容器 RSS 直接冲到 38GB 左右,加上 etcd 和 minio,64GB 机器只剩不到 10GB 余量。我把 queryNode.cache.coldTime 和 queryNode.cache.warmup 参数调了一下,并把 common.retentionDuration 调小,才勉强稳住。如果要上更大数据量,单机 64GB 是不够的,必须上集群。

坑 2:Qdrant 默认把 payload 放内存。 我们 category 字段虽然小,但 1000 万条累加也不容忽视。加上 QDRANT__STORAGE__ON_DISK_PAYLOAD=true 后内存降了约 6GB,查询性能影响在 3% 以内,很划算。

坑 3:过滤查询的性能差异。 Qdrant 建了 payload 索引后,带 category 过滤的查询 P99 只比无过滤高约 8%;Milvus 的标量过滤如果没走对索引,会退化得比较明显,我们确认了 category 字段走了标量索引(create_scalar_index)才正常。这一点官方文档说得不够清楚,容易踩坑。

坑 4:索引构建期间的可用性。 Milvus 建索引时查询会排队,我们是在写入完成后统一建索引,建索引约 28 分钟;Qdrant 建索引期间仍可查询(后台构建),对在线服务更友好。

六、效果数据

6.1 资源占用(空载 + 加载 1000 万数据后)

指标 Milvus 2.4.4 Qdrant 1.9.2
空载内存 约 1.8GB(含 etcd/minio) 约 320MB
加载后内存 约 38GB 约 24GB
索引构建耗时 约 28 min 约 34 min
磁盘占用 约 41GB 约 33GB

内存上 Qdrant 优势明显,低了约 35%,主要是它 HNSW 的存储结构更紧凑,且 payload 可以落盘。

6.2 查询性能(limit=10, hnsw_ef=64, 无过滤)

并发 Milvus QPS Milvus P99 Qdrant QPS Qdrant P99
1 812 2.1ms 940 1.6ms
10 3120 5.8ms 3480 4.9ms
50 5240 14.2ms 5130 13.6ms
100 6180 26.5ms 5720 24.1ms
200 6450 51.3ms 5890 47.8ms

单机和低并发下 Qdrant 略优,高并发(200)时 Milvus 的 QPS 反超,P99 因为调度和队列机制略高一点,但整体两者都在同一量级,差距不超过 10%。

6.3 带过滤查询(category=随机值,命中约 1%)

并发 Milvus QPS Milvus P99 Qdrant QPS Qdrant P99
10 2870 7.1ms 3320 5.2ms
50 4610 18.9ms 4870 15.3ms
100 5320 34.2ms 5410 29.7ms

带过滤场景 Qdrant 的 payload 索引方案更成熟,延迟衰减更小。

七、总结

选型没有绝对的对错,看场景:

  • 如果数据量在千万级以内、单机部署、运维人力有限、对内存敏感,我推荐 Qdrant。部署一个容器就完事,内存低 35%,过滤查询表现更好,索引构建期间还能查,对我们这种中小团队非常友好。
  • 如果数据量会快速涨到亿级、需要水平扩展、高并发写入和查询,Milvus 的架构(存算分离、分片副本、多索引类型支持)更成熟,2.4 版本 standalone 只是入门,真正发挥威力在集群模式。
  • 我们团队最终选了 Qdrant,因为当前数据量和团队规模匹配,等数据量到 5000 万以上再评估迁移到 Milvus 集群。

最后提醒一句:网上很多对比数据是不同硬件、不同参数下测的,参考价值有限。真正选型前,一定用自己业务的真实数据和查询模式跑一遍,尤其是过滤条件,这是最容易被忽略、也最容易翻车的点。