向量数据库入门:常见方案、Docker Compose 部署、Java/Go 接入与 RAG 实战
本文详细解析了向量数据库在 AI 应用和 RAG 中的作用,对比了 Qdrant、pgvector、Redis Stack、Milvus、Weaviate、Chroma、
面向想学习 AI 应用开发、RAG、Agent、知识库系统的后端同学。本文会从概念讲起,对比常见向量数据库方案,给出 Mac 和 Linux/Ubuntu 上的 Docker Compose 部署方式,并介绍 Java、Go 如何入门接入。
1. 为什么 AI 应用需要向量数据库
传统数据库擅长回答确定性问题:
id = 1001的文章是哪篇?- 某个用户发布过多少篇文章?
- 标题包含“Spring Boot”的文章有哪些?
但 AI 应用里经常需要回答语义相似问题:
- “有没有和这段话意思相近的文章?”
- “用户问的问题,应该匹配知识库里的哪几段资料?”
- “这篇文章和历史文章是否重复?”
- “给我找一些适合写公众号选题的素材。”
这类问题不是简单的字符串匹配,而是语义匹配。做法通常是:
- 用 embedding 模型把文本变成向量。
- 把向量存入向量数据库。
- 查询时也把问题变成向量。
- 用向量相似度找最接近的内容。
例如一段文本可能被 embedding 成一个 768 维或 1536 维的浮点数组:
text
[0.012, -0.085, 0.231, ..., 0.044]
向量数据库要解决的核心问题就是:如何在大量向量里快速找到最相似的 TopK 条数据。
2. 向量数据库在 RAG 中的位置
RAG,全称 Retrieval-Augmented Generation,中文一般叫“检索增强生成”。
一个典型 RAG 流程如下:
text
文档上传
-> 文档解析
-> 文本清洗
-> 切分 chunk
-> 调 embedding 模型生成向量
-> 向量入库
用户提问
-> 问题 embedding
-> 向量数据库 TopK 检索
-> MySQL/PostgreSQL 查询 chunk 正文
-> 可选 rerank
-> 拼接 prompt
-> 大模型生成答案
推荐架构是:向量数据库只存向量和轻量 metadata,业务正文仍然放 MySQL/PostgreSQL。
text
MySQL/PostgreSQL
存 document、chunk、权限、用户、任务状态
向量数据库
存 chunkId、docId、userId、tags、embedding
大模型
负责总结、问答、改写、生成文章
这样做的好处是边界清晰:业务数据库负责事务和权限,向量数据库负责语义召回。
3. 常见向量数据库方案
常见方案可以分为三类。
第一类是专用向量数据库:
- Qdrant
- Milvus
- Weaviate
- Chroma
第二类是在已有数据库上扩展向量能力:
- PostgreSQL + pgvector
- Redis Stack / RediSearch
- OpenSearch / Elasticsearch kNN
第三类是云服务:
- Zilliz Cloud
- Qdrant Cloud
- Pinecone
- Weaviate Cloud
- 阿里云、腾讯云、火山等云向量检索服务
本文重点看适合个人学习和中小型项目的开源方案。
4. 方案对比
| 方案 | 类型 | 部署复杂度 | 资源占用 | 适合规模 | 适合场景 |
|---|---|---|---|---|---|
| Qdrant | 专用向量库 | 低 | 中低 | 几万到千万级 | RAG、语义搜索、推荐、学习项目 |
| pgvector | PostgreSQL 扩展 | 中 | 中 | 几万到百万级起步 | 已有 PG、业务数据和向量想放一起 |
| Redis Vector | Redis 搜索能力 | 中 | 内存较高 | 小到中型热数据 | 低延迟、热数据、会话记忆 |
| Milvus | 分布式向量库 | 高 | 较高 | 百万到亿级 | 大规模向量检索、生产集群 |
| Weaviate | 专用向量库 | 中 | 中 | 中大型 | 知识库、对象模型、GraphQL/REST |
| Chroma | 轻量向量库 | 低 | 低 | 小到中型 | 本地开发、Demo、原型验证 |
| OpenSearch kNN | 搜索引擎扩展 | 中高 | 中高 | 中大型 | 全文检索 + 向量混合搜索 |
如果是 8G 2核服务器、几千到一两万篇文章,推荐顺序:
text
Qdrant > pgvector > Chroma > Redis Vector > Weaviate > Milvus
如果目标是学习 AI 应用岗位,建议优先学 Qdrant 或 pgvector。Qdrant 更像专用向量数据库,pgvector 更适合理解“数据库 + 向量索引”的融合方式。
5. 数据量和资源估算
假设:
- 1 篇文章 2000 到 5000 字
- 每 800 到 1200 字切一个 chunk
- 1 篇文章大约 3 到 8 个 chunk
- embedding 维度为 1536
- 每个 float32 占 4 字节
原始向量大小:
text
向量条数 * 维度 * 4 字节
估算表:
| 文章数 | chunk 数 | 原始向量大小 | 实际磁盘估计 |
|---|---|---|---|
| 1000 篇 | 3000-8000 | 18-48 MB | 100-300 MB |
| 5000 篇 | 1.5万-4万 | 90-240 MB | 500 MB-2 GB |
| 1万篇 | 3万-8万 | 180-490 MB | 1-3 GB |
| 2万篇 | 6万-16万 | 360-980 MB | 2-6 GB |
实际占用会受索引、payload、WAL、压缩、segment、备份策略影响。对个人学习和小型项目来说,Qdrant 或 pgvector 都能承受。真正需要谨慎的是:不要把长正文、图片、附件全部塞进向量数据库。
6. Mac 和 Ubuntu 上部署前准备
Mac 推荐使用 Docker Desktop。Apple Silicon 芯片,也就是 M1/M2/M3,要优先选择支持 linux/arm64 的镜像。Qdrant、PostgreSQL、Redis Stack 这类一般比较友好;Milvus 组件较重,Mac 上学习可以尝试,但更推荐 Linux 服务器。
Ubuntu 安装 Docker 和 Compose:
bash
sudo apt update
sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
| sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
| sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
docker version
docker compose version
建议统一创建一个学习目录,并把 Docker 数据目录和 Compose 文件目录分开。我的习惯是:
- Mac 本地 Docker 数据目录:
/opt/docker/xxx - 线上 Linux/Ubuntu Docker 数据目录:
/mydata/xxx
可以统一用环境变量 VECTOR_DATA_ROOT 管理数据挂载路径。
Mac 本地:
bash
mkdir -p ~/vector-lab
mkdir -p /opt/docker/vector-lab
cd ~/vector-lab
export VECTOR_DATA_ROOT=/opt/docker/vector-lab
Linux/Ubuntu 线上:
bash
mkdir -p ~/vector-lab
sudo mkdir -p /mydata/vector-lab
sudo chown -R $USER:$USER /mydata/vector-lab
cd ~/vector-lab
export VECTOR_DATA_ROOT=/mydata/vector-lab
后面的 Compose 示例都使用 ${VECTOR_DATA_ROOT}。如果不想每次手动 export,可以在 ~/vector-lab/.env 里写:
bash
# Mac 本地
VECTOR_DATA_ROOT=/opt/docker/vector-lab
# 线上 Linux/Ubuntu 改成:
# VECTOR_DATA_ROOT=/mydata/vector-lab
7. Qdrant 部署和入门
官方文档:
- Qdrant 文档:https://qdrant.tech/documentation/
- Qdrant 安装:https://qdrant.tech/documentation/operations/installation/
- Qdrant API Reference:https://api.qdrant.tech/
- Qdrant Java Client:https://github.com/qdrant/java-client
- Qdrant Go Client:https://github.com/qdrant/go-client
Qdrant 官方文档说明它提供 HTTP API 端口 6333 和 gRPC 端口 6334,并支持 Docker 和 Docker Compose 部署。
创建 docker-compose.yml:
yaml
services:
qdrant:
image: qdrant/qdrant:latest
container_name: qdrant
restart: unless-stopped
ports:
- "6333:6333"
- "6334:6334"
volumes:
- ${VECTOR_DATA_ROOT}/qdrant:/qdrant/storage
environment:
QDRANT__SERVICE__HTTP_PORT: 6333
QDRANT__SERVICE__GRPC_PORT: 6334
启动:
bash
docker compose up -d
curl http://localhost:6333
创建 collection:
bash
curl -X PUT http://localhost:6333/collections/article_chunks \
-H 'Content-Type: application/json' \
-d '{
"vectors": {
"size": 1536,
"distance": "Cosine"
}
}'
写入一个向量:
bash
curl -X PUT http://localhost:6333/collections/article_chunks/points \
-H 'Content-Type: application/json' \
-d '{
"points": [
{
"id": 1,
"vector": [0.01, 0.02, 0.03],
"payload": {
"chunkId": 1001,
"docId": 101,
"userId": 1,
"source": "blog"
}
}
]
}'
上面只是演示,真实 size 是 1536 时,vector 必须传 1536 个数字。
Java 入门思路:
java
// 实际项目建议使用 qdrant 官方 Java client。
// 学习阶段也可以先用 HTTP Client 调 Qdrant REST API。
HttpClient client = HttpClient.newHttpClient();
String body = """
{
"vectors": {
"size": 1536,
"distance": "Cosine"
}
}
""";
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("http://localhost:6333/collections/article_chunks"))
.PUT(HttpRequest.BodyPublishers.ofString(body))
.header("Content-Type", "application/json")
.build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
Go 入门思路:
go
package main
import (
"bytes"
"fmt"
"net/http"
)
func main() {
body := []byte(`{
"vectors": {
"size": 1536,
"distance": "Cosine"
}
}`)
req, _ := http.NewRequest(http.MethodPut, "http://localhost:6333/collections/article_chunks", bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
fmt.Println(resp.Status)
}
学习建议:先用 REST API 跑通 collection、upsert、search,再换官方 Java/Go SDK。
8. PostgreSQL + pgvector 部署和入门
官方文档:
- pgvector:https://github.com/pgvector/pgvector
- pgvector Java:https://github.com/pgvector/pgvector-java
- pgvector Go:https://github.com/pgvector/pgvector-go
- PostgreSQL:https://www.postgresql.org/docs/
pgvector 是 PostgreSQL 的扩展,不是一个独立数据库。它给 PostgreSQL 增加 vector 类型和向量相似度搜索能力。
创建 docker-compose.yml:
yaml
services:
postgres:
image: pgvector/pgvector:pg16
container_name: pgvector
restart: unless-stopped
environment:
POSTGRES_DB: rag
POSTGRES_USER: rag
POSTGRES_PASSWORD: rag123456
ports:
- "5432:5432"
volumes:
- ${VECTOR_DATA_ROOT}/pgvector:/var/lib/postgresql/data
启动:
bash
docker compose up -d
docker exec -it pgvector psql -U rag -d rag
建表:
sql
CREATE EXTENSION IF NOT EXISTS vector;
CREATE TABLE article_chunk (
id BIGSERIAL PRIMARY KEY,
doc_id BIGINT NOT NULL,
chunk_text TEXT NOT NULL,
embedding vector(1536),
created_at TIMESTAMP DEFAULT now()
);
CREATE INDEX idx_article_chunk_embedding_hnsw
ON article_chunk
USING hnsw (embedding vector_cosine_ops);
查询 TopK:
sql
SELECT id, doc_id, chunk_text
FROM article_chunk
ORDER BY embedding <=> '[0.01,0.02,...]'::vector
LIMIT 10;
pgvector 常用距离操作符:
| 操作符 | 含义 |
|---|---|
<-> |
L2 distance |
<#> |
negative inner product |
<=> |
cosine distance |
<+> |
L1 distance |
Java 可以使用 JDBC + pgvector-java:
java
// 伪代码,重点看思路:注册 vector 类型,然后用 JDBC 写入和查询。
PGvector.addVectorType(connection);
PreparedStatement ps = connection.prepareStatement(
"INSERT INTO article_chunk(doc_id, chunk_text, embedding) VALUES (?, ?, ?)"
);
ps.setLong(1, 101L);
ps.setString(2, "这是一段文章切片");
ps.setObject(3, new PGvector(new float[]{0.01f, 0.02f, 0.03f}));
ps.executeUpdate();
Go 可以使用 pgx + pgvector-go:
go
// 伪代码,重点看思路:注册 vector 类型后插入和查询。
ctx := context.Background()
conn, err := pgx.Connect(ctx, "postgres://rag:rag123456@localhost:5432/rag")
if err != nil {
panic(err)
}
defer conn.Close(ctx)
_, err = conn.Exec(ctx,
"INSERT INTO article_chunk(doc_id, chunk_text, embedding) VALUES ($1, $2, $3)",
101,
"这是一段文章切片",
pgvector.NewVector([]float32{0.01, 0.02, 0.03}),
)
pgvector 适合已经在用 PostgreSQL,或者希望用 SQL 管理业务数据和向量数据的项目。
9. Redis Stack 向量检索部署和入门
官方文档:
- Redis Vector Search:https://redis.io/docs/latest/develop/ai/search-and-query/vectors/
- Redis Stack Docker:https://redis.io/docs/latest/operate/oss_and_stack/install/install-stack/docker/
- Jedis:https://github.com/redis/jedis
- go-redis:https://github.com/redis/go-redis
Redis 的向量能力主要来自 Redis Stack / RediSearch。官方文档说明 Redis 可以创建 vector index,支持 FLAT、HNSW、SVS-VAMANA 等索引类型,也支持 KNN 查询、范围查询和 metadata filter。
创建 docker-compose.yml:
yaml
services:
redis-stack:
image: redis/redis-stack-server:latest
container_name: redis-stack
restart: unless-stopped
ports:
- "6379:6379"
volumes:
- ${VECTOR_DATA_ROOT}/redis-stack:/data
启动:
bash
docker compose up -d
docker exec -it redis-stack redis-cli
创建向量索引:
bash
FT.CREATE idx:article_chunks
ON HASH
PREFIX 1 chunk:
SCHEMA
chunkId NUMERIC
docId NUMERIC
title TEXT
embedding VECTOR HNSW 6
TYPE FLOAT32
DIM 1536
DISTANCE_METRIC COSINE
Redis 存向量通常要把 float32 数组转成 bytes,再写入 Hash。
适合场景:
- 热数据语义检索
- 会话记忆
- 低延迟推荐
- 小规模知识库
不太适合把全量知识库长期放 Redis,因为内存成本较高。
10. Milvus 部署和入门
官方文档:
- Milvus 文档:https://milvus.io/docs
- Milvus Docker Compose 安装:https://milvus.io/docs/install_standalone-docker-compose.md
- Milvus Java SDK:https://milvus.io/docs/install-java.md
- Milvus Go SDK:https://milvus.io/docs/install-go.md
Milvus 是面向大规模向量检索的数据库,能力很强,但部署比 Qdrant 和 pgvector 更重。Standalone 模式通常会带上 etcd、MinIO、Milvus standalone 多个组件。
Linux/Ubuntu 推荐按官方方式下载 compose:
bash
wget https://github.com/milvus-io/milvus/releases/download/v2.6.0/milvus-standalone-docker-compose.yml -O docker-compose.yml
docker compose up -d
docker compose ps
版本号请以官方文档当前推荐为准。Milvus 更适合:
- 百万级以上向量
- 多租户、多 collection
- 大规模检索服务
- 需要更完整的向量数据库能力
对 8G 2核学习机来说,Milvus 可以了解概念,但不建议作为第一个实践库。
11. Weaviate 部署和入门
官方文档:
- Weaviate 文档:https://docs.weaviate.io/weaviate
- Weaviate Docker Compose:https://docs.weaviate.io/deploy/installation-guides/docker-installation
- Weaviate Java Client:https://docs.weaviate.io/weaviate/client-libraries/java
- Weaviate Go Client:https://docs.weaviate.io/weaviate/client-libraries/go
Weaviate 是对象模型比较强的向量数据库,除了向量检索,也强调 schema、class、object、metadata 等概念。
简单 Compose:
yaml
services:
weaviate:
image: cr.weaviate.io/semitechnologies/weaviate:latest
container_name: weaviate
restart: unless-stopped
ports:
- "8080:8080"
- "50051:50051"
environment:
QUERY_DEFAULTS_LIMIT: 25
AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: "true"
PERSISTENCE_DATA_PATH: "/var/lib/weaviate"
DEFAULT_VECTORIZER_MODULE: "none"
CLUSTER_HOSTNAME: "node1"
volumes:
- ${VECTOR_DATA_ROOT}/weaviate:/var/lib/weaviate
如果你想学习“知识库对象建模 + 向量检索”,Weaviate 也值得看。
12. Chroma 部署和入门
官方文档:
- Chroma 文档:https://docs.trychroma.com/docs/overview/introduction
- Chroma GitHub:https://github.com/chroma-core/chroma
Chroma 更偏轻量、本地开发、Demo 和 Python 生态。它很适合快速验证 RAG,但如果你主要做 Java/Go 后端生产项目,Chroma 可以作为了解,不一定作为主选。
Compose 示例:
yaml
services:
chroma:
image: chromadb/chroma:latest
container_name: chroma
restart: unless-stopped
ports:
- "8000:8000"
volumes:
- ${VECTOR_DATA_ROOT}/chroma:/chroma/chroma
启动:
bash
docker compose up -d
curl http://localhost:8000/api/v2/heartbeat
13. OpenSearch 向量检索
官方文档:
- OpenSearch Vector Search:https://docs.opensearch.org/latest/vector-search/
OpenSearch 适合“全文检索 + 向量检索 + 日志搜索”场景。它不是最轻量的学习方案,但如果你的系统未来需要同时做:
- 关键词搜索
- BM25
- 向量搜索
- hybrid search
- 日志分析
那 OpenSearch 值得学习。
对 8G 2核机器来说,OpenSearch 不建议和一堆业务服务挤在一起长期运行。
14. 向量索引的核心原理
14.1 精确搜索
最直接的方法是暴力扫描:
text
query vector 和库里每个 vector 都算一次距离
排序
取 TopK
优点是准确,缺点是慢。数据少时完全没问题,比如几千、几万条。
14.2 ANN 近似最近邻
ANN 是 Approximate Nearest Neighbor,近似最近邻。它不保证 100% 找到数学上最接近的点,但会用更低成本找到足够接近的结果。
向量数据库常见索引都属于 ANN 思路。
14.3 HNSW
HNSW 是现在非常常见的向量索引,全称 Hierarchical Navigable Small World。
可以理解成多层图:
text
高层:点少,适合快速跳转
低层:点多,适合精细搜索
查询时从高层入口开始,逐层往下找越来越近的点。Redis 官方文档也把 HNSW 描述为一种多层图结构:底层包含所有数据点,高层包含子集,查询时从上到下遍历图。
常见参数:
| 参数 | 含义 | 影响 |
|---|---|---|
| M | 每个节点连接多少邻居 | 越大召回越好,内存越高 |
| efConstruction | 建图时搜索候选数 | 越大索引质量越高,构建越慢 |
| efSearch / efRuntime | 查询时候选数 | 越大召回越好,查询越慢 |
14.4 IVF / IVFFlat
IVF 是 inverted file index,可以理解为先聚类,再搜索。
流程:
text
训练聚类中心
把向量分到不同桶
查询时先找最相关的几个桶
只在这些桶里搜索
优点是节省搜索范围,缺点是需要训练和调参。
pgvector 支持 HNSW 和 IVFFlat。Milvus 也支持多种索引类型。
14.5 量化
量化是用更小的数据类型表示向量,例如 float32 变成 int8 或压缩编码。
好处:
- 降低内存
- 降低磁盘
- 提升吞吐
代价:
- 可能损失召回率
- 实现和调参更复杂
个人学习阶段可以先不碰量化。
15. 距离度量怎么选
常见距离:
| 距离 | 含义 | 适合场景 |
|---|---|---|
| Cosine | 方向相似度 | 文本 embedding 常用 |
| Inner Product | 内积 | 部分归一化模型、推荐场景 |
| L2 | 欧氏距离 | 图像、通用向量空间 |
文本 RAG 里一般优先使用 Cosine。注意:不同数据库对“距离”和“相似度”的排序方向可能不同。有的是分数越高越相似,有的是距离越小越相似。
16. RAG 中如何使用向量数据库
16.1 表设计建议
业务库:
sql
CREATE TABLE ai_dataset (
id BIGINT PRIMARY KEY,
name VARCHAR(128) NOT NULL,
owner_id BIGINT NOT NULL,
status TINYINT NOT NULL,
create_time DATETIME,
update_time DATETIME
);
CREATE TABLE ai_document (
id BIGINT PRIMARY KEY,
dataset_id BIGINT NOT NULL,
title VARCHAR(255),
source_type VARCHAR(50),
source_url VARCHAR(1000),
content_hash VARCHAR(64),
status VARCHAR(50),
create_time DATETIME,
update_time DATETIME
);
CREATE TABLE ai_document_chunk (
id BIGINT PRIMARY KEY,
document_id BIGINT NOT NULL,
dataset_id BIGINT NOT NULL,
chunk_index INT NOT NULL,
chunk_text MEDIUMTEXT NOT NULL,
token_count INT,
content_hash VARCHAR(64),
embedding_status VARCHAR(50),
create_time DATETIME,
update_time DATETIME
);
向量库 payload:
json
{
"chunkId": 10001,
"documentId": 100,
"datasetId": 10,
"ownerId": 1,
"sourceType": "blog",
"tags": ["java", "ai", "rag"]
}
16.2 导入流程
text
1. 上传文档或抓取文章
2. 提取正文
3. 清洗 HTML、广告、导航、无用段落
4. 按 800-1200 字切 chunk
5. 存 MySQL
6. 投递 embedding 任务
7. 调 embedding 模型
8. 向量写入 Qdrant/pgvector
9. 更新 chunk embedding_status
16.3 查询流程
text
1. 用户提问
2. 对问题做 embedding
3. 向量数据库 TopK 检索
4. 按 ownerId/datasetId 做 metadata filter
5. 拿到 chunkId 列表
6. 回 MySQL 查 chunk_text
7. 可选 rerank
8. 拼 prompt
9. 调用大模型生成答案
10. 返回答案和引用来源
16.4 Prompt 示例
text
你是一个严谨的知识库问答助手。
请只根据给定资料回答问题。
如果资料不足,请回答“当前资料不足以确定”。
问题:
{{question}}
资料:
[1] {{chunk_1}}
[2] {{chunk_2}}
[3] {{chunk_3}}
要求:
1. 回答要简洁准确。
2. 引用资料编号。
3. 不要编造资料中没有的信息。
17. Java 项目如何接入
Java 后端建议分层:
text
controller
接收上传、查询、检索请求
service
文档解析、切片、embedding、检索、生成回答
repository
MySQL 表操作
vector
Qdrant/pgvector/Milvus 客户端封装
接口设计:
java
public interface VectorStore {
void createCollection(String name, int dimension);
void upsert(VectorPoint point);
List<VectorSearchResult> search(VectorSearchRequest request);
void deleteByChunkId(Long chunkId);
}
数据对象:
java
public class VectorPoint {
private Long id;
private float[] vector;
private Map<String, Object> payload;
}
public class VectorSearchRequest {
private String collectionName;
private float[] queryVector;
private int topK;
private Map<String, Object> filters;
}
这样你以后从 Qdrant 切 pgvector,不会影响业务层。
18. Go 项目如何接入
Go 后端也建议抽象接口:
go
type VectorStore interface {
CreateCollection(ctx context.Context, name string, dimension int) error
Upsert(ctx context.Context, point VectorPoint) error
Search(ctx context.Context, req SearchRequest) ([]SearchResult, error)
DeleteByChunkID(ctx context.Context, chunkID int64) error
}
type VectorPoint struct {
ID uint64
Vector []float32
Payload map[string]any
}
type SearchRequest struct {
Collection string
Vector []float32
TopK int
Filters map[string]any
}
type SearchResult struct {
ID uint64
Score float32
Payload map[string]any
}
学习阶段可以先用 HTTP 调 Qdrant,生产再换官方 SDK 或封装更完整的客户端。
19. 如何选择方案
个人学习、8G 2核、一两万篇文章
推荐:
text
MySQL + Qdrant
原因:
- MySQL 继续放业务数据。
- Qdrant 单容器部署简单。
- 资源可控。
- 概念完整,适合面试讲项目。
已经使用 PostgreSQL
推荐:
text
PostgreSQL + pgvector
原因:
- 少维护一个新数据库。
- SQL 体验好。
- 业务数据和向量可以 join。
超低延迟热数据
推荐:
text
Redis Stack Vector
原因:
- 快。
- 适合热数据、缓存、会话记忆。
注意:不要把 Redis 当低成本全量知识库。
大规模生产
推荐:
text
Milvus / Qdrant Cluster / Weaviate / OpenSearch
如果是千万、亿级向量,需要考虑:
- 分片
- 副本
- 索引构建时间
- 召回率
- 查询延迟
- 数据备份
- 监控告警
- 滚动升级
20. 一条适合面试的学习路线
第一阶段:理解基本概念。
- embedding 是什么
- chunk 是什么
- TopK 是什么
- cosine similarity 是什么
- RAG 为什么需要检索
第二阶段:本地跑起来。
- Docker Compose 部署 Qdrant
- 创建 collection
- 插入向量
- 搜索 TopK
- 用 payload filter 做权限隔离
第三阶段:接入后端。
- Java 或 Go 封装 VectorStore
- MySQL 存 document/chunk
- Qdrant 存 vector/chunkId
- 实现导入、检索、问答
第四阶段:优化效果。
- chunk size 调整
- topK 调整
- hybrid search
- rerank
- prompt 加引用
- 处理无答案场景
第五阶段:工程化。
- 异步 embedding
- 失败重试
- 增量更新
- 删除同步
- 多租户隔离
- 监控和成本统计
21. 总结
向量数据库不是为了替代 MySQL、PostgreSQL、Redis,而是补齐“语义检索”能力。
对 AI 应用后端来说,最重要的不是一开始选择最强的数据库,而是理解完整链路:
text
文档 -> chunk -> embedding -> 向量库 -> TopK 检索 -> rerank -> prompt -> 大模型回答
如果你是个人学习和面试准备,我建议从 Qdrant 开始。它部署轻、概念清晰、资料完整,适合在 8G 2核服务器上跑小型知识库。等你理解了 collection、point、payload、HNSW、TopK、filter、rerank,再去看 pgvector、Milvus、Redis Vector,会顺很多。
最后记住一句话:
text
业务数据放业务库,语义召回交给向量库,大模型负责生成,rerank 负责排序质量。
参考资料
- Qdrant Documentation:https://qdrant.tech/documentation/
- Qdrant Installation:https://qdrant.tech/documentation/operations/installation/
- Qdrant API Reference:https://api.qdrant.tech/
- pgvector:https://github.com/pgvector/pgvector
- pgvector Java:https://github.com/pgvector/pgvector-java
- pgvector Go:https://github.com/pgvector/pgvector-go
- Redis Vector Search:https://redis.io/docs/latest/develop/ai/search-and-query/vectors/
- Milvus Documentation:https://milvus.io/docs
- Milvus Docker Compose:https://milvus.io/docs/install_standalone-docker-compose.md
- Weaviate Documentation:https://docs.weaviate.io/weaviate
- Chroma Documentation:https://docs.trychroma.com/docs/overview/introduction
- OpenSearch Vector Search:https://docs.opensearch.org/latest/vector-search/