langchain4j+milvus实战

本文主要研究一下如何使用langchain4j来对接向量数据库milvus

步骤

docker运行milvus

docker run -d \
        --name milvus-standalone \
        --security-opt seccomp:unconfined \
        -e ETCD_USE_EMBED=true \
        -e ETCD_DATA_DIR=/var/lib/milvus/etcd \
        -e ETCD_CONFIG_PATH=/milvus/configs/embedEtcd.yaml \
        -e COMMON_STORAGETYPE=local \
        -v $(pwd)/volumes/milvus:/var/lib/milvus \
        -v $(pwd)/embedEtcd.yaml:/milvus/configs/embedEtcd.yaml \
        -v $(pwd)/user.yaml:/milvus/configs/user.yaml \
        -p 19530:19530 \
        -p 9091:9091 \
        -p 2379:2379 \
        --health-cmd="curl -f http://localhost:9091/healthz" \
        --health-interval=30s \
        --health-start-period=90s \
        --health-timeout=20s \
        --health-retries=3 \
        docker.1ms.run/milvusdb/milvus:v2.5.5 \
        milvus run standalone  1> /dev/null

启动之后访问http://127.0.0.1:9091/webui

在这里插入图片描述

这里需要提前创建embedEtcd.yaml

listen-client-urls: http://0.0.0.0:2379
advertise-client-urls: http://0.0.0.0:2379
quota-backend-bytes: 4294967296
auto-compaction-mode: revision
auto-compaction-retention: '1000'

user.yaml内容为空即可

pom.xml

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-milvus</artifactId>
    <version>1.0.0-beta1</version>
</dependency>

example

public class JlamaMilvusExample {

    public static void main(String[] args) throws InterruptedException {
        EmbeddingModel embeddingModel = JlamaEmbeddingModel.builder()
                .modelName("intfloat/e5-small-v2")
                .build();

        MilvusServiceClient customMilvusClient = new MilvusServiceClient(
                ConnectParam.newBuilder()
                        .withHost("localhost")
                        .withPort(19530)
                        .build()
        );
        MilvusEmbeddingStore embeddingStore = MilvusEmbeddingStore.builder()
                .milvusClient(customMilvusClient)
                .collectionName("example_collection")      // Name of the collection
                .dimension(384)                            // Dimension of vectors
                .indexType(IndexType.FLAT)                 // Index type
                .metricType(MetricType.COSINE)             // Metric type
                .consistencyLevel(ConsistencyLevelEnum.EVENTUALLY)  // Consistency level
                .autoFlushOnInsert(true)                   // Auto flush after insert
                .idFieldName("id")                         // ID field name
                .textFieldName("text")                     // Text field name
                .metadataFieldName("metadata")             // Metadata field name
                .vectorFieldName("vector")                 // Vector field name
                .build();                                  // Build the MilvusEmbeddingStore instance

        TextSegment segment1 = TextSegment.from("I like football.");
        Embedding embedding1 = embeddingModel.embed(segment1).content();
        embeddingStore.add(embedding1, segment1);

        TimeUnit.SECONDS.sleep(60);

        TextSegment segment2 = TextSegment.from("The weather is good today.");
        Embedding embedding2 = embeddingModel.embed(segment2).content();
        embeddingStore.add(embedding2, segment2);

        TimeUnit.SECONDS.sleep(60);

        String userQuery = "What is your favourite sport?";
        Embedding queryEmbedding = embeddingModel.embed(userQuery).content();
        int maxResults = 1;
        List<EmbeddingMatch<TextSegment>> relevant = embeddingStore.findRelevant(queryEmbedding, maxResults);
        EmbeddingMatch<TextSegment> embeddingMatch = relevant.get(0);

        System.out.println("Question: " + userQuery); // What is your favourite sport?
        System.out.println("Response: " + embeddingMatch.embedded().text()); // I like football.
    }
}

最后输出

WARNING: Using incubator modules: jdk.incubator.vector
INFO  c.g.tjake.jlama.model.AbstractModel - Model type = F32, Working memory type = F32, Quantized memory type = F32
WARN  c.g.t.j.t.o.TensorOperationsProvider - Native operations not available. Consider adding 'com.github.tjake:jlama-native' to the classpath
INFO  c.g.t.j.t.o.TensorOperationsProvider - Using Panama Vector Operations (OffHeap)
Question: What is your favourite sport?
Response: I like football.

quotaAndLimits

quotaAndLimits:
  enabled: true # `true` to enable quota and limits, `false` to disable.
  # quotaCenterCollectInterval is the time interval that quotaCenter
  # collects metrics from Proxies, Query cluster and Data cluste
<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系统实现方案,结合了LangChainMilvus和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]: 混合搜索同时使用稠密向量和稀疏向量增强准确性
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值