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 系统时,我们需要一个能够:

  1. 快速检索:从大规模文档库中快速找到相关文档
  2. 精确匹配:通过向量相似度找到语义相关的文档
  3. 易于集成:与现有 AI 工具链无缝集成
  4. 生产就绪:支持高并发、高可用部署

Milvus 完美满足这些需求,已成为 RAG 系统的首选向量数据库。

1.3 Milvus Lite vs Milvus Server

Milvus 提供了两种使用方式:

特性
Milvus Lite
Milvus Server
部署方式
本地文件,无需启动服务
独立服务,需要启动
适用场景
开发、测试、小规模应用
生产环境、大规模应用
数据存储
本地文件(.db)
分布式存储
性能
适合中小规模(<100 万向量)
支持大规模(百万到百亿级)
使用方式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 文档预处理

在实际应用中,我们需要将原始文档转换为向量。这个过程包括:

  1. 文档加载:从文件、数据库或 API 加载文档
  2. 文档分块:将长文档切分为较小的块(chunks)
  3. 向量化:使用 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
384
英文
快速原型、演示
⭐⭐⭐
BGE-large-en-v1.5
1024
英文
生产环境、高精度
⭐⭐⭐⭐⭐
BGE-large-zh-v1.5
1024
中文
中文检索
⭐⭐⭐⭐⭐
E5-mistral-7b
4096
多语言
长文档检索
⭐⭐⭐⭐

代码示例:

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 型陷阱:

核心策略:

  1. 最相关文档 → 开头:利用 Primacy Bias
  2. 次相关文档 → 中间:低优先级
  3. 用户问题 → 结尾:利用 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…
— 以上为试看内容(约 40%),开通会员后阅读全文 —