大模型向量技术完全指南：从概念到实践
Spring AI RAG 检索增强生成：概念、实战与完整代码：
https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/161055108
SpringBoot+LangChain4j+Ollama+RAG(检索增强生成)实现私有文档向量化检索回答：
https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/160443735
上述用到了向量化相关的概念。下面具体介绍概念相关知识点。
📚 目录
- 什么是向量？
- 什么是文本向量化？
- [什么是向量模型（Embedding Model）？](#什么是向量模型（Embedding Model）？)
- 什么是向量数据库？
- 什么是余弦相似度？
- 多维度向量详解
- 完整工作流程
- 实际应用场景
- 核心概念对比总结
注：
博客：
https://blog.csdn.net/badao_liumang_qizhi
一、什么是向量？
1.1 数学定义
**向量（Vector）**是一个有方向和大小的量，在计算机中通常表示为一组数字的数组。
例如：
二维向量：[3, 5]
三维向量：[1.2, -0.5, 3.8]
高维向量：[0.1, 0.5, -0.3, 0.8, ..., 0.2] （可能有 768、1024、1536 个维度）1.2 通俗理解
类比 1：坐标系统
想象一个地图：
- 二维向量 [x, y] = 地图上的一个坐标点
- 三维向量 [x, y, z] = 空间中的一个位置（加上了高度）
- 高维向量 = "超空间"中的一个位置（我们看不见，但数学上存在）类比 2：特征描述
描述一个人可以用多个特征：
[身高cm, 体重kg, 年龄, 收入k]
= [175, 70, 25, 15]
这就是一个 4 维向量，每个数字代表一个特征1.3 在 AI 中的意义
在大模型中，向量是信息的数学表示：
- 文字 → 转换成向量
- 图片 → 转换成向量
- 声音 → 转换成向量
核心思想：把世间万物都变成数字数组，计算机就能理解和处理了！
二、什么是文本向量化？
2.1 概念定义
**文本向量化（Text Embedding）**是将文字（词语、句子、段落）转换成数字向量（数组）的过程。
输入：文本字符串
输出：数字向量（固定长度的数组）
示例：
"人工智能" → [0.12, -0.45, 0.78, 0.23, ..., 0.56] （假设 768 维）
"机器学习" → [0.15, -0.42, 0.75, 0.28, ..., 0.53] （同样 768 维）2.2 为什么要向量化？
问题：计算机不认识汉字、英文单词，只认识数字！
解决方案：把文字变成数字向量，计算机就能：
- ✅ 计算相似度
- ✅ 进行搜索和匹配
- ✅ 进行分类和聚类
- ✅ 进行各种数学运算
2.3 核心理解：语义空间
重要概念 ：向量化不是随机转换，而是将文本映射到语义空间。
类比：图书馆分类系统
想象一个巨大的图书馆：
- 每本书都有一个坐标位置（向量）
- 内容相似的书，位置靠近
- 内容不同的书，位置远离
例如：
"人工智能"这本书的位置：[0.12, -0.45, 0.78, ...]
"机器学习"这本书的位置：[0.15, -0.42, 0.75, ...]
"烹饪菜谱"这本书的位置：[0.89, 0.67, -0.23, ...]
前两者位置很近（主题相关），后者很远（主题无关）2.4 关键特性
特性 1：语义相似的文本，向量距离近
"我喜欢编程" 和 "我热爱写代码"
→ 向量非常接近（意思相近）
"我喜欢编程" 和 "今天天气真好"
→ 向量距离很远（意思无关）特性 2：固定维度
无论输入多长：
- 一个字："好" → 768 维向量
- 一句话："你好世界" → 768 维向量
- 一段话："..." → 768 维向量
（维度由模型决定，常见 768、1024、1536 维）特性 3：捕捉语义而非字面
"医生" 和 "医师"
→ 字面不同，但向量很接近（同义词）
"苹果"（水果）和 "Apple"（公司）
→ 根据上下文，向量会不同三、什么是向量模型（Embedding Model）？
3.1 概念定义
**向量模型（Embedding Model）**是一种 AI 模型，专门负责将文本转换为向量。
类比：翻译官
向量模型就像一个"语义翻译官"：
- 输入：人类语言（文字）
- 输出：机器语言（向量）
- 职责：保证翻译后的向量能准确表达原文含义3.2 常见的向量模型
| 模型名称 | 出品方 | 维度 | 特点 |
|---|---|---|---|
| text-embedding-ada-002 | OpenAI | 1536 | 通用性强，效果好 |
| bge-m3 | 北京智源 | 1024 | 中文优化，开源免费 |
| text2vec | 国内开源 | 768 | 轻量级，适合中文 |
| m3e | 阿里通义 | 1024 | 多语言支持 |
| ollama nomic-embed-text | Ollama | 768 | 本地部署，隐私安全 |
3.3 向量模型的工作原理（简化版）
步骤 1：文本预处理
"我爱学习" → 分词 → ["我", "爱", "学", "习"]
步骤 2：词嵌入
每个词转换成初始向量
"我" → [0.1, 0.2, ...]
"爱" → [0.3, 0.4, ...]
步骤 3：上下文编码（Transformer）
考虑词与词之间的关系，生成整体语义向量
["我", "爱", "学", "习"] → [0.25, 0.35, ..., 0.45]（最终向量）
步骤 4：归一化
确保向量在合理范围内3.4 如何选择合适的向量模型？
选择因素：
1. 语言支持
中文为主 → 选 bge-m3、text2vec、m3e
英文为主 → 选 text-embedding-ada-002
多语言 → 选 m3e、bge-m32. 部署方式
云端 API → OpenAI ADA（效果好，需联网，付费）
本地部署 → Ollama（隐私好，免费，需要本地资源）3. 性能要求
高精度 → 大维度模型（1536 维）
快速度 → 小维度模型（384/768 维）
平衡 → 1024 维4. 成本考虑
预算充足 → OpenAI API
预算有限 → 开源模型本地部署3.5 实际使用示例
java
// 使用 Spring AI Alibaba + Ollama 示例
@Autowired
private EmbeddingModel embeddingModel;
public float[] generateEmbedding(String text) {
// 调用向量模型，将文本转换为向量
EmbeddingResponse response = embeddingModel.embed(text);
return response.getResults().get(0).getOutput();
}
// 使用：
float[] vector = generateEmbedding("人工智能");
// 返回：[0.12, -0.45, 0.78, 0.23, ...] 共 768 个数字四、什么是向量数据库？
4.1 概念定义
**向量数据库（Vector Database）**是专门用来存储和检索向量的数据库系统。
类比：超级索引系统
传统数据库：按关键字搜索
SELECT * FROM books WHERE title = '人工智能'
向量数据库：按语义搜索
"找和'人工智能'意思相近的所有文档"
→ 返回关于 AI、机器学习、深度学习的文档4.2 为什么需要专门的向量数据库？
问题 1：传统数据库不适合向量检索
MySQL 可以存储向量，但：
❌ 无法高效计算相似度
❌ 百万级数据查询很慢
❌ 没有专门的向量索引算法问题 2：向量检索的特殊需求
需要快速找到"最相似的 N 个向量"
→ 这叫近似最近邻搜索（ANN, Approximate Nearest Neighbor）
→ 需要特殊的索引结构（HNSW、IVF 等）4.3 常见的向量数据库
| 数据库 | 类型 | 特点 | 适用场景 |
|---|---|---|---|
| Milvus | 开源 | 功能强大，分布式 | 大规模生产环境 |
| Chroma | 开源 | 轻量级，易用 | 小规模项目、原型开发 |
| FAISS | 库 | Facebook 开源，极速 | 单机高性能检索 |
| Pinecone | 云服务 | 全托管，易用 | 快速上线，不想运维 |
| Elasticsearch | 混合 | 传统 ES + 向量检索 | 已有 ES 基础设施 |
| PostgreSQL (pgvector) | 插件 | PG 扩展，SQL 友好 | 关系型数据 + 向量混合 |
4.4 向量数据库的核心功能
功能 1：存储向量
java
// 存储文档及其向量
document: "人工智能是计算机科学的一个分支"
vector: [0.12, -0.45, 0.78, ...]
metadata: {id: 1, category: "AI", date: "2024-01-01"}功能 2：建立索引
使用 HNSW、IVF 等算法建立索引
→ 加速相似度搜索
→ 从 O(n) 暴力搜索提升到 O(log n)功能 3：相似度检索
输入：查询向量
输出：最相似的 Top-K 个向量及其相似度分数
示例：
查询："机器学习"
返回：
1. "深度学习" (相似度 0.92)
2. "神经网络" (相似度 0.88)
3. "数据挖掘" (相似度 0.75)
4. "烹饪技巧" (相似度 0.12) ← 不相关功能 4：元数据过滤
"查找与'人工智能'相似，且类别为'技术'的文档"
→ 结合向量相似度和元数据条件4.5 向量数据库工作流程
┌─────────────┐
│ 存入阶段 │
└─────────────┘
↓
1. 文本 → 向量模型 → 向量
2. 向量 + 元数据 → 存入向量数据库
3. 数据库建立索引
┌─────────────┐
│ 检索阶段 │
└─────────────┘
↓
1. 查询文本 → 向量模型 → 查询向量
2. 向量数据库 → 相似度搜索 → Top-K 结果
3. 返回原始文本 + 相似度分数4.6 实际使用示例
java
// 使用 Chroma 向量数据库示例
@Autowired
private VectorStore vectorStore;
// 存入数据
public void storeDocument(String text, String id) {
Document doc = new Document.Builder()
.text(text)
.metadata(Map.of("id", id, "category", "AI"))
.build();
vectorStore.add(List.of(doc));
}
// 检索数据
public List<Document> searchSimilar(String query, int topK) {
SearchRequest request = SearchRequest.builder()
.query(query)
.topK(topK)
.similarityThreshold(0.7) // 相似度阈值
.build();
return vectorStore.similaritySearch(request);
}
// 使用：
storeDocument("人工智能是研究使计算机模拟人类智能的学科", "doc1");
List<Document> results = searchSimilar("机器学习方法", 5);
// 返回最相关的 5 个文档五、什么是余弦相似度？
5.1 概念定义
**余弦相似度（Cosine Similarity）**是衡量两个向量方向相似程度的指标。
取值范围 ：-1 到 1
1：完全相同（方向一致）0：正交（无相关性）-1：完全相反（方向相反）
5.2 数学公式
cos(θ) = (A · B) / (||A|| × ||B||)
其中：
- A · B 是向量点积
- ||A|| 是向量 A 的模（长度）
- θ 是两个向量的夹角展开公式：
Σ(Ai × Bi)
cos(θ) = ───────────────
√Σ(Ai²) × √Σ(Bi²)5.3 通俗理解
类比：手电筒光束
想象两束手电筒的光：
- 光束 A 指向某个方向
- 光束 B 指向另一个方向
余弦相似度 = 两束光方向的接近程度
如果：
✅ 两束光指向同一方向 → 相似度 = 1
✅ 两束光垂直（90°） → 相似度 = 0
✅ 两束光指向相反方向 → 相似度 = -1关键点 ：余弦相似度只看方向 ，不看长度！
5.4 为什么用余弦相似度而不是欧氏距离？
对比示例：
向量 A = [1, 2, 3]
向量 B = [2, 4, 6] （B 是 A 的 2 倍）
欧氏距离：
- 计算两点间的直线距离
- A 和 B 距离较远（因为长度不同）
- 但它们的"方向"其实是一样的！
余弦相似度：
- 只看方向，忽略长度
- A 和 B 相似度 = 1（完全相同的方向）
- 这正是我们想要的：语义相同，只是表达长短不同在文本检索中的意义：
"AI" 和 "人工智能是非常复杂的技术领域"
→ 长度差异很大
→ 但语义方向一致
→ 余弦相似度高 ✓
如果用欧氏距离，会因为长度差异误判为不相似 ✗5.5 计算示例
python
import numpy as np
from numpy.linalg import norm
# 两个向量
A = np.array([0.1, 0.2, 0.3, 0.4])
B = np.array([0.15, 0.25, 0.35, 0.45])
# 计算余弦相似度
cosine_similarity = np.dot(A, B) / (norm(A) * norm(B))
print(f"余弦相似度: {cosine_similarity:.4f}")
# 输出：余弦相似度: 0.9938 （非常相似）5.6 相似度阈值参考
| 相似度范围 | 含义 | 示例 |
|---|---|---|
| 0.9 - 1.0 | 极其相似 | 同义词、 paraphrase |
| 0.7 - 0.9 | 高度相关 | 同一主题的不同表述 |
| 0.5 - 0.7 | 中度相关 | 有一定关联 |
| 0.3 - 0.5 | 弱相关 | 间接关联 |
| 0.0 - 0.3 | 几乎无关 | 不同主题 |
| < 0.0 | 负相关 | 对立概念（少见） |
实际应用建议：
java
// 设置相似度阈值过滤
.similarityThreshold(0.7) // 只返回相似度 > 0.7 的结果六、多维度向量详解
6.1 什么是维度？
**维度（Dimension）**是向量中数字的个数。
3 维向量：[0.1, 0.5, -0.3] ← 3 个数字
768 维向量：[0.1, 0.5, -0.3, ..., 0.2] ← 768 个数字
1536 维向量：[0.1, 0.5, -0.3, ..., 0.8] ← 1536 个数字6.2 维度的意义
类比：描述事物的特征数量
描述一个人的方式：
低维度（3 维）：
[身高, 体重, 年龄]
→ 信息量少，区分度低
中维度（10 维）：
[身高, 体重, 年龄, 收入, 学历, 职业, 城市, 爱好, 性格, 婚姻状况]
→ 信息量适中
高维度（100 维）：
[... 100 个各种特征 ...]
→ 信息量丰富，区分度高6.3 维度高低的影响
| 维度 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 低维 (64-256) | 速度快，存储小 | 表达能力弱 | 简单任务、资源受限 |
| 中维 (384-768) | 平衡性好 | 中等 | 大多数应用 |
| 高维 (1024-1536) | 表达能力强，精度高 | 速度慢，存储大 | 高精度要求 |
6.4 常见模型的维度
OpenAI text-embedding-ada-002 → 1536 维
Ollama nomic-embed-text → 768 维
bge-m3 → 1024 维
text2vec-base-chinese → 768 维6.5 维度选择的实际考虑
存储空间计算：
假设 100 万条数据：
768 维（float32，每维 4 字节）：
100万 × 768 × 4 bytes = 2.86 GB
1536 维：
100万 × 1536 × 4 bytes = 5.72 GB
→ 维度翻倍，存储空间翻倍检索速度：
维度越高：
✅ 精度提升（可能）
❌ 计算量增加
❌ 内存占用增加
❌ 检索速度变慢6.6 可视化理解（降维）
虽然我们看不到高维空间，但可以降维可视化：
python
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
# 假设有 1000 个 768 维的向量
high_dim_vectors = [...] # shape: (1000, 768)
# 降维到 2 维
tsne = TSNE(n_components=2, random_state=42)
low_dim_vectors = tsne.fit_transform(high_dim_vectors) # shape: (1000, 2)
# 绘制散点图
plt.scatter(low_dim_vectors[:, 0], low_dim_vectors[:, 1])
plt.title("文本向量分布（降维可视化）")
plt.show()
# 你会看到：相似的文本聚集在一起形成簇可视化效果：
●●●● ▲▲▲▲
●●●●●● ▲▲▲▲▲▲
●●●●●●●● ▲▲▲▲▲▲▲▲
AI相关文本簇 体育相关文本簇
○○○○
○○○○○○ 美食相关文本簇
○○○○
每个点是一篇文章，相近的点表示语义相似七、完整工作流程
7.1 RAG（检索增强生成）架构流程
这是向量技术最典型的应用场景：
┌─────────────────────────────────────────────────┐
│ 第一阶段：知识库构建 │
└─────────────────────────────────────────────────┘
1. 收集文档
↓
PDF、Word、网页、数据库记录...
2. 文本分块（Chunking）
↓
"长篇文档" → ["段落1", "段落2", "段落3", ...]
3. 文本向量化（Embedding）
↓
每个段落 → 向量模型 → 向量
"段落1" → [0.12, -0.45, 0.78, ...]
"段落2" → [0.34, 0.56, -0.12, ...]
4. 存入向量数据库
↓
向量 + 原文 + 元数据 → 向量数据库
建立索引加速检索
┌─────────────────────────────────────────────────┐
│ 第二阶段：用户查询 │
└─────────────────────────────────────────────────┘
5. 用户提问
↓
"什么是机器学习？"
6. 查询向量化
↓
问题 → 同样的向量模型 → 查询向量
"什么是机器学习？" → [0.15, -0.42, 0.75, ...]
7. 向量检索
↓
查询向量 vs 向量数据库
→ 找出最相似的 Top-K 个段落
→ 返回相似度最高的 3-5 个相关文档
8. 构建提示词（Prompt）
↓
组合：
- 系统指令
- 检索到的相关文档（作为上下文）
- 用户问题
Prompt = """
基于以下资料回答问题：
资料1: 机器学习是人工智能的一个分支...
资料2: 机器学习通过数据训练模型...
问题：什么是机器学习？
"""
9. 调用大模型生成答案
↓
LLM 根据 Prompt 生成回答
10. 返回答案给用户
↓
"机器学习是人工智能的一个分支，它通过..."7.2 代码实现示例（Spring AI Alibaba）
java
@Service
public class RagService {
@Autowired
private EmbeddingModel embeddingModel;
@Autowired
private VectorStore vectorStore;
@Autowired
private ChatClient chatClient;
/**
* 第一步：构建知识库
*/
public void buildKnowledgeBase(List<String> documents) {
for (String doc : documents) {
// 1. 文本分块
List<String> chunks = splitText(doc, 500);
for (String chunk : chunks) {
// 2. 向量化
EmbeddingResponse embedding = embeddingModel.embed(chunk);
float[] vector = embedding.getResults().get(0).getOutput();
// 3. 存入向量数据库
Document document = new Document.Builder()
.text(chunk)
.vector(vector)
.metadata(Map.of("source", "knowledge_base"))
.build();
vectorStore.add(List.of(document));
}
}
}
/**
* 第二步：回答用户问题
*/
public String answerQuestion(String question) {
// 1. 查询向量化
EmbeddingResponse queryEmbedding = embeddingModel.embed(question);
// 2. 向量检索（Top-5 相似文档）
SearchRequest searchRequest = SearchRequest.builder()
.query(question)
.topK(5)
.similarityThreshold(0.7)
.build();
List<Document> relevantDocs = vectorStore.similaritySearch(searchRequest);
// 3. 构建 Prompt
StringBuilder context = new StringBuilder();
for (int i = 0; i < relevantDocs.size(); i++) {
context.append("资料").append(i+1).append(": ")
.append(relevantDocs.get(i).getText())
.append("\n\n");
}
String prompt = String.format("""
基于以下资料回答问题，如果资料中没有相关信息，请说明：
%s
问题：%s
回答：
""", context.toString(), question);
// 4. 调用大模型生成答案
return chatClient.prompt(prompt).call().content();
}
/**
* 文本分块工具方法
*/
private List<String> splitText(String text, int chunkSize) {
// 简单实现：按固定长度分割
List<String> chunks = new ArrayList<>();
for (int i = 0; i < text.length(); i += chunkSize) {
int end = Math.min(i + chunkSize, text.length());
chunks.add(text.substring(i, end));
}
return chunks;
}
}八、实际应用场景
8.1 智能客服
场景：用户咨询产品问题
传统方式：
- 关键词匹配
- 规则引擎
- 僵化，无法理解语义
向量方式：
1. 将所有 FAQ 和问题向量化，存入向量数据库
2. 用户提问向量化
3. 检索最相似的 FAQ
4. 返回答案或转人工
优势：
✅ 理解同义表达（"怎么退款" = "如何退货款"）
✅ 模糊匹配（即使不完全一致也能找到相关）
✅ 持续学习（新增 QA 只需添加向量）8.2 文档搜索引擎
场景：企业内部文档搜索
传统搜索：
- 只能匹配关键词
- "AI" 搜不到 "人工智能"
- 无法理解语义
向量搜索：
1. 所有文档向量化
2. 用户查询向量化
3. 按语义相似度排序返回
优势：
✅ 语义搜索（搜 "机器学习" 能找到 "深度学习" 相关文档）
✅ 跨语言搜索（中英文混搜）
✅ 智能排序（相关度高的排前面）8.3 推荐系统
场景：新闻/商品推荐
原理：
1. 用户历史行为向量化（看过的文章、买过的商品）
2. 候选物品向量化
3. 计算相似度，推荐最相关的内容
示例：
用户看了 "Python 入门教程"
→ 用户兴趣向量
→ 推荐 "Python 进阶"、"数据分析实战"
→ 而不是推荐 "烹饪技巧"8.4 去重与聚类
场景：检测重复内容、自动分类
去重：
- 新文章向量化
- 与已有文章计算相似度
- 相似度 > 0.95 → 判定为重复/抄袭
聚类：
- 大量文档向量化
- 使用聚类算法（K-Means）分组
- 自动发现主题类别8.5 代码搜索
场景：在代码库中搜索功能相似的代码
1. 代码片段向量化（使用代码专用 embedding 模型）
2. 自然语言查询向量化
3. 检索相似代码
示例：
查询："如何读取 CSV 文件"
返回：项目中所有读取 CSV 的代码片段八、核心概念对比总结
8.1 概念关系图
┌──────────────────────────────────────────────────┐
│ 向量技术生态系统 │
└──────────────────────────────────────────────────┘
文本/图片/音频
↓
┌─────────────┐
│ 向量模型 │ ← Embedding Model（转换器）
│ (Embedding) │ 负责：文本 → 向量
└─────────────┘
↓
向量（数组）
[0.12, -0.45, 0.78, ...]
↓
┌─────────────┐
│ 向量数据库 │ ← Vector Database（存储器）
│ │ 负责：存储 + 检索向量
└─────────────┘
↓
┌─────────────┐
│ 相似度计算 │ ← Cosine Similarity（度量器）
│ (余弦相似度) │ 负责：衡量向量间相似程度
└─────────────┘
↓
检索结果 + 相似度分数9.2 核心概念对照表
| 概念 | 是什么 | 类比 | 作用 | 常见工具 |
|---|---|---|---|---|
| 向量 | 数字数组 | 坐标点 | 信息的数学表示 | NumPy 数组 |
| 文本向量化 | 文本→向量的过程 | 翻译 | 让计算机理解语义 | Embedding API |
| 向量模型 | 执行向量化的 AI 模型 | 翻译官 | 生成高质量向量 | OpenAI ADA, BGE, Ollama |
| 向量数据库 | 存储检索向量的数据库 | 超级索引 | 快速相似度搜索 | Milvus, Chroma, FAISS |
| 余弦相似度 | 衡量向量相似度的算法 | 角度测量 | 判断语义相关程度 | 数学公式计算 |
| 维度 | 向量中数字的个数 | 特征数量 | 决定表达能力 | 768, 1024, 1536 |
9.3 一句话总结
向量 = 信息的数字身份证
向量化 = 给信息办身份证的过程
向量模型 = 办理身份证的工作人员
向量数据库 = 存放身份证的档案室
余弦相似度 = 比对两张身份证的相似程度
维度 = 身份证上记录的信息项数量9.4 学习路径建议
初学者路线：
第 1 步：理解向量概念
→ 知道向量就是数字数组
第 2 步：体验文本向量化
→ 调用 API，看文本如何变成向量
第 3 步：计算相似度
→ 手动计算两个向量的余弦相似度
第 4 步：使用向量数据库
→ 安装 Chroma/Milvus，存取向量
第 5 步：构建 RAG 应用
→ 完整的检索增强生成系统
第 6 步：优化与调优
→ 选择合适的模型、维度、阈值🎯 实战练习建议
练习 1：基础向量化
java
// 目标：将文本转换为向量并观察
String text = "人工智能";
float[] vector = embeddingModel.embed(text).getResults().get(0).getOutput();
System.out.println("维度: " + vector.length);
System.out.println("前10维: " + Arrays.toString(Arrays.copyOfRange(vector, 0, 10)));练习 2：相似度计算
java
// 目标：比较不同文本的相似度
double sim1 = cosineSimilarity(embed("AI"), embed("人工智能"));
double sim2 = cosineSimilarity(embed("AI"), embed("烹饪"));
System.out.println("AI vs 人工智能: " + sim1); // 应该很高
System.out.println("AI vs 烹饪: " + sim2); // 应该很低练习 3：向量检索
java
// 目标：从向量数据库中检索相关文档
vectorStore.add(documents);
List<Document> results = vectorStore.similaritySearch("查询文本");
results.forEach(doc -> {
System.out.println("文档: " + doc.getText());
System.out.println("相似度: " + doc.getScore());
});关键技术栈：
- 框架：Spring AI、LangChain、LlamaIndex
- 模型：OpenAI Embeddings、BGE、M3E
- 数据库：Milvus、Chroma、FAISS、pgvector
- 可视化：TensorBoard Projector、UMAP
💡 常见问题 FAQ
Q1：向量化会丢失信息吗？
A：会有少量信息损失，但好的向量模型能保留核心语义。就像摘要会省略细节但保留主旨。
Q2：为什么不用关键词搜索而用向量搜索？
A：向量搜索能理解语义，关键词只能匹配字面。"AI" 和 "人工智能" 字面不同但语义相同。
Q3：向量数据库和普通数据库能一起用吗？
A：当然！通常混合使用：
- 向量数据库：存储向量，做相似度检索
- 关系数据库：存储结构化数据，做精确查询
- 通过 ID 关联两者
Q4：多少数据量才需要用向量数据库？
A：
-
< 1000 条：内存中计算即可
-
1000 - 10万条：FAISS 或 Chroma
-
10万条：Milvus、Pinecone 等专业向量数据库
Q5：向量模型需要 GPU 吗？
A：
- 云端 API：不需要，服务商提供
- 本地部署：小模型 CPU 可用，大模型建议 GPU
- Ollama：CPU 可用，GPU 更快
🎉 结语
向量技术是大模型应用的基础设施，理解了这些概念，你就掌握了：
- ✅ RAG 系统的核心原理
- ✅ 语义搜索的实现机制
- ✅ 智能推荐的技术基础
- ✅ 现代 AI 应用的关键组件
记住核心思想：
把万物变成向量，用数学方法处理语义！