← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共8章,点击直达)
一、Embedding基础二、向量检索算法三、Milvus向量数据库四、pgvector实战五、向量检索在RAG中的应用六、性能优化七、面试高频综合题面试速记口诀

Q126 Embedding与向量数据库深度实战

20K Java+AI 岗位高频考点 — 向量检索是RAG和AI应用的核心基础设施,面试高频考察Embedding原理、HNSW/IVF算法、Milvus/pgvector实战。覆盖向量模型、检索算法、Spring AI集成、性能优化。

一、Embedding基础

1. 什么是Embedding?


Embedding = 将文本/图片等转化为固定长度的浮点向量
使得语义相近的内容在向量空间中距离相近

示例:
"Java编程" → [0.23, -0.15, 0.89, ..., 0.12]  (1536维)
"Java开发" → [0.22, -0.14, 0.88, ..., 0.11]  (相近)
"红烧肉食谱" → [0.01, 0.95, -0.33, ..., 0.67] (不同)

维度:通常是256/384/768/1536维
距离度量:余弦相似度(cosine)、L2距离(euclidean)、内积(dot product)

2. 主流Embedding模型?

模型提供方维度特点
text-embedding-3-smallOpenAI1536通用,API调用
text-embedding-3-largeOpenAI3072高精度
bge-large-zh-v1.5BAAI1024中文最强(开源)
bge-m3BAAI1024多语言+多粒度
gte-large-zhAlibaba1024中文优秀
Cohere embed-v3Cohere1024搜索优化
E5-mistral-7bMicrosoft4096高精度大模型

3. 相似度计算?


// 余弦相似度(最常用,范围[-1,1])
public static float cosineSimilarity(float[] a, float[] b) {
    float dot = 0, normA = 0, normB = 0;
    for (int i = 0; i < a.length; i++) {
        dot += a[i] * b[i];
        normA += a[i] * a[i];
        normB += b[i] * b[i];
    }
    return (float) (dot / (Math.sqrt(normA) * Math.sqrt(normB) + 1e-8));
}

// L2距离(越小越相似)
public static float l2Distance(float[] a, float[] b) {
    float sum = 0;
    for (int i = 0; i < a.length; i++) {
        sum += (a[i] - b[i]) * (a[i] - b[i]);
    }
    return (float) Math.sqrt(sum);
}

4. Spring AI Embedding?


@Configuration
public class EmbeddingConfig {
    @Bean
    public EmbeddingModel embeddingModel(RestClient.Builder restClient) {
        return new OpenAiEmbeddingModel(restClient,
            OpenAiApi.builder().apiKey(System.getenv("OPENAI_API_KEY")).build(),
            MetadataMode.EMBED,
            OpenAiEmbeddingOptions.builder()
                .model("text-embedding-3-small")
                .dimensions(1536)
                .build());
    }
}

// 使用
@Autowired EmbeddingModel embeddingModel;

public float[] embed(String text) {
    return embeddingModel.embed(text);
}

// 批量
public List<float[]> embedBatch(List<String> texts) {
    return embeddingModel.embed(texts, EmbeddingOptions.EMPTY);
}

二、向量检索算法

5. 暴力搜索 vs ANN?


暴力搜索(KNN):
- 与所有向量计算距离,取Top-K
- 精度100%,但O(N)复杂度
- 百万级以上不可接受

近似最近邻(ANN):
- 牺牲少量精度换取100-1000倍加速
- 召回率通常>95%
- 适合大规模向量检索

ANN算法分类:
- 基于图:HNSW、NSW
- 基于量化:PQ、OPQ、SQ
- 基于树:KD-Tree、Annoy
- 基于哈希:LSH
- 基于聚类:IVF、IVF-PQ

6. HNSW算法原理?


HNSW = Hierarchical Navigable Small World

核心思想:多层图结构,上层稀疏下层密集
查找时从上层开始,逐层向下逼近目标

构建:
1. 随机决定节点出现在哪些层
2. 每层维护一个Navigable Small World图
3. 新节点连接到最近的M个邻居

查询:
1. 从最高层入口开始
2. 在当前层贪心搜索最近邻
3. 到达局部最优后进入下一层
4. 最底层找到精确最近邻

参数:
M = 16-64:每层最大连接数(越大越准但越慢)
ef_construction = 100-200:构建时搜索宽度
ef_search = 50-200:查询时搜索宽度

性能:百万级向量,查询 < 1ms

7. IVF+PQ算法?


IVF(Inverted File Index):
1. 对所有向量做K-Means聚类(如1024个聚类中心)
2. 每个向量归属最近的聚类中心
3. 查询时只搜索最近的nprobe个聚类

PQ(Product Quantization):
1. 将向量切分为M个子空间(如128维切8个16维)
2. 每个子空间独立做K-Means(256个中心)
3. 每个子向量用1字节编码(中心ID)
4. 128维float(512B) → 8字节,压缩64倍

IVF+PQ联合:
1. IVF筛选候选聚类(减少搜索范围)
2. PQ快速计算距离(压缩存储+快速比较)
3. 精排时用原始向量重算

适合:亿级向量,内存敏感场景

8. Faiss库原理?


Facebook开源的向量检索库(Python/C++)

常用索引:
IndexFlatL2        → 暴力搜索(精确)
IndexIVFFlat       → IVF + 原始向量
IndexIVFPQ         → IVF + PQ量化
IndexHNSWFlat      → HNSW图索引
IndexScalarQuantizer → 标量量化

Java集成:
- JNI直接调用
- 或通过Milvus(内置Faiss)

GPU加速:
faiss.index_gpu_to_cpu / index_cpu_to_gpu
适合:亿级向量,需要GPU加速

三、Milvus向量数据库

9. Milvus架构?


组件:
- Proxy:客户端入口,解析请求
- Coordinator:元数据管理+调度
- Worker Node:数据读写+索引构建
- Storage:MinIO/S3(对象) + etcd(元数据) + Kafka/Wal(日志)

特性:
- 云原生,存算分离
- 支持HNSW/IVF_PQ/SCANN等多种索引
- CRUD + 标量过滤 + 向量检索
- 水平扩展
- 多租户

数据模型:
Collection(表) → Field(列) → Index(索引)
  字段类型:FloatVector, BinaryVector, Int64, VarChar, JSON, Array

10. Milvus Java SDK?


// Spring AI Milvus集成
@Configuration
public class MilvusConfig {
    @Bean
    public VectorStore vectorStore(EmbeddingModel embeddingModel) {
        MilvusVectorStoreOptions options = MilvusVectorStoreOptions.builder()
            .collectionName("documents")
            .databaseName("default")
            .indexType(IndexType.IVF_FLAT)
            .metricType(MetricType.COSINE)
            .build();

        return MilvusVectorStore.builder()
            .embeddingModel(embeddingModel)
            .milvusClient(milvusClient())
            .options(options)
            .build();
    }

    @Bean
    public MilvusServiceClient milvusClient() {
        return ConnectParam.newBuilder()
            .withHost("localhost")
            .withPort(19530)
            .build();
    }
}

// 使用
@Autowired VectorStore vectorStore;

// 添加文档
vectorStore.add(List.of(
    new Document("Java是面向对象语言", Map.of("source", "wiki", "category", "programming")),
    new Document("Spring是Java框架", Map.of("source", "docs", "category", "framework"))
));

// 搜索
List<Document> results = vectorStore.similaritySearch(
    SearchRequest.builder()
        .query("什么是Java")
        .topK(5)
        .filterExpression("category == 'programming'")
        .build());

11. Milvus索引选择?

索引构建速度查询速度内存适用
FLAT快慢高小数据集/精确搜索
IVF_FLAT中中中百万级通用
IVF_PQ慢快低内存敏感/亿级
HNSW慢最快高低延迟要求
SCANN慢快中Google优化方案

12. 元数据过滤?


// 向量检索 + 标量过滤
SearchRequest request = SearchRequest.builder()
    .query("如何学习Java")
    .topK(10)
    .filterExpression("category == 'tutorial' AND year >= 2024")
    .similarityThreshold(0.7)
    .build();

// Milvus支持丰富的过滤表达式:
// field == value, field > value, field IN [v1, v2]
// field LIKE '%keyword%', JSON字段过滤
// array_contains(field, value)

四、pgvector实战

13. pgvector作为向量库?


CREATE EXTENSION vector;

CREATE TABLE documents (
    id bigserial PRIMARY KEY,
    content text NOT NULL,
    embedding vector(1536),
    metadata jsonb
);

-- HNSW索引
CREATE INDEX idx_doc_embedding ON documents
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);

-- 查询
SELECT id, content, 1 - (embedding <=> $query_vector) AS similarity
FROM documents
WHERE metadata->>'category' = 'java'
ORDER BY embedding <=> $query_vector
LIMIT 5;

14. pgvector vs Milvus?

维度pgvectorMilvus
类型PG扩展独立向量库
最大规模百万级十亿级
SQL查询完整SQL有限过滤
运维PG运维即可独立运维
事务ACID有限
适用中小规模+SQL大规模+高并发

建议:<百万级+已有PG → pgvector;百万级以上+高并发 → Milvus


五、向量检索在RAG中的应用

15. 文档分块策略?


分块大小影响检索质量:
- 太小(100字):语义不完整
- 太大(2000字):噪声太多
- 推荐:300-800字,重叠50-100字

分块方式:
1. 固定大小:简单但可能截断句子
2. 按段落:保留语义完整性
3. 按标题(Markdown Header):保留文档结构
4. 语义分块:基于Embedding相似度切分

Spring AI TextSplitter:
TokenTextSplitter splitter = new TokenTextSplitter(800, 100, 5, 10000, true);
List<Document> chunks = splitter.split(document);

16. 父子文档索引?


问题:小块检索精度高但上下文不完整
方案:小块检索,返回大块上下文

实现:
1. 大块(2000字)作为父文档,存入vector_store
2. 小块(500字)作为子文档,存入vector_store_child
3. 子文档的metadata中记录parentId

检索:
1. 用query搜索子文档
2. 通过parentId找到父文档
3. 返回父文档的完整上下文给LLM

17. 混合检索(Hybrid Search)?


// 向量检索 + 关键词检索 + RRF融合
@Service
public class HybridSearchService {
    @Autowired VectorStore vectorStore;
    @Autowired ElasticsearchService esService;

    public List<Document> hybridSearch(String query, int topK) {
        // 1. 向量检索
        List<Document> vectorResults = vectorStore.similaritySearch(
            SearchRequest.builder().query(query).topK(topK * 3).build());

        // 2. 关键词检索
        List<Document> keywordResults = esService.search(query, topK * 3);

        // 3. RRF融合
        Map<String, Double> scores = new HashMap<>();
        int k = 60;
        for (int i = 0; i < vectorResults.size(); i++) {
            scores.merge(vectorResults.get(i).getId(), 1.0 / (k + i + 1), Double::sum);
        }
        for (int i = 0; i < keywordResults.size(); i++) {
            scores.merge(keywordResults.get(i).getId(), 1.0 / (k + i + 1), Double::sum);
        }

        return scores.entrySet().stream()
            .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
            .limit(topK)
            .map(e -> findById(e.getKey()))
            .collect(Collectors.toList());
    }
}

六、性能优化

18. 索引参数调优?


HNSW调优:
- m = 16:默认,平衡性能和内存
- m = 32:更高召回率,内存翻倍
- m = 64:最高召回率,内存4倍
- ef_construction = 200:构建质量(越高越好,构建越慢)
- ef_search = 100:查询质量(越高越准,查询越慢)

经验:
- m=16, ef_search=100 → 召回率>95%,延迟<5ms
- m=32, ef_search=200 → 召回率>99%,延迟<10ms
- 生产推荐:m=32, ef_construction=200, ef_search=100

IVF调优:
- nlist = sqrt(N):聚类数(N为向量数)
- nprobe = 10-50:搜索聚类数

19. 百万级向量优化?


1. 量化压缩:
   - PQ:压缩4-8倍,精度损失<5%
   - SQ:压缩2倍,精度损失<2%

2. 分区:
   - 按时间分区(只搜索近期数据)
   - 按业务分区(只搜索相关数据)

3. 缓存:
   - 热点查询结果缓存
   - Embedding结果缓存

4. 批处理:
   - 批量插入(1000条/批)
   - 批量查询

5. 预计算:
   - 查询Embedding预计算缓存
   - 热门查询预计算结果

20. 多模态向量?


文本+图片联合检索:

CLIP模型:将文本和图片映射到同一向量空间
- "一只猫" 和 猫的图片 → 相似的向量

Java实现:
// 图片Embedding
float[] imageEmbedding = clipModel.embedImage(imageFile);

// 文本Embedding
float[] textEmbedding = clipModel.embedText("一只猫");

// 跨模态检索
List<Document> results = vectorStore.similaritySearch(
    SearchRequest.builder()
        .queryEmbedding(imageEmbedding)  // 用图片搜文本
        .topK(5).build());

七、面试高频综合题

21. 向量数据库选型?


决策树:
数据量?
├── <100万 → pgvector(简单,已有PG基础设施)
├── 100万-1000万 → Milvus/Qdrant/Weaviate
└── >1000万 → Milvus集群/Pinecone Serverless

需要SQL过滤?
├── 是 → pgvector / Weaviate
└── 否 → Milvus / Qdrant

团队运维能力?
├── 弱 → Pinecone(全托管)
└── 强 → Milvus(自建)

22. RAG检索不准怎么优化?


检索层优化:
1. 更好的Embedding模型(BGE > OpenAI > 默认)
2. 混合检索(向量+BM25 RRF融合)
3. Rerank重排序(BGE-Reranker/Cohere)
4. 查询改写(Multi-Query/HyDE)
5. 分块策略调优(300-800字+重叠)

索引层优化:
1. HNSW参数调优(m=32, ef_search=100)
2. 元数据过滤(缩小搜索范围)
3. 父子文档(小块检索+大块上下文)

23. Embedding模型选型?


中文场景:
1. bge-large-zh-v1.5 → 中文最强开源
2. bge-m3 → 多语言+长文本
3. gte-large-zh → 阿里达摩院

英文/多语言:
1. text-embedding-3-large → OpenAI最强
2. Cohere embed-v3 → 搜索场景优化
3. E5-mistral-7b → 最高精度

选型维度:
- 语言(中文/英文/多语言)
- 精度(准确率 vs 速度)
- 成本(API vs 自部署)
- 维度(存储成本)

面试速记口诀

Embedding三步:文本→向量→相似度计算(余弦/L2/内积)

>

ANN两算法:HNSW(图结构,快) / IVF+PQ(聚类+量化,省内存)

>

向量库三选:小规模pgvector / 中大规模Milvus / 托管Pinecone

>

RAG检索四优化:换更好Embedding + 混合检索 + Rerank + 分块调优