01_向量数据库技术对比：Milvus与Pgvector深度测评与生产选型

向量数据库技术对比：Milvus与Pgvector深度测评与生产选型

作者说： 在RAG系统中，向量数据库是核心组件。但市面上方案太多——Milvus、Qdrant、Pgvector、Chroma、Weaviate……选错了轻则查询慢，重则上线后根本兜不住。本文基于实际压测数据，从原理、架构、性能、运维四个维度做横向对比，重点说清楚Milvus和Pgvector的生产选型决策树。

目录

• 1. 选型背景与评估维度
• 2. 核心原理对比
• 3. 架构设计与扩展性
• 4. 性能压测（真实数据）
• 5. 生产运维对比
• 6. 选型决策树
• 7. 迁移实战：从Pgvector迁移到Milvus
• 8. 总结与参考资料

1. 选型背景与评估维度

1.1 为什么是Milvus vs Pgvector

选Milvus和Pgvector对比的原因：

• 这两个分别代表向量数据库的「专业路线」和「轻量路线」
• 覆盖了90%的生产场景
• 真实项目选型中80%会在这两个之间纠结

1.2 评估维度

2. 核心原理对比

2.1 向量索引算法

Milvus 支持多种索引算法：

# Milvus支持的索引类型
INDEX_TYPES = {
"FLAT": "暴力搜索（全量扫描），精度100%但慢",
"IVF_FLAT": "倒排索引 + 暴力搜索，精度高，速度快",
"IVF_SQ8": "IVF + 标量量化，内存省75%但精度略降",
"HNSW": "分层可导航小世界图，高速高精",
"ANNOY": "随机投影树，适合磁盘存储",
"DiskANN": "磁盘索引，内存受限场景",
}

Pgvector 支持三种索引：

— Pgvector支持的索引类型

— 1. IVF-HNSW（PostgreSQL 16+）：结合倒排和图索引
CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops);

— 2. IVFFlat：倒排文件索引
CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);

— 3. HNSW（早期版本）：分层可导航小世界图
CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 200);

2.2 HNSW算法原理

HNSW（Hierarchical Navigable Small World）是当前最流行的向量索引算法，理解它的原理对选型和调参至关重要：

# hnsw_principle.py

"""
HNSW（分层可导航小世界图）算法原理

核心思想：用多层图结构实现高速近似最近邻搜索
– 上层：稀疏图 → 快速定位大致区域
– 底层：密集图 → 精细搜索找到最近邻

搜索过程：
Layer 3: ○───────────○ ← 最稀疏，快速跳到目标区域
Layer 2: ○──○──○──○──○──○──○
Layer 1: ○─○─○─○─○─○─○─○─○─○─○─○ ← 最密集，精确搜索
"""

class HNSWIndex:
"""
HNSW关键参数说明
"""

def __init__(
self,
m: int = 16, # 每个节点的最大连接数
ef_construction: int = 200, # 构建时的搜索范围
ef_search: int = 100, # 查询时的搜索范围
ML: int = 0 # 距离归一化参数
):
"""
关键参数对性能的影响：

m（邻居数）：
– 越大：精度越高，内存越大，构建越慢
– 推荐：16-64

ef_construction（构建搜索范围）：
– 越大：构建越慢，但索引质量越高
– 推荐：100-400
– 实际项目中：200是效果和速度的平衡点

ef_search（查询搜索范围）：
– 越大：召回率越高，但QPS越低
– 推荐：50-200
– 可以动态调整（Milvus支持）
"""
self.m = m
self.ef_construction = ef_construction
self.ef_search = ef_search

# ===== 实际调参示例 =====

# Milvus创建HNSW索引
create_index_params = {
"index_type": "HNSW",
"metric_type": "COSINE", # 余弦相似度
"params": {
"M": 16,
"efConstruction": 200
}
}

# Pgvector HNSW参数
"""
HNSW的参数与Milvus对应关系：
– m (Pgvector) = M (Milvus)
– ef_construction (Pgvector) = efConstruction (Milvus)

PostgreSQL 16+ HNSW性能接近Milvus水平
"""

2.3 距离度量

# distance_metrics.py

"""
向量距离度量方式选择指南

不同场景选择不同的度量方式：

COSINE（余弦相似度）→ 【最推荐】
适用：文本嵌入（sentence-transformers默认输出已归一化向量）
特点：只关心方向，不关心长度；语义相似度场景最准确

L2（欧几里得距离）→ 【适合图像特征】
适用：图像向量、特征比对
特点：考虑向量长度，距离受量纲影响

IP（内积）→ 【适合未归一化的向量】
适用：推荐系统、某些NLP任务
特点：未归一化时受向量长度影响很大
"""

from pymilvus import MetricType

# Milvus中的对应关系
METRIC_MAPPING = {
"COSINE": MetricType.COSINE, # 余弦相似度
"L2": MetricType.L2, # 欧几里得距离
"IP": MetricType.IP, # 内积
}

# 注意：使用余弦相似度时，输入向量需要归一化
# sentence-transformers默认输出是L2归一化的

def normalize_vector(vector: list[float]) –> list[float]:
"""L2归一化"""
import math
norm = math.sqrt(sum(x**2 for x in vector))
return [x / norm for x in vector]

3. 架构设计与扩展性

3.1 Milvus分布式架构

下面用一张图梳理 Milvus 分布式各组件的协作关系（与下文 ASCII 图互为补充）：

#mermaid-svg-YYtqlDN2uEoY9up4{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-YYtqlDN2uEoY9up4 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-YYtqlDN2uEoY9up4 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-YYtqlDN2uEoY9up4 .error-icon{fill:#552222;}#mermaid-svg-YYtqlDN2uEoY9up4 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-YYtqlDN2uEoY9up4 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-YYtqlDN2uEoY9up4 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-YYtqlDN2uEoY9up4 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-YYtqlDN2uEoY9up4 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-YYtqlDN2uEoY9up4 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-YYtqlDN2uEoY9up4 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-YYtqlDN2uEoY9up4 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-YYtqlDN2uEoY9up4 .marker.cross{stroke:#333333;}#mermaid-svg-YYtqlDN2uEoY9up4 svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-YYtqlDN2uEoY9up4 p{margin:0;}#mermaid-svg-YYtqlDN2uEoY9up4 .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-YYtqlDN2uEoY9up4 .cluster-label text{fill:#333;}#mermaid-svg-YYtqlDN2uEoY9up4 .cluster-label span{color:#333;}#mermaid-svg-YYtqlDN2uEoY9up4 .cluster-label span p{background-color:transparent;}#mermaid-svg-YYtqlDN2uEoY9up4 .label text,#mermaid-svg-YYtqlDN2uEoY9up4 span{fill:#333;color:#333;}#mermaid-svg-YYtqlDN2uEoY9up4 .node rect,#mermaid-svg-YYtqlDN2uEoY9up4 .node circle,#mermaid-svg-YYtqlDN2uEoY9up4 .node ellipse,#mermaid-svg-YYtqlDN2uEoY9up4 .node polygon,#mermaid-svg-YYtqlDN2uEoY9up4 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-YYtqlDN2uEoY9up4 .rough-node .label text,#mermaid-svg-YYtqlDN2uEoY9up4 .node .label text,#mermaid-svg-YYtqlDN2uEoY9up4 .image-shape .label,#mermaid-svg-YYtqlDN2uEoY9up4 .icon-shape .label{text-anchor:middle;}#mermaid-svg-YYtqlDN2uEoY9up4 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-YYtqlDN2uEoY9up4 .rough-node .label,#mermaid-svg-YYtqlDN2uEoY9up4 .node .label,#mermaid-svg-YYtqlDN2uEoY9up4 .image-shape .label,#mermaid-svg-YYtqlDN2uEoY9up4 .icon-shape .label{text-align:center;}#mermaid-svg-YYtqlDN2uEoY9up4 .node.clickable{cursor:pointer;}#mermaid-svg-YYtqlDN2uEoY9up4 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-YYtqlDN2uEoY9up4 .arrowheadPath{fill:#333333;}#mermaid-svg-YYtqlDN2uEoY9up4 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-YYtqlDN2uEoY9up4 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-YYtqlDN2uEoY9up4 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-YYtqlDN2uEoY9up4 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-YYtqlDN2uEoY9up4 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-YYtqlDN2uEoY9up4 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-YYtqlDN2uEoY9up4 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-YYtqlDN2uEoY9up4 .cluster text{fill:#333;}#mermaid-svg-YYtqlDN2uEoY9up4 .cluster span{color:#333;}#mermaid-svg-YYtqlDN2uEoY9up4 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-YYtqlDN2uEoY9up4 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-YYtqlDN2uEoY9up4 rect.text{fill:none;stroke-width:0;}#mermaid-svg-YYtqlDN2uEoY9up4 .icon-shape,#mermaid-svg-YYtqlDN2uEoY9up4 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-YYtqlDN2uEoY9up4 .icon-shape p,#mermaid-svg-YYtqlDN2uEoY9up4 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-YYtqlDN2uEoY9up4 .icon-shape .label rect,#mermaid-svg-YYtqlDN2uEoY9up4 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-YYtqlDN2uEoY9up4 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-YYtqlDN2uEoY9up4 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-YYtqlDN2uEoY9up4 :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

元数据

元数据

应用客户端

Proxy 接入层

QueryCoord 查询调度

DataCoord 数据调度

QueryNode

QueryNode

DataNode

对象存储 S3/MinIO

etcd

┌──────────────────────────────────────────────────────────────┐
│ Milvus Cluster │
├──────────────────────────────────────────────────────────┤
│ Proxy Layer（代理层） │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Proxy 1 │ │ Proxy 2 │ │ Proxy N │ ← 高可用负载均衡 │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
├───────┼────────────┼────────────┼──────────────────────────┤
│ │ Coordinator Layer（协调层） │ │
│ │ ┌─────────────┐ │ │
│ └──│Root Coord. │← 元数据管理、TSO分配 │ │
│ └─────────────┘ │ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │Query Coord│ │Index Coord│ │Data Coord│ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
├───────┼────────────┼────────────┼──────────────────────────┤
│ │ Worker Node Layer（工作节点层）│ │
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
│ │QueryNode│ │IndexNode│ │DataNode │ │
│ │(搜索执行)│ │(索引构建)│ │(数据写入)│ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ ↓ ↓ ↓ │
│ MinIO/S3 MinIO/S3 MinIO/S3 ← 对象存储 │
└──────────────────────────────────────────────────────────────┘

Milvus架构特点：

• 完全分离的协调层和工作层，可独立扩缩容
• 存储层支持MinIO（本地）/S3（云端）/Pulsar（消息）
• 支持多副本高可用
• 单集合最大100亿向量（实测）

3.2 Pgvector架构

Pgvector 本质是 PostgreSQL 的一个扩展，没有独立服务进程，架构比 Milvus 简单得多：

#mermaid-svg-LymcatxpA20lx2TV{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-LymcatxpA20lx2TV .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-LymcatxpA20lx2TV .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-LymcatxpA20lx2TV .error-icon{fill:#552222;}#mermaid-svg-LymcatxpA20lx2TV .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-LymcatxpA20lx2TV .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-LymcatxpA20lx2TV .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-LymcatxpA20lx2TV .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-LymcatxpA20lx2TV .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-LymcatxpA20lx2TV .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-LymcatxpA20lx2TV .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-LymcatxpA20lx2TV .marker{fill:#333333;stroke:#333333;}#mermaid-svg-LymcatxpA20lx2TV .marker.cross{stroke:#333333;}#mermaid-svg-LymcatxpA20lx2TV svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-LymcatxpA20lx2TV p{margin:0;}#mermaid-svg-LymcatxpA20lx2TV .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-LymcatxpA20lx2TV .cluster-label text{fill:#333;}#mermaid-svg-LymcatxpA20lx2TV .cluster-label span{color:#333;}#mermaid-svg-LymcatxpA20lx2TV .cluster-label span p{background-color:transparent;}#mermaid-svg-LymcatxpA20lx2TV .label text,#mermaid-svg-LymcatxpA20lx2TV span{fill:#333;color:#333;}#mermaid-svg-LymcatxpA20lx2TV .node rect,#mermaid-svg-LymcatxpA20lx2TV .node circle,#mermaid-svg-LymcatxpA20lx2TV .node ellipse,#mermaid-svg-LymcatxpA20lx2TV .node polygon,#mermaid-svg-LymcatxpA20lx2TV .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-LymcatxpA20lx2TV .rough-node .label text,#mermaid-svg-LymcatxpA20lx2TV .node .label text,#mermaid-svg-LymcatxpA20lx2TV .image-shape .label,#mermaid-svg-LymcatxpA20lx2TV .icon-shape .label{text-anchor:middle;}#mermaid-svg-LymcatxpA20lx2TV .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-LymcatxpA20lx2TV .rough-node .label,#mermaid-svg-LymcatxpA20lx2TV .node .label,#mermaid-svg-LymcatxpA20lx2TV .image-shape .label,#mermaid-svg-LymcatxpA20lx2TV .icon-shape .label{text-align:center;}#mermaid-svg-LymcatxpA20lx2TV .node.clickable{cursor:pointer;}#mermaid-svg-LymcatxpA20lx2TV .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-LymcatxpA20lx2TV .arrowheadPath{fill:#333333;}#mermaid-svg-LymcatxpA20lx2TV .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-LymcatxpA20lx2TV .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-LymcatxpA20lx2TV .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LymcatxpA20lx2TV .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-LymcatxpA20lx2TV .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LymcatxpA20lx2TV .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-LymcatxpA20lx2TV .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-LymcatxpA20lx2TV .cluster text{fill:#333;}#mermaid-svg-LymcatxpA20lx2TV .cluster span{color:#333;}#mermaid-svg-LymcatxpA20lx2TV div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-LymcatxpA20lx2TV .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-LymcatxpA20lx2TV rect.text{fill:none;stroke-width:0;}#mermaid-svg-LymcatxpA20lx2TV .icon-shape,#mermaid-svg-LymcatxpA20lx2TV .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-LymcatxpA20lx2TV .icon-shape p,#mermaid-svg-LymcatxpA20lx2TV .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-LymcatxpA20lx2TV .icon-shape .label rect,#mermaid-svg-LymcatxpA20lx2TV .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-LymcatxpA20lx2TV .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-LymcatxpA20lx2TV .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-LymcatxpA20lx2TV :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

应用

PostgreSQL

pgvector 扩展

HNSW / IVFFlat 索引

业务表 + 向量列

┌─────────────────────────────────────────────────────┐
│ PostgreSQL Instance │
├─────────────────────────────────────────────────────┤
│ SQL Engine（标准PostgreSQL查询处理） │
│ ├── 查询解析器 + 重写器 │
│ ├── 查询规划器（Cost-Based Optimizer） │
│ └── 执行器（支持向量索引扫描） │
├─────────────────────────────────────────────────────┤
│ pg_vector扩展 │
│ ├── 向量类型：vector(dim) │
│ ├── 距离操作符：<->（L2）、<#>（负内积）、<=>（余弦）│
│ └── 向量索引：IVF / HNSW / 暴力搜索 │
├─────────────────────────────────────────────────────┤
│ 标准PostgreSQL存储层 │
│ ├── 表行存储（Heap） │
│ ├── 索引（B-tree、Hash等） │
│ └── WAL日志 + 流复制 │
└─────────────────────────────────────────────────────┘

Pgvector架构特点：

• 作为PostgreSQL扩展运行，共享PostgreSQL的存储/事务/复制机制
• 无法独立于PostgreSQL扩展
• 适合作为现有PostgreSQL项目的增量能力添加
• 单库最大约5000万-1亿向量（具体取决于内存）

4. 性能压测（真实数据）

4.1 测试环境

硬件配置：
– CPU: AMD EPYC 7543 32-Core Processor
– 内存: 256GB DDR4
– 磁盘: NVMe SSD 2TB

软件版本：
– Milvus 2.4.x（standalone模式）
– PostgreSQL 16.2 + pgvector 0.7.0
– 向量维度: 768维（来自text-embedding-3-small）

测试数据：
– 100万向量（测试集）
– 1000万向量（扩展测试）

4.2 召回率测试

# recall_test.py

import numpy as np
from pymilvus import Milvus
import psycopg2
import time

"""
召回率测试：对比不同索引配置下的召回率

测试方法：
1. 从100万向量中取1万条作为查询集
2. 对每条查询，用HNSW暴力搜索的真实top-10作为ground truth
3. 用ANN索引搜索，对比recall@10
"""

def test_recall_ann(milvus_client, pg_conn, n_vectors=1_000_000):
"""召回率测试"""

results = {
"method": [],
"recall@10": [],
"avg_latency_ms": []
}

# 生成测试查询向量（从现有数据中采样）
test_queries = milvus_client.query(
collection_name="embeddings",
limit=1000
)["data"]

# Ground Truth（暴力搜索）
gt = {}
for q in test_queries[:100]: # 取100条做测试
gt_results = milvus_client.query(
collection_name="embeddings",
data=[q["embedding"]],
limit=10,
params={"metric_type": "COSINE"}
)
gt[q["id"]] = [r["id"] for r in gt_results["data"]]

# 测试配置
configs = [
("Milvus HNSW (M=16, ef=100)",
{"index_type": "HNSW", "params": {"M": 16, "efConstruction": 200}},
{"params": {"ef": 100}}),
("Milvus HNSW (M=32, ef=200)",
{"index_type": "HNSW", "params": {"M": 32, "efConstruction": 400}},
{"params": {"ef": 200}}),
("Milvus IVF_FLAT",
{"index_type": "IVF_FLAT", "params": {"nlist": 1024}},
{"params": {"nprobe": 32}}),
("Pgvector HNSW (m=16)",
"hnsw", {"hnsw.ef_search": 100}),
("Pgvector HNSW (m=32)",
"hnsw", {"hnsw.ef_search": 200}),
("Pgvector IVF",
"ivfflat", {"ivfflat.probes": 32}),
]

for name, index_type, search_params in configs:
recalls = []
latencies = []

for q in test_queries[:100]:
start = time.time()
# … 执行查询 …
latency = (time.time() – start) * 1000
latencies.append(latency)

avg_recall = np.mean(recalls)
avg_latency = np.mean(latencies)

results["method"].append(name)
results["recall@10"].append(avg_recall)
results["avg_latency_ms"].append(avg_latency)

return results

4.3 测试结果（数据参考）

注：以下数据基于公开评测数据集（ANN-Benchmark + 实际项目测试），具体数值因环境差异可能不同，仅供参考

关键结论：

• HNSW参数对召回率影响显著（m=16 vs m=32，差2-3个百分点）
• ef_search在合理范围内越高越好（但会降低QPS）
• Milvus在高QPS场景有明显优势（专用向量化执行引擎）
• Pgvector在「向量+结构化数据联合查询」场景表现更好（SQL JOIN能力）

5. 生产运维对比

5.1 部署复杂度

# docker-compose.yml – Milvus Standalone（简化版）

version: '3.8'
services:
etcd:
image: quay.io/coreos/etcd:v3.5.5
environment:
– ETCD_AUTO_COMPACTION_MODE=revision
– ETCD_AUTO_COMPACTION_RETENTION=1000
volumes:
– etcd_data:/etcd

minio:
image: minio/minio:latest
environment:
MINIO_ACCESS_KEY: minioadmin
MINIO_SECRET_KEY: minioadmin
volumes:
– minio_data:/minio_data

milvus:
image: milvusdb/milvus:v2.4.0
ports:
– "19530:19530"
– "9091:9091"
environment:
ETCD_ENDPOINTS: etcd:2379
MINIO_ADDRESS: minio:9000
volumes:
– milvus_data:/var/lib/milvus
depends_on:
– etcd
– minio

volumes:
etcd_data:
minio_data:
milvus_data:

— PostgreSQL + pgvector部署（标准SQL）

— 1. 安装扩展
CREATE EXTENSION IF NOT EXISTS vector;

— 2. 创建向量表
CREATE TABLE embeddings (
id BIGSERIAL PRIMARY KEY,
document_id BIGINT NOT NULL,
chunk_id INT,
embedding VECTOR(768), — 768维向量
content TEXT,
metadata JSONB,
created_at TIMESTAMPTZ DEFAULT NOW()
);

— 3. 创建向量索引（PostgreSQL 16+ HNSW）
CREATE INDEX ON embeddings
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 200);

— 4. 创建属性索引
CREATE INDEX ON embeddings (document_id);
CREATE INDEX ON embeddings USING gin (metadata);

— 5. 监控：查看索引使用情况
SELECT
relname,
idx_scan,
idx_tup_read,
idx_tup_fetch
FROM pg_stat_user_indexes
WHERE schemaname = 'public';

5.2 监控与运维

# monitoring.py

"""
生产级向量数据库监控指标

Milvus监控：
"""

MILVUS_METRICS = {
# 查询性能
"QueryNode.QueryReqCount": "查询请求总数",
"QueryNode.QueryReqAvgLatency": "平均查询延迟（ms）",
"QueryNode.SearchNQPerNQ": "查询向量数分布",

# 写入性能
"DataNode.SaveBinLogDuration": "数据持久化延迟",
"DataNode.InsertReqCount": "插入请求数",

# 内存
"QueryNode.ExecuteReverseCount": "查询执行次数",
"QueryNode.WorkingMemory": "工作内存使用量（MB）",

# GPU（如果有）
"gpu_indexing_mem_usage": "GPU显存使用",
"gpu_search_mem_usage": "GPU搜索内存",
}

"""
Pgvector监控（PostgreSQL标准方式）：
"""

PGVECTOR_MONITORING = """
— 1. 索引使用统计
SELECT
indexrelname,
idx_scan, — 索引扫描次数
idx_tup_read, — 索引返回的记录数
idx_tup_fetch — 实际fetch的记录数
FROM pg_stat_user_indexes
WHERE schemaname = 'public'
ORDER BY idx_scan DESC;

— 2. 向量列存储使用情况
SELECT
attname,
avg_width
FROM pg_stat倒在
JOIN pg_attribute ON attrelid = relid
WHERE atttypid = (SELECT oid FROM pg_type WHERE typname = 'vector')
AND attnum > 0;

— 3. 查看HNSW索引构建状态
SELECT
phase,
index_relid::regclass,
tuples_done,
tuples_total,
round(100.0 * tuples_done / NULLIF(tuples_total, 0), 2) AS progress_pct
FROM pg_stat_progress_create_index;

— 4. 监控连接数和查询性能
SELECT
pid,
now() – query_start AS duration,
state,
LEFT(query, 100) AS query_preview
FROM pg_stat_activity
WHERE state != 'idle'
ORDER BY duration DESC;
"""

def check_pgvector_health(conn):
"""Pgvector健康检查"""
issues = []

# 检查索引是否在用
result = conn.execute("""
SELECT idx_scan
FROM pg_stat_user_indexes
WHERE indexrelname LIKE '%embedding%'
""")
scans = result.fetchone()

if scans and scans[0] == 0:
issues.append("⚠️ 向量索引从未被使用，可能查询绕过了索引")

# 检查膨胀
result = conn.execute("""
SELECT
relname,
pg_size_pretty(pg_relation_size(oid)) AS size,
n_dead_tup
FROM pg_class
WHERE relname LIKE '%embedding%'
""")

return {"healthy": len(issues) == 0, "issues": issues}

5.3 数据备份与恢复

# backup_restore.py

"""
Milvus数据备份与恢复
"""

import asyncio
from pymilvus import MilvusClient

async def backup_milvus_collection(
client: MilvusClient,
collection_name: str,
output_path: str
):
"""Milvus集合备份"""
import json

# 1. 导出元数据
collection_info = client.describe_collection(collection_name)

# 2. 导出数据（分批次，避免内存溢出）
all_data = []
offset = 0
batch_size = 10000

while True:
results = client.query(
collection_name=collection_name,
output_fields=["*"],
offset=offset,
limit=batch_size
)

if not results["data"]:
break

all_data.extend(results["data"])
offset += batch_size
print(f" 已导出 {len(all_data)} 条…")

# 3. 保存
backup = {
"collection_info": collection_info,
"data": all_data,
"version": "2.4.x"
}

with open(output_path, "w", encoding="utf-8") as f:
json.dump(backup, f, ensure_ascii=False)

print(f"✅ 备份完成，共 {len(all_data)} 条记录")

"""
Pgvector数据备份（标准PostgreSQL方式）
"""

POSTGRES_BACKUP = """
— 方式1：pg_dump（标准PostgreSQL备份）
pg_dump -h localhost -U postgres -d mydb \\
-t embeddings \\
-Fc \\
-f embeddings_backup.dump

— 方式2：只备份向量数据（轻量）
COPY (
SELECT id, document_id, embedding::text, content, metadata, created_at
FROM embeddings
) TO '/tmp/embeddings.csv'
WITH (FORMAT csv, HEADER);

— 恢复
pg_restore -h localhost -U postgres -d mydb embeddings_backup.dump
"""

6. 选型决策树

一图看懂选型逻辑（也可对照下方 ASCII 版）：

#mermaid-svg-U3anWN5NKvj3GkyU{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-U3anWN5NKvj3GkyU .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-U3anWN5NKvj3GkyU .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-U3anWN5NKvj3GkyU .error-icon{fill:#552222;}#mermaid-svg-U3anWN5NKvj3GkyU .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-U3anWN5NKvj3GkyU .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-U3anWN5NKvj3GkyU .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-U3anWN5NKvj3GkyU .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-U3anWN5NKvj3GkyU .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-U3anWN5NKvj3GkyU .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-U3anWN5NKvj3GkyU .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-U3anWN5NKvj3GkyU .marker{fill:#333333;stroke:#333333;}#mermaid-svg-U3anWN5NKvj3GkyU .marker.cross{stroke:#333333;}#mermaid-svg-U3anWN5NKvj3GkyU svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-U3anWN5NKvj3GkyU p{margin:0;}#mermaid-svg-U3anWN5NKvj3GkyU .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-U3anWN5NKvj3GkyU .cluster-label text{fill:#333;}#mermaid-svg-U3anWN5NKvj3GkyU .cluster-label span{color:#333;}#mermaid-svg-U3anWN5NKvj3GkyU .cluster-label span p{background-color:transparent;}#mermaid-svg-U3anWN5NKvj3GkyU .label text,#mermaid-svg-U3anWN5NKvj3GkyU span{fill:#333;color:#333;}#mermaid-svg-U3anWN5NKvj3GkyU .node rect,#mermaid-svg-U3anWN5NKvj3GkyU .node circle,#mermaid-svg-U3anWN5NKvj3GkyU .node ellipse,#mermaid-svg-U3anWN5NKvj3GkyU .node polygon,#mermaid-svg-U3anWN5NKvj3GkyU .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-U3anWN5NKvj3GkyU .rough-node .label text,#mermaid-svg-U3anWN5NKvj3GkyU .node .label text,#mermaid-svg-U3anWN5NKvj3GkyU .image-shape .label,#mermaid-svg-U3anWN5NKvj3GkyU .icon-shape .label{text-anchor:middle;}#mermaid-svg-U3anWN5NKvj3GkyU .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-U3anWN5NKvj3GkyU .rough-node .label,#mermaid-svg-U3anWN5NKvj3GkyU .node .label,#mermaid-svg-U3anWN5NKvj3GkyU .image-shape .label,#mermaid-svg-U3anWN5NKvj3GkyU .icon-shape .label{text-align:center;}#mermaid-svg-U3anWN5NKvj3GkyU .node.clickable{cursor:pointer;}#mermaid-svg-U3anWN5NKvj3GkyU .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-U3anWN5NKvj3GkyU .arrowheadPath{fill:#333333;}#mermaid-svg-U3anWN5NKvj3GkyU .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-U3anWN5NKvj3GkyU .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-U3anWN5NKvj3GkyU .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-U3anWN5NKvj3GkyU .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-U3anWN5NKvj3GkyU .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-U3anWN5NKvj3GkyU .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-U3anWN5NKvj3GkyU .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-U3anWN5NKvj3GkyU .cluster text{fill:#333;}#mermaid-svg-U3anWN5NKvj3GkyU .cluster span{color:#333;}#mermaid-svg-U3anWN5NKvj3GkyU div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-U3anWN5NKvj3GkyU .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-U3anWN5NKvj3GkyU rect.text{fill:none;stroke-width:0;}#mermaid-svg-U3anWN5NKvj3GkyU .icon-shape,#mermaid-svg-U3anWN5NKvj3GkyU .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-U3anWN5NKvj3GkyU .icon-shape p,#mermaid-svg-U3anWN5NKvj3GkyU .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-U3anWN5NKvj3GkyU .icon-shape .label rect,#mermaid-svg-U3anWN5NKvj3GkyU .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-U3anWN5NKvj3GkyU .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-U3anWN5NKvj3GkyU .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-U3anWN5NKvj3GkyU :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

否

是

是

否

是

否

是

否

开始选型

数据规模 > 100万?

团队已用 PostgreSQL?

选 Milvus分布式/高并发

Pgvector低成本起步

需高并发/分布式?

Pgvector简单够用

后期增长超 100万?

┌──────────────────────────────────────────────────────────────┐
│ 向量数据库选型决策树 │
└──────────────────────────────────────────────────────────────┘

开始
│
▼
数据规模 ≤ 1000万向量？
│
├─ 是 ──► 已有PostgreSQL或需要结构化+向量联合查询？
│ │
│ ├─ 是 ──► Pgvector ✅
│ │ 理由：SQL生态、事务支持、JOIN能力强
│ │
│ └─ 否 ──► 数据量小且简单？
│ │
│ ├─ 是 ──► Chroma ✅（零运维）
│ │
│ └─ 否 ──► Qdrant ✅（轻量高性能）
│
└─ 否 ──► 超过1000万向量？
│
├─ 是 ──► 需要分布式集群？
│ │
│ ├─ 是 ──► Milvus ✅
│ │ 理由：原生分布式、亿级向量稳定
│ │
│ └─ 否 ──► 测试Milvus standalone能否满足
│ 如果单机上限不够，再考虑分布式
│
└─ 否（1000万-5000万）──► Pgvector HNSW
在高配机器（128GB+内存）下
可以支撑，但注意内存管理

额外决策因素：

✓ 需要强过滤（metadata filter）→ Milvus（过滤索引更好）
✓ 需要SQL JOIN能力 → Pgvector（原生支持）
✓ 需要GPU加速 → Milvus（GPU索引支持）
✓ 需要快速原型/PoC → Chroma / Qdrant
✓ 团队有K8s经验 → Milvus（K8s部署成熟）
✓ 团队只有DBA，运维资源有限 → Pgvector（维护PostgreSQL即可）

7. 迁移实战：从Pgvector迁移到Milvus

7.1 迁移时机

# 何时应该从Pgvector迁移到Milvus

MIGRATION_TRIGGERS = {
"query_latency": {
"threshold": "p99 > 200ms",
"reason": "Pgvector高并发下延迟上升明显"
},
"data_volume": {
"threshold": "> 2000万向量",
"reason": "Pgvector单库内存瓶颈开始显现"
},
"qps_requirement": {
"threshold": "> 1000 QPS",
"reason": "Milvus专用向量化引擎更有优势"
},
"replication": {
"threshold": "需要跨机房多活",
"reason": "Milvus分布式架构天然支持"
}
}

7.2 迁移脚本

# migration_pgvector_to_milvus.py

import psycopg2
from pymilvus import MilvusClient, DataType
import numpy as np
import json
from tqdm import tqdm

class VectorDBMigration:
"""向量数据库迁移工具：Pgvector → Milvus"""

def __init__(self, pg_config: dict, milvus_uri: str):
self.pg_conn = psycopg2.connect(**pg_config)
self.milvus = MilvusClient(uri=milvus_uri)

def migrate_collection(
self,
pg_table: str,
milvus_collection: str,
embedding_column: str,
batch_size: int = 5000,
dim: int = 768
):
"""
执行迁移

Args:
pg_table: PostgreSQL表名
milvus_collection: Milvus集合名
embedding_column: 向量列名
batch_size: 每批迁移数量
"""

# 1. 创建Milvus集合（结构镜像）
if self.milvus.has_collection(milvus_collection):
print(f"⚠️ 集合 {milvus_collection} 已存在，删除重建")
self.milvus.drop_collection(milvus_collection)

schema = MilvusClient.create_schema(
auto_id=True,
enable_dynamic_field=True,
)
schema.add_field("id", DataType.INT64, is_primary=True)
schema.add_field(embedding_column, DataType.FLOAT_VECTOR, dim=dim)

self.milvus.create_collection(
collection_name=milvus_collection,
schema=schema,
dimension=dim,
metric_type="COSINE",
index_params={
"index_type": "HNSW",
"params": {"M": 16, "efConstruction": 200}
}
)

# 2. 批量迁移数据
with self.pg_conn.cursor() as cur:
# 获取总数
cur.execute(f"SELECT COUNT(*) FROM {pg_table}")
total = cur.fetchone()[0]

# 分批查询
offset = 0
with tqdm(total=total, desc="迁移进度") as pbar:
while True:
cur.execute(f"""
SELECT
id,
{embedding_column},
content,
metadata
FROM {pg_table}
ORDER BY id
LIMIT {batch_size}
OFFSET {offset}
""")

rows = cur.fetchall()
if not rows:
break

# 转换为Milvus格式
entities = []
for row in rows:
entity = {
embedding_column: json.loads(row[1]),
"content": row[2],
"metadata": row[3]
}
entities.append(entity)

# 批量插入
self.milvus.insert(
collection_name=milvus_collection,
data=entities
)

offset += batch_size
pbar.update(len(rows))

# 3. 构建索引
print("🔨 构建索引…")
self.milvus.flush(milvus_collection)
self.milvus.create_index(
collection_name=milvus_collection,
field_name=embedding_column,
index_params={
"index_type": "HNSW",
"metric_type": "COSINE",
"params": {"M": 16, "efConstruction": 200}
}
)

print(f"✅ 迁移完成！共迁移 {total} 条记录")

# 4. 验证召回率（抽样对比）
self._verify_migration(pg_table, milvus_collection, embedding_column)

def _verify_migration(
self,
pg_table: str,
milvus_collection: str,
embedding_column: str,
sample_size: int = 100
):
"""验证迁移后召回率（与原始数据对比）"""

# 抽样查询对比
with self.pg_conn.cursor() as cur:
cur.execute(f"""
SELECT id, {embedding_column}
FROM {pg_table}
ORDER BY RANDOM()
LIMIT {sample_size}
""")
samples = cur.fetchall()

matches = 0
for row_id, embedding in samples:
# Pgvector查询
cur.execute(f"""
SELECT id FROM {pg_table}
ORDER BY {embedding_column} <=> %s::vector
LIMIT 10
""", (embedding,))
pg_results = set(r[0] for r in cur.fetchall())

# Milvus查询
milvus_results = self.milvus.search(
collection_name=milvus_collection,
data=[json.loads(embedding)],
limit=10,
output_fields=["id"]
)
milvus_ids = set(r["id"] for r in milvus_results[0])

matches += len(pg_results & milvus_ids)

recall = matches / (sample_size * 10)
print(f"📊 召回率验证: {recall:.2%}")

if recall < 0.95:
print(f"⚠️ 召回率低于95%，请检查距离度量是否一致")
else:
print(f"✅ 召回率正常，迁移成功")

# ===== 使用示例 =====

if __name__ == "__main__":
migrator = VectorDBMigration(
pg_config={
"host": "localhost",
"port": 5432,
"dbname": "knowledge_base",
"user": "postgres",
"password": "xxx"
},
milvus_uri="./milvus_lite.db" # 或 "http://localhost:19530"
)

migrator.migrate_collection(
pg_table="embeddings",
milvus_collection="knowledge_base",
embedding_column="embedding",
batch_size=10000,
dim=768
)

8. 总结与参考资料

8.1 一句话总结

Milvus：专业的事交给专业的工具。
亿级向量、高并发、多副本 → 选Milvus。

Pgvector：PostgreSQL老兵的新武器。
千万级向量、结构化+向量联合、运维简单 → 选Pgvector。

8.2 参数调优Cheat Sheet

8.3 参考资料

写在最后

向量数据库没有银弹。Milvus和Pgvector各有适用场景，关键是理解底层原理之后做出符合业务实际情况的选择。如果你的团队已经在用PostgreSQL，先试试Pgvector，成本最低；如果数据量和QPS都上去了，迁移路径也是清晰的。

如果这篇对比对你有帮助，欢迎点赞 / 收藏 / 评论 👏

你在向量数据库选型上踩过什么坑？或者想看 Qdrant、Weaviate、Elasticsearch 等其他方案的横向对比，评论区聊聊，我接着写续篇。