向量数据库 2026：从 pgvector 到专用向量数据库的完整对比指南

一句话结论：2026 年 RAG / Agent / 推荐系统离不开向量数据库。本文 6 大产品深度对比 + 选型决策树 + 4 个实战。

背景

2026 年 AI 应用爆发，向量数据库成为核心基础设施：

传统数据库（结构化）：
- MySQL / PostgreSQL
- 精确匹配
- B-Tree 索引

向量数据库（高维）：
- pgvector / Pinecone / Weaviate / Qdrant / Milvus / Chroma
- 语义匹配
- HNSW / IVF / PQ 索引

为什么 2026 年向量数据库爆发：

1. RAG 成为 LLM 标准：知识库增强
2. Agent 记忆：长期 + 短期 + 语义
3. 推荐系统：用户 / 内容匹配
4. 图像 / 视频搜索：CLIP / ViT 嵌入
5. 多模态 AI：统一向量空间

6 大产品对比

产品	类型	部署	适用场景	价格
pgvector	扩展	自建 / Supabase / Neon	已有 Postgres + 简单向量	免费
Pinecone	SaaS	全托管 Serverless	中大型 SaaS	$0.096/GB/月
Weaviate	开源 / SaaS	自建 / WCD	模块化 + GraphQL	免费 / $25/月
Qdrant	开源 / 云	自建 / Qdrant Cloud	高性能 + Rust	免费 / $25/月
Milvus	开源 / 云	自建 / Zilliz	超大规模 + GPU	免费 / $99/月
Chroma	开源	自建 / Chroma Cloud	轻量 + 嵌入式	免费

1. pgvector（PostgreSQL 扩展）

优势：

• ✅ 已有 PostgreSQL 直接用
• ✅ 事务 / JOIN / SQL 全部支持
• ✅ PostgreSQL 18 增强（关联 7/21）

限制：

• ❌ 大规模性能有限（10M+ 慢）
• ❌ 无专用索引优化

-- PostgreSQL 18 + pgvector 2.0（10 亿向量）
CREATE EXTENSION vector;

CREATE TABLE documents (
  id BIGSERIAL PRIMARY KEY,
  content TEXT,
  embedding VECTOR(1024)  -- 1024 维向量
);

-- HNSW 索引（高性能）
CREATE INDEX ON documents 
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);

-- 语义搜索
SELECT id, content, 
  embedding <=> $1 AS distance  -- 余弦距离
FROM documents
ORDER BY embedding <=> $1
LIMIT 10;

2. Pinecone（Serverless）

优势：

• ✅ 全托管，零运维
• ✅ Serverless 按需
• ✅ 全球低延迟

限制：

• ❌ 价格高
• ❌ 锁定厂商

// lib/pinecone.ts
import { Pinecone } from "@pinecone-database/pinecone";

const pc = new Pinecone({ apiKey: process.env.PINECONE_API_KEY });
const index = pc.index("my-index");

// Upsert
await index.upsert([
  {
    id: "doc-1",
    values: [0.1, 0.2, ...],  // 1024 维向量
    metadata: { source: "blog.xblz.org", title: "..." },
  },
]);

// Query
const result = await index.query({
  vector: queryEmbedding,
  topK: 10,
  includeMetadata: true,
});

3. Weaviate（开源 + 模块化）

优势：

• ✅ 模块化（向量化 / 检索 / 生成）
• ✅ GraphQL API
• ✅ 多租户支持
• ✅ 内置向量模型（vectorizer）

限制：

• ❌ 部署相对复杂

import weaviate from "weaviate-ts-client";

const client = weaviate.client({
  scheme: "https",
  host: "my-cluster.weaviate.network",
  apiKey: process.env.WEAVIATE_API_KEY,
});

// 创建 Schema
await client.schema.classCreator().withClass({
  class: "Article",
  vectorizer: "text2vec-openai",  // 自动向量化
  properties: [
    { name: "title", dataType: ["text"] },
    { name: "content", dataType: ["text"] },
  ],
}).do();

// 插入数据
await client.data.creator()
  .withClassName("Article")
  .withProperties({ title: "...", content: "..." })
  .do();

// 语义搜索
const result = await client.graphql
  .get()
  .withClassName("Article")
  .withFields("title content _additional { distance }")
  .withNearText({ concepts: ["AI Agent"] })
  .withLimit(10)
  .do();

4. Qdrant（高性能 Rust）

优势：

• ✅ Rust 性能极强
• ✅ 丰富过滤（地理位置 / 数值 / 标签）
• ✅ Hybrid Search（向量 + 全文）
• ✅ 资源占用低

限制：

• ❌ 生态相对小

import { QdrantClient } from "@qdrant/js-client-rest";

const client = new QdrantClient({ url: "http://localhost:6333" });

// 创建 Collection
await client.createCollection("articles", {
  vectors: { size: 1024, distance: "Cosine" },
  // 全文索引（Hybrid Search）
  sparse_vectors: { name: "bm25", modifier: "idf" },
});

// 插入
await client.upsert("articles", {
  points: [
    {
      id: 1,
      vector: { dense: [0.1, 0.2, ...], sparse: { indices: [10, 50], values: [0.5, 0.3] } },
      payload: { title: "...", category: "AI" },
    },
  ],
});

// Hybrid Search
const result = await client.search("articles", {
  vector: { name: "dense", vector: queryDense },
  sparse_vector: { name: "bm25", vector: querySparse },
  filter: { must: [{ key: "category", match: { value: "AI" } }] },
  limit: 10,
});

5. Milvus（超大规模）

优势：

• ✅ 100 亿+ 向量
• ✅ GPU 加速
• ✅ 分布式架构
• ✅ 多副本强一致

限制：

• ❌ 部署重
• ❌ 学习曲线陡

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

# 连接
connections.connect(host="localhost", port="19530")

# Schema
fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1024),
]
schema = CollectionSchema(fields=fields)
collection = Collection("articles", schema=schema)

# 索引
collection.create_index(
    field_name="embedding",
    index_params={
        "metric_type": "COSINE",
        "index_type": "IVF_PQ",  # 大规模必备
        "params": { "nlist": 1024, "m": 8 },
    },
)

# 搜索
collection.load()
results = collection.search(
    data=[query_embedding],
    anns_field="embedding",
    param={ "metric_type": "COSINE", "params": { "nprobe": 16 } },
    limit=10,
)

6. Chroma（轻量嵌入式）

优势：

• ✅ 极简 API
• ✅ 嵌入式（in-memory / SQLite / DuckDB）
• ✅ 适合原型 / 小规模

限制：

• ❌ 不适合生产大规模

import chromadb

# 嵌入式
client = chromadb.PersistentClient(path="./chroma")

# 创建 Collection
collection = client.create_collection("articles")

# 添加
collection.add(
    ids=["doc-1"],
    documents=["PostgreSQL 18 released"],
    embeddings=[[0.1, 0.2, ...]],
    metadatas=[{ "source": "blog.xblz.org" }],
)

# 搜索
results = collection.query(
    query_embeddings=[[0.3, 0.4, ...]],
    n_results=10,
)

选型决策树

你的向量规模？
├── < 10K     → Chroma（最简）
├── < 1M      → pgvector（已有 PG）
├── < 10M     → Weaviate / Qdrant
├── < 100M    → Pinecone / Qdrant Cloud
└── > 100M    → Milvus（超大规模）

你的部署偏好？
├── 自建 → Weaviate / Qdrant / Milvus
├── 托管 → Pinecone / WCD / Qdrant Cloud / Zilliz
└── 嵌入式 → Chroma

你的预算？
├── $0      → pgvector / Chroma / Weaviate 开源
├── $25/月  → Qdrant Cloud / WCD 标准版
└── $99+/月 → Pinecone / Zilliz

你的场景？
├── RAG       → Weaviate / Qdrant
├── Agent     → Pinecone（Serverless）
├── 推荐系统  → Milvus（大规模）
└── 简单搜索  → pgvector

4 个实战项目

项目 1：RAG 知识库（pgvector）

// lib/rag.ts
import { embed } from "ai";
import { openai } from "@ai-sdk/openai";
import { Pool } from "pg";

const db = new Pool({ connectionString: process.env.DATABASE_URL });

// 1. 嵌入文档
async function embedDocuments(docs: Document[]) {
  for (const doc of docs) {
    const { embedding } = await embed({
      model: openai.embedding("text-embedding-3-large"),
      value: doc.content,
    });
    
    await db.query(
      "INSERT INTO documents (content, embedding) VALUES ($1, $2)",
      [doc.content, embedding]
    );
  }
}

// 2. 检索 + 生成
async function rag(query: string) {
  // 嵌入查询
  const { embedding } = await embed({
    model: openai.embedding("text-embedding-3-large"),
    value: query,
  });
  
  // 检索 Top-10
  const { rows } = await db.query(
    `SELECT content, embedding <=> $1 AS distance
     FROM documents
     ORDER BY embedding <=> $1
     LIMIT 10`,
    [JSON.stringify(embedding)]
  );
  
  // 生成答案
  const context = rows.map(r => r.content).join("\n\n");
  const prompt = `
    基于以下上下文回答问题：
    
    ${context}
    
    问题：${query}
  `;
  
  return await generateText({ prompt });
}

项目 2：AI Agent 长期记忆（Qdrant）

# agent_memory.py
from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer

client = QdrantClient("localhost", port=6333)
model = SentenceTransformer("BAAI/bge-large-zh-v1.5")

# Collection：Agent 记忆
client.create_collection(
    collection_name="agent_memories",
    vectors_config={"size": 1024, "distance": "Cosine"},
)

# 存储记忆
def remember(user_id: str, content: str, importance: float = 0.5):
    embedding = model.encode(content)
    client.upsert(
        collection_name="agent_memories",
        points=[{
            "id": hash(content),
            "vector": embedding.tolist(),
            "payload": {
                "user_id": user_id,
                "content": content,
                "importance": importance,
                "timestamp": datetime.now().isoformat(),
            },
        }],
    )

# 检索相关记忆
def recall(user_id: str, query: str, top_k: int = 5):
    embedding = model.encode(query)
    results = client.search(
        collection_name="agent_memories",
        query_vector=embedding.tolist(),
        query_filter={"must": [{"key": "user_id", "match": {"value": user_id}}]},
        limit=top_k,
    )
    return [r.payload["content"] for r in results]

# 使用
remember("user-1", "用户喜欢 AI 编程工具")
recall("user-1", "用户的偏好")

项目 3：多租户推荐系统（Weaviate）

// lib/recommend.ts
import weaviate from "weaviate-ts-client";

const client = weaviate.client({ /* ... */ });

// 多租户 Schema
await client.schema.classCreator().withClass({
  class: "Product",
  vectorizer: "text2vec-openai",
  multiTenancy: { enabled: true },
  properties: [
    { name: "title", dataType: ["text"] },
    { name: "description", dataType: ["text"] },
    { name: "price", dataType: ["number"] },
  ],
}).do();

// 为每个租户添加 tenant
await client.schema.tenantsCreator("Product", [
  { name: "tenant-a" },
  { name: "tenant-b" },
]).do();

// 推荐（基于用户最近浏览）
async function recommend(userId: string, tenant: string) {
  const userHistory = await getUserHistory(userId);
  const lastViewEmbedding = await embed(userHistory[0]);
  
  return client.graphql
    .get()
    .withClassName("Product")
    .withTenant(tenant)  // 多租户
    .withFields("title description price _additional { distance }")
    .withNearVector({ vector: lastViewEmbedding })
    .withLimit(10)
    .do();
}

项目 4：图像语义搜索（Pinecone + CLIP）

# image_search.py
import pinecone
from transformers import CLIPProcessor, CLIPModel
from PIL import Image

# 初始化
pc = pinecone.Pinecone(api_key="...")
index = pc.Index("images")

model = CLIPModel.from_pretrained("openai/clip-vit-large-patch14")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")

# 嵌入图像
def embed_image(image_path):
    image = Image.open(image_path)
    inputs = processor(images=image, return_tensors="pt")
    outputs = model.get_image_features(**inputs)
    return outputs[0].detach().numpy().tolist()

# 嵌入文本（查询）
def embed_text(text):
    inputs = processor(text=[text], return_tensors="pt", padding=True)
    outputs = model.get_text_features(**inputs)
    return outputs[0].detach().numpy().tolist()

# 添加图像
for i, path in enumerate(image_paths):
    embedding = embed_image(path)
    index.upsert([(f"img-{i}", embedding, {"path": path})])

# 文本搜索图像
def search_by_text(query, top_k=10):
    query_embedding = embed_text(query)
    return index.query(
        vector=query_embedding,
        top_k=top_k,
        include_metadata=True,
    )

# 使用
results = search_by_text("a cat sitting on a beach")

5 个常见坑

坑 1：维度不匹配

❌ 嵌入模型输出 1536 维，索引设为 1024
✅ 维度必须匹配

坑 2：距离度量选错

- 余弦相似度（Cosine）：文本嵌入首选
- 欧氏距离（Euclidean）：图像嵌入
- 点积（Dot Product）：已归一化向量

坑 3：索引选错

- HNSW：通用首选（高精度 + 中等内存）
- IVF：超大规模（节省内存）
- PQ：超大规模（牺牲精度）

坑 4：不过滤元数据

❌ 全部返回再过滤
✅ 向量搜索时同时过滤（filter）

坑 5：不监控成本

❌ 100M 向量按全价收费
✅ Pinecone Serverless 按需 / pgvector 自建

与之前内容的关系

7/15 RAG + pgvector       → 向量数据库初识
7/21 PostgreSQL 18        → 数据库升级
8/4  Redis 8              → 缓存
8/8  MCP                  → AI 工具
8/12 向量数据库完整对比   → AI 数据层  ← 今天
→ "数据层 → 工具 → 协议"完整 AI 栈

7 天落地路径

Day 1：选型

基于规模 + 预算 + 场景决策

Day 2：本地启动

# Docker
docker run -d -p 6333:6333 qdrant/qdrant

Day 3：嵌入 + 存储

// 100 条文档

Day 4：搜索 + 评估

// Recall@10 / MRR

Day 5：RAG 集成

// 检索 + LLM 生成

Day 6：性能优化

索引 / 过滤 / 缓存

Day 7：生产部署

监控 / 备份 / 自动扩缩容

我的看法

向量数据库是 2026 年 AI 应用的"数据库"：

1. RAG 标准：所有 LLM 应用都需要
2. 多模态统一：文本 / 图像 / 视频统一向量
3. 专用 vs 通用：按规模选择
4. 生态成熟：6 大产品可选
5. 独立开发者友好：开源 + 免费

对独立开发者的建议：

• 小项目：pgvector（关联 7/15）
• 中型：Qdrant / Weaviate
• 大型：Pinecone / Milvus
• 快速原型：Chroma
• 多租户：Weaviate

参考

• pgvector
• Pinecone
• Weaviate
• Qdrant
• Milvus
• Chroma
• RAG + pgvector（7/15）
• PostgreSQL 18（7/21）
• Redis 8（8/4）
• MCP（8/8）

---

本文基于 2026 年向量数据库最新对比，2026 年 8 月完整选型指南。