Milvus 2.4 与 Qdrant 1.9 向量库选型对比：千万级商品检索部署与性能实测

# milvus-standalone-docker-compose.yml
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
    volumes:
      - ./volumes/etcd:/etcd
    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
    volumes:
      - ./volumes/minio:/minio_data
    command: minio server /minio_data --console-address ":9001"

  standalone:
    image: milvusdb/milvus:v2.4.1
    command: ["milvus", "run", "standalone"]
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    volumes:
      - ./volumes/milvus:/var/lib/milvus
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - etcd
      - minio

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

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

fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True),
    FieldSchema(name="category_id", dtype=DataType.INT32),
    FieldSchema(name="price", dtype=DataType.FLOAT),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=768),
]
schema = CollectionSchema(fields, description="product_vectors")
col = Collection("products", schema)

# HNSW 索引
index_params = {
    "index_type": "HNSW",
    "metric_type": "IP",
    "params": {"M": 16, "efConstruction": 200},
}
col.create_index("embedding", index_params)
col.create_index("category_id", {"index_type": "INVERTED"})
col.create_index("price", {"index_type": "STL_SORT"})
col.load()

# 批量写入 1200 万
BATCH = 10000
total = 12_000_000
for start in range(0, total, BATCH):
    n = min(BATCH, total - start)
    ids = list(range(start, start + n))
    cats = np.random.randint(0, 200, n).tolist()
    prices = (np.random.rand(n) * 1000).round(2).tolist()
    vecs = np.random.rand(n, 768).astype(np.float32)
    vecs /= np.linalg.norm(vecs, axis=1, keepdims=True)
    col.insert([ids, cats, prices, vecs.tolist()])

# 查询：带过滤的 TopK
query_vec = np.random.rand(1, 768).astype(np.float32)
query_vec /= np.linalg.norm(query_vec)

search_params = {"metric_type": "IP", "params": {"ef": 128}}
t0 = time.time()
res = col.search(
    data=query_vec.tolist(),
    anns_field="embedding",
    param=search_params,
    limit=50,
    expr="category_id == 12 && price < 300",
    output_fields=["category_id", "price"],
)
print(f"Milvus latency: {(time.time()-t0)*1000:.2f} ms")

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.2

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

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

client.recreate_collection(
    collection_name="products",
    vectors_config=VectorParams(size=768, distance=Distance.COSINE),
    hnsw_config=HnswConfigDiff(m=16, ef_construct=200),
    optimizers_config={"memmap_threshold": 20000},
)

BATCH = 1000
total = 12_000_000
for start in range(0, total, BATCH):
    n = min(BATCH, total - start)
    vecs = np.random.rand(n, 768).astype(np.float32)
    vecs /= np.linalg.norm(vecs, axis=1, keepdims=True)
    points = [
        PointStruct(
            id=start + i,
            vector=vecs[i].tolist(),
            payload={
                "category_id": int(np.random.randint(0, 200)),
                "price": float(np.random.rand() * 1000),
            },
        )
        for i in range(n)
    ]
    client.upsert(collection_name="products", points=points)

# 建 payload 索引
client.create_payload_index("products", "category_id", "integer")
client.create_payload_index("products", "price", "float")

qvec = np.random.rand(768).astype(np.float32)
qvec /= np.linalg.norm(qvec)

flt = Filter(must=[
    FieldCondition(key="category_id", match=MatchValue(value=12)),
    FieldCondition(key="price", range=Range(lt=300)),
])

t0 = time.time()
hits = client.search(
    collection_name="products",
    query_vector=qvec.tolist(),
    query_filter=flt,
    limit=50,
    search_params={"hnsw_ef": 128},
)
print(f"Qdrant latency: {(time.time()-t0)*1000:.2f} ms")