Milvus 向量数据库实战:从零构建高性能 RAG 系统
前言
在 AI 应用快速发展的今天,向量数据库已成为构建智能检索系统的核心基础设施。Milvus 作为一款开源的高性能向量数据库,在 RAG(Retrieval-Augmented Generation)系统中发挥着关键作用。
本文将带你从零开始,基于 Milvus 构建一个完整的 RAG 系统,涵盖数据准备、向量检索、结果重排、位置优化等核心环节,并分享生产环境中的最佳实践和性能优化技巧。
1. Milvus 简介与核心特性
1.1 什么是 Milvus?
Milvus 是一个开源的向量数据库,专为 AI 应用设计,支持大规模向量数据的存储、索引和检索。它具备以下核心特性:
高性能:毫秒级向量检索,支持百万到百亿级向量 易用性:提供 Python SDK,API 简洁直观 可扩展性:支持分布式部署,水平扩展 多索引支持:HNSW、IVF、DiskANN 等多种索引算法 多模态友好:支持文本、图像、音频等多种数据类型
1.2 为什么选择 Milvus?
在构建 RAG 系统时,我们需要一个能够:
快速检索:从大规模文档库中快速找到相关文档 精确匹配:通过向量相似度找到语义相关的文档 易于集成:与现有 AI 工具链无缝集成 生产就绪:支持高并发、高可用部署
Milvus 完美满足这些需求,已成为 RAG 系统的首选向量数据库。
1.3 Milvus Lite vs Milvus Server
Milvus 提供了两种使用方式:
| 部署方式 | ||
| 适用场景 | ||
| 数据存储 | ||
| 性能 | ||
| 使用方式 | MilvusClient(uri="./db") | connections.connect(host="localhost") |
本文使用 Milvus Lite,因为它更简单,适合快速上手和开发测试。
2. 环境准备与安装
2.1 系统要求
Python 3.8+ 8GB+ RAM(推荐 16GB) 10GB+ 磁盘空间(用于存储向量和模型)
2.2 安装依赖
首先创建虚拟环境(推荐):
# 创建虚拟环境
python3 -m venv venv
# 激活虚拟环境
# macOS/Linux:
source venv/bin/activate
# Windows:
# venv\Scripts\activate
安装必要的依赖:
pip install pymilvus[milvus_lite] # 包含Milvus Lite
pip install sentence-transformers # Embedding模型
pip install transformers # 重排模型
pip install torch # PyTorch(重排模型需要)
重要提示:必须安装 pymilvus[milvus_lite](不是 pymilvus),这样才能使用 Milvus Lite 的本地文件功能。
2.3 验证安装
from pymilvus import MilvusClient
# 测试Milvus Lite连接
client = MilvusClient(uri="./test.db")
print("✓ Milvus Lite 安装成功!")
3. 数据准备:从文档到向量
3.1 文档预处理
在实际应用中,我们需要将原始文档转换为向量。这个过程包括:
文档加载:从文件、数据库或 API 加载文档 文档分块:将长文档切分为较小的块(chunks) 向量化:使用 Embedding 模型将文本转换为向量
3.2 文档分块策略
文档分块是 RAG 系统的关键步骤,直接影响检索效果:
def chunk_document(text, chunk_size=512, overlap=50):
"""
文档分块
Args:
text: 原始文档文本
chunk_size: 每块的大小(字符数或tokens)
overlap: 块之间的重叠大小,保证上下文连贯性
Returns:
文档块列表
"""
chunks = []
start = 0
while start < len(text):
end = start + chunk_size
chunk = text[start:end]
chunks.append(chunk)
start = end - overlap # 重叠,保证上下文连贯
return chunks
分块策略选择:
固定大小分块:简单快速,适合结构化文档 语义分块:按句子或段落边界分块,保持语义完整性 滑动窗口:使用重叠窗口,避免信息丢失
3.3 向量化:选择 Embedding 模型
选择合适的 Embedding 模型至关重要:
| all-MiniLM-L6-v2 | ||||
| BGE-large-en-v1.5 | ||||
| BGE-large-zh-v1.5 | ||||
| E5-mistral-7b |
代码示例:
from sentence_transformers import SentenceTransformer
# 选择模型(根据需求)
embedding_model = "sentence-transformers/all-MiniLM-L6-v2" # 快速,80MB
# embedding_model = "BAAI/bge-large-en-v1.5" # 高精度,1.3GB
# 加载模型
encoder = SentenceTransformer(embedding_model)
# 生成向量
texts = ["Milvus is a vector database...", "RAG combines retrieval and generation..."]
embeddings = encoder.encode(texts, normalize_embeddings=True)
print(f"向量维度: {embeddings.shape}") # (2, 384) 或 (2, 1024)
3.4 创建 Milvus 集合
在插入数据之前,需要先创建集合(Collection):
from pymilvus import MilvusClient
# 连接Milvus(自动使用Milvus Lite)
client = MilvusClient(uri="./milvus_demo.db")
# 集合配置
collection_name = "documents"
dimension = 384# 根据Embedding模型选择:all-MiniLM-L6-v2=384, BGE-large=1024
# 检查集合是否存在
if client.has_collection(collection_name):
print(f"集合 {collection_name} 已存在,删除旧集合...")
client.drop_collection(collection_name)
# 创建集合
client.create_collection(
collection_name=collection_name,
dimension=dimension, # 向量维度
metric_type="L2", # 距离度量:L2(欧氏距离)或IP(内积)
auto_id=True, # 自动生成ID
)
print(f"✓ 集合 {collection_name} 创建成功")
3.5 插入数据
将向量和元数据插入 Milvus:
# 准备数据
documents = [
{
"text": "Milvus is an open-source vector database...",
"doc_id": "doc_001",
"title": "Introduction to Milvus"
},
# ... 更多文档
]
# 生成向量
texts = [doc["text"] for doc in documents]
embeddings = encoder.encode(texts, normalize_embeddings=True)
# 准备插入数据
data = []
for i, (emb, doc) in enumerate(zip(embeddings, documents)):
data.append({
"vector": emb.tolist(), # 向量(必须)
"text": doc["text"], # 文本内容
"doc_id": doc["doc_id"], # 业务ID
"title": doc["title"], # 标题
})
# 插入数据
client.insert(collection_name=collection_name, data=data)
print(f"✓ 成功插入 {len(data)} 个文档")
完整的数据准备脚本:
"""
完整的数据准备示例
"""
from pymilvus import MilvusClient
from sentence_transformers import SentenceTransformer
def prepare_data():
# 1. 连接Milvus
client = MilvusClient(uri="./milvus_demo.db")
collection_name = "documents"
# 2. 准备文档
documents = [
"Milvus is an open-source vector database...",
"RAG combines information retrieval with language models...",
# ... 更多文档
]
# 3. 初始化Embedding模型
encoder = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
dimension = 384
# 4. 创建集合
if client.has_collection(collection_name):
client.drop_collection(collection_name)
client.create_collection(
collection_name=collection_name,
dimension=dimension,
metric_type="L2",
auto_id=True,
)
# 5. 生成向量并插入
embeddings = encoder.encode(documents, normalize_embeddings=True)
data = [
{"vector": emb.tolist(), "text": doc}
for emb, doc in zip(embeddings, documents)
]
client.insert(collection_name=collection_name, data=data)
print(f"✓ 数据准备完成,共 {len(data)} 个文档")
if __name__ == "__main__":
prepare_data()
4. 核心实现:构建 RAG 系统
4.1 RAG 系统架构
一个完整的 RAG 系统包含以下组件:
用户查询
↓
向量检索(Milvus)← 知识库
↓
结果重排(可选)
↓
上下文构建
↓
LLM生成答案
4.2 基础 RAG 实现
让我们从最简单的 RAG 系统开始:
from pymilvus import MilvusClient
from sentence_transformers import SentenceTransformer
class SimpleRAGSystem:
"""基础RAG系统"""
def __init__(self, milvus_uri="./milvus_demo.db", collection_name="documents"):
# 连接Milvus
self.client = MilvusClient(uri=milvus_uri)
self.collection_name = collection_name
# 初始化Embedding模型
self.encoder = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
def retrieve(self, query: str, top_k: int = 10):
"""向量检索"""
# 1. 编码查询
query_vector = self.encoder.encode(query, normalize_embeddings=True)
query_vector = query_vector.tolist()
# 2. 在Milvus中搜索
results = self.client.search(
collection_name=self.collection_name,
data=[query_vector],
limit=top_k,
search_params={"metric_type": "L2", "params": {}},
output_fields=["text", "doc_id", "title"]
)
# 3. 格式化结果
retrieved_docs = []
for hit in results[0]:
retrieved_docs.append({
"id": hit.get("id", ""),
"text": hit.get("entity", {}).get("text", ""),
"score": hit.get("distance", 0.0),
"doc_id": hit.get("entity", {}).get("doc_id", ""),
"title": hit.get("entity", {}).get("title", ""),
})
return retrieved_docs
def query(self, user_query: str, top_k: int = 5):
"""查询流程"""
# 1. 检索
retrieved_docs = self.retrieve(user_query, top_k=top_k)
# 2. 构建上下文
context = "\n\n".join([doc["text"] for doc in retrieved_docs])
# 3. 返回结果(这里只返回上下文,实际应用中会调用LLM)
return {
"query": user_query,
"context": context,
"documents": retrieved_docs
}
# 使用示例
rag = SimpleRAGSystem()
result = rag.query("What is Milvus?")
print(result["context"])
4.3 增强版 RAG:添加重排
向量检索虽然快速,但可能不够精确。我们可以添加重排(Reranking)步骤来提升准确性:
from transformers import AutoModelForSequenceClassification, AutoTokenizer
import torch
class EnhancedRAGSystem(SimpleRAGSystem):
"""增强版RAG系统(带重排)"""
def __init__(self, milvus_uri="./milvus_demo.db", collection_name="documents"):
super().__init__(milvus_uri, collection_name)
# 初始化重排模型(可选)
self.reranker = None
self.reranker_tokenizer = None
try:
print("正在加载重排模型...")
reranker_model = "BAAI/bge-reranker-base"
self.reranker = AutoModelForSequenceClassification.from_pretrained(reranker_model)
self.reranker_tokenizer = AutoTokenizer.from_pretrained(reranker_model)
self.reranker.eval()
print("✓ 重排模型加载成功")
except Exception as e:
print(f"⚠️ 重排模型加载失败: {e},将跳过重排步骤")
def rerank(self, query: str, documents: List[str], top_k: int = 10):
"""重排:使用BGE-Reranker对检索结果进行精排"""
if self.reranker isNoneor len(documents) == 0:
return documents[:top_k]
# 构建查询-文档对
pairs = [[query, doc] for doc in documents]
# Tokenize
with torch.no_grad():
inputs = self.reranker_tokenizer(
pairs,
padding=True,
truncation=True,
return_tensors="pt",
max_length=512
)
# 计算相关性分数
scores = self.reranker(**inputs).logits.squeeze(-1)
# 按分数排序
ranked_indices = scores.argsort(descending=True)
# 返回Top-K
reranked_docs = [documents[idx] for idx in ranked_indices[:top_k]]
return reranked_docs
def query(self, user_query: str, retrieve_top_k: int = 100, rerank_top_k: int = 10):
"""查询流程:检索 → 重排 → 构建上下文"""
# 1. 向量检索(粗排)
retrieved_docs = self.retrieve(user_query, top_k=retrieve_top_k)
# 2. 重排(精排)
doc_texts = [doc["text"] for doc in retrieved_docs]
reranked_texts = self.rerank(user_query, doc_texts, top_k=rerank_top_k)
# 3. 构建上下文
context = "\n\n".join(reranked_texts)
return {
"query": user_query,
"context": context,
"retrieved_count": len(retrieved_docs),
"reranked_count": len(reranked_texts)
}
重排的优势:
提升准确性:重排模型考虑查询和文档的交互,比单纯向量相似度更准确 灵活调整:可以调整重排后的 Top-K,平衡准确性和成本 效果显著:通常能提升 15-22%的准确率
5. 关键优化:突破 U 型陷阱
5.1 什么是 U 型陷阱?
研究发现,长上下文语言模型存在位置偏差(Position Bias):
开头位置(Primacy Bias):准确率 ~75.8% ✅ 中间位置(Lost in the Middle):准确率 ~53.8% ❌ 结尾位置(Recency Bias):准确率 ~63.2% ✅
这意味着,如果关键信息放在中间位置,模型可能无法有效利用,导致性能下降。
5.2 位置优化策略
通过位置优化,我们可以突破 U 型陷阱:
核心策略:
最相关文档 → 开头:利用 Primacy Bias 次相关文档 → 中间:低优先级 用户问题 → 结尾:利用 Recency Bias
5.3 实现位置优化
class OptimizedRAGSystem(EnhancedRAGSystem):
"""优化版RAG系统(位置优化)"""
def build_context(self, query: str, retrieved_docs: List[Dict[str, Any]]) -> str:
"""
构建上下文(位置优化:突破U型陷阱的关键步骤)
策略:
- 最相关文档 → 开头(利用Primacy Bias)
- 次相关文档 → 中间(低优先级)
- 用户问题 → 结尾(利用Recency Bias)
"""
if len(retrieved_docs) == 0:
returnf"系统提示:请回答问题。\n\n用户问题:{query}"
# 按相关性排序(最相关的在前)
sorted_docs = sorted(
retrieved_docs,
key=lambda x: x.get("score", 0) if isinstance(x.get("score"), (int, float)) else0,
reverse=True# 分数越高越好(如果是相似度分数)
)
# 构建上下文
context_parts = []
# 系统提示
context_parts.append("系统提示:请基于以下文档回答问题。\n")
# 最相关文档(开头位置 - 利用Primacy Bias)
context_parts.append("# 最相关文档(开头位置)\n")
top_docs = sorted_docs[:min(3, len(sorted_docs))]
for i, doc in enumerate(top_docs, 1):
text = doc.get("text", "")
context_parts.append(f"文档 {i}:{text}\n")
# 次相关文档(中间位置)
if len(sorted_docs) > 3:
context_parts.append("\n# 次相关文档(中间位置)\n")
secondary_docs = sorted_docs[3:min(7, len(sorted_docs))]
for i, doc in enumerate(secondary_docs, 4):
text = doc.get("text", "")
context_parts.append(f"文档 {i}:{text}\n")
# 用户问题(结尾位置 - 利用Recency Bias)
context_parts.append("\n# 用户问题(结尾位置)\n")
context_parts.append(f"用户问题:{query}")
return"\n".join(context_parts)
def query(self, user_query: str, retrieve_top_k: int = 100, rerank_top_k: int = 10):
"""完整查询流程:检索 → 重排 → 位置优化 → 生成"""
prin…