<think>我们正在构建一个RAG系统，使用LangChain作为框架，Milvus作为向量数据库，bge-m3作为嵌入模型。以下是实现步骤：1.**环境准备**：-安装必要的库：langchain,pymilvus,transformers等。-下载bge-m3模型（可以从ModelScope或HuggingFace下载）。2.**文档加载与处理**：-使用LangChain的文档加载器（如`TextLoader`、`DirectoryLoader`）加载文档。-对文档进行拆分（使用`RecursiveCharacterTextSplitter`等），注意设置合适的块大小和重叠。3.**嵌入模型**：-初始化bge-m3模型，该模型能够生成稠密向量（denseembeddings）和稀疏向量（sparseembeddings）。-由于Milvus支持混合搜索（hybridsearch），我们将同时使用这两种向量。4.**向量数据库（Milvus）**：-在Milvus中创建两个集合（collections）或一个支持多向量的集合，分别存储稠密向量和稀疏向量（或者使用一个集合包含两个向量字段）。-注意：Milvus2.4及以上版本支持多向量字段，因此可以创建一个集合，包含两个向量字段：一个稠密向量字段和一个稀疏向量字段（注意Milvus对稀疏向量的支持情况，目前Milvus支持稀疏向量SPARSE_FLOAT_VECTOR）。5.**文档向量化与存储**：-将拆分后的文档通过bge-m3模型生成稠密向量和稀疏向量。-将文档块内容、元数据以及对应的两种向量存储到Milvus中。6.**检索**：-用户输入查询问题，同样使用bge-m3生成查询的稠密向量和稀疏向量。-使用Milvus的混合搜索（hybridsearch）功能，同时利用两种向量进行检索，并融合结果（例如使用RRF（ReciprocalRankFusion）或其他方法）。-返回最相关的文档块。7.**生成**：-将检索到的文档块作为上下文，与用户问题一起输入到大语言模型（LLM）中，生成回答。下面我们详细说明每一步，并给出代码示例。###步骤1：环境准备首先，安装必要的库：```bashpipinstalllangchainpymilvustransformers```然后，下载bge-m3模型。由于模型较大，建议使用ModelScope（国内更快）或HuggingFace。这里使用ModelScope：```bashgitlfsinstallgitclonehttps://www.modelscope.cn/Xorbits/bge-m3.git```###步骤2：文档加载与处理假设我们有一个文档目录，里面存放着多个文本文件。```pythonfromlangchain.document_loadersimportDirectoryLoaderfromlangchain.text_splitterimportRecursiveCharacterTextSplitter#加载文档loader=DirectoryLoader('./docs',glob="**/*.txt")documents=loader.load()#拆分文档text_splitter=RecursiveCharacterTextSplitter(chunk_size=500,chunk_overlap=50)texts=text_splitter.split_documents(documents)```###步骤3：初始化嵌入模型我们使用`transformers`库加载bge-m3模型。注意，bge-m3可以同时生成稠密向量和稀疏向量（稀疏向量是SPLADE表示）。```pythonfromtransformersimportAutoModel,AutoTokenizermodel_path="path/to/bge-m3"#替换为实际路径tokenizer=AutoTokenizer.from_pretrained(model_path)model=AutoModel.from_pretrained(model_path)```###步骤4：设置Milvus向量数据库确保Milvus服务已经启动。然后，我们使用`pymilvus`连接Milvus，并创建集合。```pythonfrompymilvusimportconnections,FieldSchema,CollectionSchema,DataType,Collection,utility#连接Milvusconnections.connect("default",host="localhost",port="19530")#定义集合的字段fields=[FieldSchema(name="id",dtype=DataType.INT64,is_primary=True,auto_id=True),FieldSchema(name="text",dtype=DataType.VARCHAR,max_length=1000),FieldSchema(name="dense_vector",dtype=DataType.FLOAT_VECTOR,dim=1024),#bge-m3稠密向量维度为1024FieldSchema(name="sparse_vector",dtype=DataType.SPARSE_FLOAT_VECTOR)#稀疏向量]#创建集合schema=CollectionSchema(fields,"RAGusingbge-m3andMilvus")collection_name="bge_m3_docs"ifutility.has_collection(collection_name):utility.drop_collection(collection_name)collection=Collection(collection_name,schema)#创建索引（稠密向量使用IVF_FLAT，稀疏向量使用SPARSE_INVERTED_INDEX）index_params_dense={"index_type":"IVF_FLAT","metric_type":"L2","params":{"nlist":1024}}index_params_sparse={"index_type":"SPARSE_INVERTED_INDEX","metric_type":"IP"#内积}collection.create_index("dense_vector",index_params_dense)collection.create_index("sparse_vector",index_params_sparse)```###步骤5：文档向量化与存储对每个文本块，使用bge-m3生成稠密向量和稀疏向量，然后插入Milvus。```pythonimporttorchimportnumpyasnpfrompymilvusimportMilvusClient#初始化Milvus客户端client=MilvusClient(uri="http://localhost:19530",db_name="default")#准备批量插入的数据data=[]fortextintexts:#使用bge-m3生成向量inputs=tokenizer(text.page_content,return_tensors="pt")withtorch.no_grad():outputs=model(**inputs)#获取稠密向量dense_embedding=outputs.last_hidden_state.mean(dim=1).squeeze().numpy()#获取稀疏向量（SPLADE）sparse_embedding=outputs.logits.max(dim=1)[0].squeeze().numpy()#将稀疏向量转换为字典格式（索引:值）sparse_dict={idx:valueforidx,valueinenumerate(sparse_embedding)ifvalue!=0}data.append({"text":text.page_content,"dense_vector":dense_embedding.tolist(),"sparse_vector":sparse_dict})#插入数据client.insert(collection_name,data)```###步骤6：检索用户查询时，同样生成两种向量，然后进行混合搜索。```pythondefhybrid_search(query,top_k=5):#生成查询向量inputs=tokenizer(query,return_tensors="pt")withtorch.no_grad():outputs=model(**inputs)dense_embedding=outputs.last_hidden_state.mean(dim=1).squeeze().numpy()sparse_embedding=outputs.logits.max(dim=1)[0].squeeze().numpy()sparse_dict={idx:valueforidx,valueinenumerate(sparse_embedding)ifvalue!=0}#分别进行稠密搜索和稀疏搜索#稠密搜索dense_results=client.search(collection_name=collection_name,data=[dense_embedding.tolist()],anns_field="dense_vector",param={"metric_type":"L2","params":{"nprobe":10}},limit=top_k,output_fields=["text"])#稀疏搜索（注意：Milvus的稀疏向量搜索使用内积，且返回的分数是内积值）sparse_results=client.search(collection_name=collection_name,data=[sparse_dict],anns_field="sparse_vector",param={"metric_type":"IP"},limit=top_k,output_fields=["text"])#融合结果（简单示例：使用RRF）#为每个文档分配一个融合后的分数scores={}#处理稠密结果foridx,hitinenumerate(dense_results[0]):doc_id=hit.id#RRF:1/(rank+k)这里k设为60（常用值）rrf_score=1.0/(idx+60)scores[doc_id]=scores.get(doc_id,0)+rrf_score#处理稀疏结果foridx,hitinenumerate(sparse_results[0]):doc_id=hit.idrrf_score=1.0/(idx+60)scores[doc_id]=scores.get(doc_id,0)+rrf_score#按融合分数排序sorted_scores=sorted(scores.items(),key=lambdax:x[1],reverse=True)top_doc_ids=[doc_idfordoc_id,scoreinsorted_scores[:top_k]]#获取文档内容results=client.get(collection_name,ids=top_doc_ids,output_fields=["text"])return[res['text']forresinresults]```###步骤7：生成使用LangChain的LCEL（LangChainExpressionLanguage）或简单的链式调用，将检索到的文档作为上下文，输入到LLM中。```pythonfromlangchain.llmsimportOpenAIfromlangchain.promptsimportPromptTemplatefromlangchain.schema.runnableimportRunnablePassthrough#初始化LLMllm=OpenAI(api_key="your-openai-key")#定义提示模板template="""基于以下上下文，回答用户问题：{context}问题：{question}"""prompt=PromptTemplate.from_template(template)#定义RAG链defretrieve(question):returnhybrid_search(question)chain=({"context":retrieve,"question":RunnablePassthrough()}|prompt|llm)#调用链response=chain.invoke("用户的问题")print(response)```###注意事项1.**性能考虑**：bge-m3模型较大，推理速度较慢，可以考虑使用GPU加速。2.**混合搜索的融合策略**：这里使用了简单的RRF，也可以尝试其他融合方法，如加权分数等。3.**Milvus的稀疏向量支持**：确保Milvus版本支持稀疏向量（2.4及以上）。4.**文档分块大小**：根据实际文档调整分块大小和重叠。以上是一个完整的RAG系统实现方案，结合了LangChain、Milvus和bge-m3的优势。###相关问题1.如何优化bge-m3模型的推理速度？2.在Milvus中，如何调整索引参数以提高搜索性能？3.除了RRF，还有哪些融合检索结果的方法？4.如何处理大文档的嵌入，避免内存溢出？</think>### 使用 LangChain + Milvus + BGE-M3 实现 RAG 方案
以下是完整的实现方案，分为 6 个关键步骤：
#### 1. **环境准备**
```python
# 安装核心库
pip install langchain pymilvus sentence-transformers
git clone https://www.modelscope.cn/Xorbits/bge-m3.git # 下载模型[^1]
```
#### 2. **初始化组件**
```python
from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from pymilvus import connections, Collection
from transformers import AutoModel, AutoTokenizer
# 连接 Milvus
connections.connect(host="localhost", port="19530")
# 加载 BGE-M3 模型[^3]
model = AutoModel.from_pretrained("./bge-m3")
tokenizer = AutoTokenizer.from_pretrained("./bge-m3")
```
#### 3. **文档处理与向量化**
```python
# 加载文档
loader = TextLoader("data.txt")
documents = loader.load()
# 文档分块（关键步骤）[^2]
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=512,
chunk_overlap=50
)
chunks = text_splitter.split_documents(documents)
# 生成混合向量
def get_embeddings(text):
inputs = tokenizer(text, return_tensors="pt")
outputs = model(**inputs)
dense_embed = outputs.last_hidden_state.mean(dim=1).squeeze().tolist()
sparse_embed = outputs.logits.max(dim=1)[0].squeeze().numpy()
return dense_embed, sparse_embed
```
#### 4. **Milvus 向量库配置**
```python
# 创建集合（支持混合向量）[^4]
collection = Collection.create(
"rag_collection",
fields=[
{"name": "id", "type": "INT64", "is_primary": True},
{"name": "text", "type": "VARCHAR", "max_length": 1000},
{"name": "dense_vector", "type": "FLOAT_VECTOR", "dim": 1024},
{"name": "sparse_vector", "type": "SPARSE_FLOAT_VECTOR"}
]
)
# 创建双索引
collection.create_index(
field_name="dense_vector",
index_params={"index_type": "IVF_FLAT", "metric_type": "L2"}
)
collection.create_index(
field_name="sparse_vector",
index_params={"index_type": "SPARSE_INVERTED_INDEX"}
)
```
#### 5. **检索增强流程**
```python
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
# 混合检索函数
def hybrid_search(query, top_k=5):
dense_emb, sparse_emb = get_embeddings(query)
# 并行执行双向量检索
dense_results = collection.search(
data=[dense_emb],
anns_field="dense_vector",
limit=top_k
)
sparse_results = collection.search(
data=[sparse_emb],
anns_field="sparse_vector",
limit=top_k
)
# 结果融合 (RRF 算法)
return reciprocal_rank_fusion(dense_results, sparse_results)
# 构建 RAG 链
qa_chain = RetrievalQA.from_chain_type(
llm=OpenAI(temperature=0),
chain_type="stuff",
retriever=hybrid_search,
return_source_documents=True
)
```
#### 6. **运行与优化**
```python
# 插入文档向量
for chunk in chunks:
dense_vec, sparse_vec = get_embeddings(chunk.page_content)
collection.insert([
{"text": chunk.page_content},
{"dense_vector": dense_vec},
{"sparse_vector": sparse_vec}
])
# 执行查询
response = qa_chain("什么是量子纠缠？")
print(f"答案: {response['result']}")
print(f"来源: {response['source_documents'][0].page_content}")
```
### 关键优势说明
1. **多粒度检索**：BGE-M3 支持词级/句级/段落级嵌入[^3]，提升语义捕获能力
2. **混合搜索**：同时利用稠密向量的语义信息和稀疏向量的关键词信息[^4]
3. **性能优化**：
- 分块大小建议 256-512 字符[^2]
- 使用 `IVF_FLAT` + `SPARSE_INVERTED_INDEX` 组合索引
- 批处理文档插入（每次 500-1000 条）
### 常见问题解决
- **OOM 错误**：减小分块尺寸或启用 `model.half()` 半精度
- **低召回率**：调整分块重叠（建议 10-15%）或尝试不同分块策略
- **延迟过高**：在 Milvus 中启用 GPU 加速或增加 `nprobe` 参数
### 相关问题
1. 如何评估 RAG 系统中检索结果的质量？
2. BGE-M3 与其他嵌入模型（如 OpenAI Embeddings）相比有何优势？
3. 在资源受限环境中如何优化 Milvus 的性能？
4. 如何处理 RAG 中的长文档上下文溢出问题？
5. 如何实现基于 RAG 的多轮对话系统？
[^1]: 从 huggingface 或国内的 modelscope 下载 BGE-M3 模型
[^2]: 文档拆分的注意点，embedding model， chat model区别
[^3]: BGE-M3：Multi-Functionality Multi-Linguisticity Multi-Granularity
[^4]: 混合搜索同时使用稠密向量和稀疏向量增强准确性
最低0.47元/天 解锁文章
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
