向量数据库入门:常见方案、Docker Compose 部署、Java/Go 接入与 RAG 实战

2026-06-29大模型12 分钟114 次阅读
AI 摘要salmon-ai

本文详细解析了向量数据库在 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 应用里经常需要回答语义相似问题:

  • “有没有和这段话意思相近的文章?”
  • “用户问的问题,应该匹配知识库里的哪几段资料?”
  • “这篇文章和历史文章是否重复?”
  • “给我找一些适合写公众号选题的素材。”

这类问题不是简单的字符串匹配,而是语义匹配。做法通常是:

  1. 用 embedding 模型把文本变成向量。
  2. 把向量存入向量数据库。
  3. 查询时也把问题变成向量。
  4. 用向量相似度找最接近的内容。

例如一段文本可能被 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 官方文档说明它提供 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 是 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 的向量能力主要来自 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 是面向大规模向量检索的数据库,能力很强,但部署比 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 是对象模型比较强的向量数据库,除了向量检索,也强调 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 更偏轻量、本地开发、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 适合“全文检索 + 向量检索 + 日志搜索”场景。它不是最轻量的学习方案,但如果你的系统未来需要同时做:

  • 关键词搜索
  • 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 负责排序质量。

参考资料

觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句