工作流程
大语言模型 重排序器 Milvus Elasticsearch 应用程序 用户 大语言模型 重排序器 Milvus Elasticsearch 应用程序 用户 1. 数据索引阶段 2. 用户查询与检索阶段 par 并行检索 3. 融合与重排序 4. 生成回答 文档切块(Chunking) 调用 Embedding 模型 存储文本块与嵌入向量 存储文本块与嵌入向量 输入问题(Query) 调用 Embedding 模型 关键词检索 返回相关文本块 (BM25) 向量检索 返回相关文本块 (语义) 融合结果 (RRF/加权) 调用 Reranker 模型 返回重排序后的Top-K结果 构建提示词(Prompt) + 上下文 生成最终回答 返回回答
ollam+llm
[安装参考](https://blog.csdn.net/wenwang3000/article/details/145705858)这里需要2种类型的
milvus安装
参考：https://milvus.io/docs/zh 线上环境采用集群版本，这里只做演示配 配置轻量版本 Milvus Lite
shell
#安装 pymilvus 客户端
pip install pymilvus
#安装 milvus 服务端包
pip install milvus
#启动 Milvus 本地服务
milvus-server --data D:\logs\milvus_data
milvus客户端工具
参考：https://github.com/zilliztech/attu/blob/main/README_CN.md
collection
elasticsearch安装
[集群配置参考](https://blog.csdn.net/wenwang3000/article/details/99820920)，这里受环境限制配置单节点
配置
shell
# 配置项
cluster.name: es8
node.name: node1
path.data: D:\DataBase\elasticsearch-8.19.14\data
path.logs: D:\DataBase\elasticsearch-8.19.14\logs
network.host: 127.0.0.1
http.port: 9200
discovery.type: single-node
xpack.security.enabled: false
http.cors.enabled: true
http.cors.allow-origin: "*"ik分词器
java
#安装 ik分词器 插件
cd D:\DataBase\elasticsearch-8.19.14\plugins
.\elasticsearch-plugin install https://release.infinilabs.com/analysis-ik/stable/elasticsearch-analysis-ik-8.19.14.zip
启动服务
java
# 启动服务 不带任何参数） 打开浏览器，访问 http://localhost:9200
elasticsearch.bat（不带任何参数）
elasticsearch客户端工具
轻量、现代化的Web UI；可作为浏览器插件一键安装，极客风，支持REST API调试 https://github.com/cars10/elasticvue
浏览器插件版本：
展示效果
核心代码(java版本)
jar依赖
java
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.5.9</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.spring.cloud.admin</groupId>
<artifactId>com-spring-ai</artifactId>
<version>1.0</version>
<name>com-spring-ai</name>
<description>admin</description>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>17</java.version>
<spring-ai.version>1.0.0</spring-ai.version>
<elasticsearch-java.version>8.12.0</elasticsearch-java.version>
<milvus-sdk-java.version>2.6.18</milvus-sdk-java.version>
<commons-lang3.version>3.7</commons-lang3.version>
<alibaba-fastjson.version>1.2.58</alibaba-fastjson.version>
<org-projectlombok.version>1.18.44</org-projectlombok.version>
<jackson.version>2.15.3</jackson.version>
<langchain4j.version>1.13.1</langchain4j.version>
</properties>
<dependencies>
<!-- LangChain4j core + OpenAI -->
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j</artifactId>
<version>${langchain4j.version}</version>
</dependency>
<!-- LangChain4j Ollama 集成 -->
<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j-ollama</artifactId>
<version>${langchain4j.version}</version>
</dependency>
<!-- 文档解析器（支持 PDF/Word/HTML 等） -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-tika-document-reader</artifactId>
<exclusions>
<exclusion>
<groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- Apache Commons Compress - 修复 Tika ZIP 处理问题 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId>
<version>1.26.0</version>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-pdf-document-reader</artifactId>
</dependency>
<!-- Spring AI -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-ollama</artifactId>
</dependency>
<!--<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-vector-store-milvus</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-advisors-vector-store</artifactId>
</dependency>-->
<!-- Elasticsearch Java Client -->
<dependency>
<groupId>co.elastic.clients</groupId>
<artifactId>elasticsearch-java</artifactId>
<version>${elasticsearch-java.version}</version>
</dependency>
<!-- Milvus Java SDK -->
<dependency>
<groupId>io.milvus</groupId>
<artifactId>milvus-sdk-java</artifactId>
<version>${milvus-sdk-java.version}</version>
</dependency>
<!-- Jackson for JSON -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.version}</version>
</dependency>
<!--common-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>${commons-lang3.version}</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${alibaba-fastjson.version}</version>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
<version>${org-projectlombok.version}</version>
</dependency>
<!--web-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-bom</artifactId>
<version>${spring-ai.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>yml配置
java
server:
port: 8080
servlet:
# 项目contextPath
context-path: /
spring:
application:
name: ai
#ai
ai:
ollama:
base-url: http://localhost:11434
chat:
options:
model: qwen3.5:2b
temperature: 0.7
embedding:
options:
model: qwen3-embedding:0.6b
autoconfigure:
exclude:
- org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration
- org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration
# Elasticsearch Configuration
elasticsearch:
host: localhost
port: 9200
scheme: http
username:
password:
index:
name: documents
# Milvus Configuration
milvus:
host: localhost
port: 19530
db-name: test
collection:
name: test_ai
index:
type: IVF_FLAT
metric-type: IP
embedding-dimension: 1024
search.top: 2
logging:
level:
com.example: DEBUG服务入口
java
package com.controller;
import com.ai.rag.bean.AskRequest;
import com.ai.rag.bean.DocumentChunk;
import com.ai.rag.bean.FIleInfo;
import com.ai.rag.service.DocumentChunkService;
import com.ai.rag.service.RagQueryService;
import com.alibaba.fastjson.JSONObject;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.document.Document;
import org.springframework.ai.reader.tika.TikaDocumentReader;
import org.springframework.ai.transformer.splitter.TokenTextSplitter;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.*;
/**
┌─────────────────────────────────────────────────────────────────────┐
│ Spring Boot Application │
├─────────────────────────────────────────────────────────────────────┤
│ API Layer │
├─────────────────────────────────────────────────────────────────────┤
│ DocumentService │
│ (双写入库核心调度层) │
├─────────────────────────────────────────────────────────────────────┤
│ EmbeddingService │
│ (Ollama Chunk + 向量转换) │
├───────────────────────────────────┬─────────────────────────────────┤
│ ElasticsearchService │ MilvusService │
│ (全文检索 + 文本存储) │ (向量检索 + 向量存储) │
├───────────────────────────────────┴─────────────────────────────────┤
│ VectorStore │
│ (双写入库事务/补偿机制) │
└─────────────────────────────────────────────────────────────────────┘
*/
@Slf4j
@RestController
@RequestMapping("/api/rag")
public class RagController {
private final DocumentChunkService documentChunkService;
private final RagQueryService ragQueryService;
public RagController(DocumentChunkService documentChunkService,
RagQueryService ragQueryService) {
this.documentChunkService = documentChunkService;
this.ragQueryService = ragQueryService;
}
/**
* 全文检索接口
*/
@GetMapping("/search/text")
public ResponseEntity<List<DocumentChunk>> textSearch(@RequestParam String query,
@RequestParam(defaultValue = "10") int limit) {
return ResponseEntity.ok(ragQueryService.getSearchResults(query, limit));
}
/**
* 混合检索接口
*/
@GetMapping("/search/hybrid/{topK}")
public ResponseEntity<List<DocumentChunk>> hybridSearch(
@RequestParam String query,
@PathVariable(required = false) Integer topK) {
int finalTopK = (topK != null) ? topK : 10;
return ResponseEntity.ok(ragQueryService.hybridSearch(query, topK));
}
/**
* RAG 问答接口
*/
@PostMapping("/ask")
public ResponseEntity<Map<String, String>> askQuestion(@RequestBody AskRequest request) {
log.info("askQuestion-入参{}", JSONObject.toJSONString(request));
String answer = ragQueryService.askQuestion(request.getQuestion());
Map<String, String> response = new HashMap<>();
response.put("question", request.getQuestion());
response.put("answer", answer);
return ResponseEntity.ok(response);
}
@RequestMapping("/tikaDocument")
public String tikaDocument(@RequestBody FIleInfo fIleInfo) {
log.info("tikaDocument-入参{}", JSONObject.toJSONString(fIleInfo));
/**
* 基于Apache Tika 技术实现，支持自动检测和解析超过 1000 种文件格式。
*可处理 PDF、DOC/DOCX、PPT/PPTX、XLS/XLSX、HTML、EPUB、ZIP（内含文档）等主流办公与结构化文档格式
* 统一文本提取：将异构文档转换为标准化的纯文本，便于后续 AI 处理（如 RAG、知识库构建、文档分类等）
* 元数据保留：自动提取作者、创建日期、MIME 类型等结构化信息
*Spring 生态集成：作为 DocumentReader 接口的实现，可无缝接入 Spring AI 的文档处理流水线
*/
TikaDocumentReader reader = new TikaDocumentReader(fIleInfo.getUrl());
/**
* * PagePdfDocumentReader - 按页面读取PDF文档，适合需要分页处理的场景
* * ParagraphPdfDocumentReader - 按段落读取PDF文档，保持文档的逻辑结构
*/
//PagePdfDocumentReader reader = new PagePdfDocumentReader(fIleInfo.getUrl());
/**
* Spring AI 提供的按 Token 精确切分长文本的工具，核心用于 RAG 场景，把超长文档切分成符合大模型上下文限制的小块，同时保证语义连贯
* 精确按 Token 计数，底层集成专业分词器，安全适配模型要求
* int defaultChunkSize = 800, // 每块最大 Token 数
* int chunkOverlap = 160, // 块间重叠 Token 数（默认 20%）
* int minChunkSizeChars = 350, // 每块最小字符数
* int minChunkLengthToEmbed = 5, // 可嵌入的最小长度
* int maxNumChunks = 10000, // 最大分块数
* boolean keepSeparator = true // 保留分隔符（换行/句号）
*/
TokenTextSplitter splitter = new TokenTextSplitter();
List<Document> documents = splitter.apply(reader.read());
log.info("tikaDocument-分割结果:{}", documents.size());
List<DocumentChunk> chunks = new ArrayList<>();
for (int i = 0; i < documents.size(); i++) {
DocumentChunk chunk = DocumentChunk.builder()
.id(documents.get(i).getId())
.documentId(fIleInfo.getDocumentId())
.content(documents.get(i).getText())
.title(fIleInfo.getTitle())
.author(fIleInfo.getAuthor())
.category(fIleInfo.getCategory())
.chunkIndex(i)
.createdAt(new Date())
.updatedAt(new Date())
.totalChunks(documents.size())
.build();
chunks.add(chunk);
}
if (chunks.size() >0){
documentChunkService.batchDualWriteDocumentChunks(chunks);
}
return "ok";
}
}基础服务
milvus服务
java
package com.ai.rag.service;
import com.ai.rag.bean.DocumentChunk;
import com.ai.rag.constant.FiledEnums;
import io.milvus.client.MilvusServiceClient;
import io.milvus.grpc.DataType;
import io.milvus.grpc.MutationResult;
import io.milvus.grpc.SearchResults;
import io.milvus.param.*;
import io.milvus.param.collection.*;
import io.milvus.param.dml.DeleteParam;
import io.milvus.param.dml.InsertParam;
import io.milvus.param.dml.SearchParam;
import io.milvus.param.index.CreateIndexParam;
import io.milvus.response.QueryResultsWrapper;
import io.milvus.response.SearchResultsWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import jakarta.annotation.PostConstruct;
import java.util.*;
import java.util.stream.Collectors;
@Slf4j
@Service
public class MilvusService {
@Value("${milvus.host}")
private String milvusHost;
@Value("${milvus.port}")
private int milvusPort;
@Value("${milvus.db-name}")
private String dbName;
@Value("${milvus.collection.name}")
private String collectionName;
@Value("${milvus.index.type}")
private String indexType;
@Value("${milvus.index.metric-type}")
private String metricType;
@Value("${milvus.index.embedding-dimension}")
private Integer embeddingDim;
private MilvusServiceClient milvusClient;
@PostConstruct
public void init() {
ConnectParam connectParam = ConnectParam.newBuilder()
.withHost(milvusHost)
.withPort(milvusPort)
.withDatabaseName(dbName)
.build();
milvusClient = new MilvusServiceClient(connectParam);
log.info("Connected to Milvus at {}:{}", milvusHost, milvusPort);
// 创建集合（如果不存在）
createCollectionIfNotExists();
}
private void createCollectionIfNotExists() {
// 检查集合是否存在
R<Boolean> hasCollectionRes = milvusClient.hasCollection(
HasCollectionParam.newBuilder()
.withCollectionName(collectionName)
.build()
);
if (hasCollectionRes.getData()) {
log.info("Milvus collection already exists: {}", collectionName);
return;
}
// 定义字段结构
List<FieldType> fieldTypes = Arrays.asList(
FieldType.newBuilder()
.withName(FiledEnums.id.getCode())
.withDataType(DataType.VarChar)
.withMaxLength(255)
.withPrimaryKey(true)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.documentId.getCode())
.withDataType(DataType.VarChar)
.withMaxLength(255)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.content.getCode())
.withDataType(DataType.VarChar)
.withMaxLength(65535)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.title.getCode())
.withDataType(DataType.VarChar)
.withMaxLength(255)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.author.getCode())
.withDataType(DataType.VarChar)
.withMaxLength(255)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.category.getCode())
.withDataType(DataType.VarChar)
.withMaxLength(255)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.chunkIndex.getCode())
.withDataType(DataType.Int32)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.totalChunks.getCode())
.withDataType(DataType.Int32)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.createdAt.getCode())
.withDataType(DataType.Int64)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.updatedAt.getCode())
.withDataType(DataType.Int64)
.build(),
// 2.6+版本才支持
/* FieldType.newBuilder()
.withName(FiledEnums.createdAt.getCode())
.withDataType(DataType.Timestamptz)
.build(),
FieldType.newBuilder()
.withName(FiledEnums.updatedAt.getCode())
.withDataType(DataType.Timestamptz)
.build(),*/
FieldType.newBuilder()
.withName(FiledEnums.embedding.getCode())
.withDataType(DataType.FloatVector)
.withDimension(embeddingDim)
.build()
);
CreateCollectionParam createParam = CreateCollectionParam.newBuilder()
.withCollectionName(collectionName)
.withDescription("测试db双写")
.withFieldTypes(fieldTypes)
.build();
R<RpcStatus> res = milvusClient.createCollection(createParam);
if (res.getStatus() == R.Status.Success.getCode()) {
log.info("Created Milvus collection: {}", collectionName);
createIndex();
} else {
log.error("Failed to create Milvus collection: {}", res.getMessage());
}
}
/**
* 使用 IVF_FLAT 索引类型时，必须在 extraParam 中提供 nlist 参数，该参数控制了向量空间划分的簇数量。
*/
private void createIndex() {
// 定义索引参数
CreateIndexParam indexParam = CreateIndexParam.newBuilder()
.withCollectionName(collectionName)
.withFieldName(FiledEnums.embedding.getCode())
.withIndexType(IndexType.valueOf(indexType))
.withMetricType(MetricType.valueOf(metricType))
.withExtraParam("{\"nlist\":" + embeddingDim + "}")
.build();
R<RpcStatus> res = milvusClient.createIndex(indexParam);
if (res.getStatus() == R.Status.Success.getCode()) {
log.info("Created index on collection: {} with type {}", collectionName, indexType);
// 加载集合到内存
LoadCollectionParam loadParam = LoadCollectionParam.newBuilder()
.withCollectionName(collectionName)
.build();
milvusClient.loadCollection(loadParam);
log.info("Loaded collection: {} into memory", collectionName);
} else {
log.error("Failed to create index: {}", res.getMessage());
}
}
/**
* 批量插入文档块
*/
public boolean batchInsertDocumentChunks(List<DocumentChunk> chunks) {
if (chunks.isEmpty()) return true;
try {
List<InsertParam.Field> fields = new ArrayList<>();
fields.add(new InsertParam.Field(FiledEnums.id.getCode(), chunks.stream().map(DocumentChunk::getId)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.documentId.getCode(), chunks.stream().map(DocumentChunk::getDocumentId)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.content.getCode(), chunks.stream().map(DocumentChunk::getContent)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.category.getCode(), chunks.stream().map(DocumentChunk::getCategory)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.title.getCode(), chunks.stream().map(DocumentChunk::getTitle)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.author.getCode(), chunks.stream().map(DocumentChunk::getAuthor)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.chunkIndex.getCode(), chunks.stream().map(DocumentChunk::getChunkIndex)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.totalChunks.getCode(), chunks.stream().map(DocumentChunk::getTotalChunks)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.embedding.getCode(), chunks.stream().map(DocumentChunk::getEmbedding)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.createdAt.getCode(), chunks.stream()
.map(chunk -> chunk.getCreatedAt() != null ? chunk.getCreatedAt().getTime() : System.currentTimeMillis())
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.updatedAt.getCode(), chunks.stream()
.map(chunk -> chunk.getUpdatedAt() != null ? chunk.getUpdatedAt().getTime() : System.currentTimeMillis())
.collect(Collectors.toList())));
// 2.6+版本才支持
/* fields.add(new InsertParam.Field(FiledEnums.createdAt.getCode(), chunks.stream().map(DocumentChunk::getCreatedAt)
.collect(Collectors.toList())));
fields.add(new InsertParam.Field(FiledEnums.updatedAt.getCode(), chunks.stream().map(DocumentChunk::getUpdatedAt)
.collect(Collectors.toList())));*/
InsertParam insertParam = InsertParam.newBuilder()
.withCollectionName(collectionName)
.withFields(fields)
.build();
R<MutationResult> res = milvusClient.insert(insertParam);
if (res.getStatus() == R.Status.Success.getCode()) {
log.info("Batch inserted {} chunks to Milvus", chunks.size());
return true;
} else {
log.error("Failed to batch insert to Milvus: {}", res.getMessage());
return false;
}
} catch (Exception e) {
log.error("Exception during Milvus batch insert", e);
return false;
}
}
/**
* 根据ID删除文档块
*/
public boolean deleteDocumentChunk(String id) {
try {
String expr = String.format("id == \"%s\"", id);
DeleteParam deleteParam = DeleteParam.newBuilder()
.withCollectionName(collectionName)
.withExpr(expr)
.build();
R<MutationResult> res = milvusClient.delete(deleteParam);
if (res.getStatus() == R.Status.Success.getCode()) {
log.debug("Document deleted from Milvus: {}", id);
return true;
} else {
log.error("Failed to delete from Milvus: {}", res.getMessage());
return false;
}
} catch (Exception e) {
log.error("Exception during Milvus delete", e);
return false;
}
}
/**
* 向量相似度搜索
*/
public List<DocumentChunk> searchByVector(List<Float> queryVector, int topK) {
try {
List<String> outputFields = Arrays.asList("id", "documentId", "content",
"title", "category", "chunkIndex");
SearchParam searchParam = SearchParam.newBuilder()
.withCollectionName(collectionName)
.withVectorFieldName(FiledEnums.embedding.getCode())
.withVectors(Arrays.asList(queryVector))
.withTopK(topK)
.withMetricType(MetricType.valueOf(metricType))
// nlist = 1024（索引时划分的簇数） nprobe = 10（搜索时检查的簇数） 比例 = 10/1024 ≈ 1%
// 只搜索约 1% 的向量空间 如果发现搜索结果不够准确，可以适当增加 nprobe：
.withParams("{\"nprobe\":10}")
/** 做权限过滤 .withExpr("")
* // 1. 等于
* "author == \"admin\""
* // 2. 不等于
* "author != \"guest\""
* // 3. 大于/小于（数值类型）
* "createdAt > 1700000000000"
* // 4. IN 操作
* "category in [\"tech\", \"science\"]"
* // 5. NOT IN
* "category not in [\"private\", \"confidential\"]"
* // 6. AND/OR 组合
* "(author == \"admin\" || category == \"public\") && createdAt > 1700000000000"
* // 7. LIKE 模糊匹配（VarChar 字段）
* "title like \"AI%\""
* // 8. 范围查询
* "createdAt >= 1700000000000 && createdAt <= 1710000000000"
*/
.withOutFields(outputFields)
.build();
R<SearchResults> res = milvusClient.search(searchParam);
if (res.getStatus() == R.Status.Success.getCode()) {
SearchResultsWrapper wrapper = new SearchResultsWrapper(res.getData().getResults());
List<DocumentChunk> results = new ArrayList<>();
for (QueryResultsWrapper.RowRecord record : wrapper.getRowRecords()) {
DocumentChunk chunk = DocumentChunk.builder()
.id((String)record.get("id"))
.documentId((String) record.get("documentId"))
.content((String) record.get("content"))
.title((String) record.get("title"))
.category((String) record.get("category"))
.chunkIndex((Integer) record.get("chunkIndex"))
.build();
results.add(chunk);
}
return results;
} else {
log.error("Failed to search in Milvus: {}", res.getMessage());
return new ArrayList<>();
}
} catch (Exception e) {
log.error("Exception during Milvus search", e);
return new ArrayList<>();
}
}
}es服务
java
package com.ai.rag.service;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.mapping.Property;
import co.elastic.clients.elasticsearch.core.*;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.elasticsearch.indices.CreateIndexRequest;
import co.elastic.clients.elasticsearch.indices.ExistsRequest;
import co.elastic.clients.elasticsearch.indices.IndexSettings;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import com.ai.rag.bean.DocumentChunk;
import com.ai.rag.constant.FiledEnums;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@Slf4j
@Service
public class ElasticsearchService {
@Value("${elasticsearch.host}")
private String esHost;
@Value("${elasticsearch.port}")
private int esPort;
@Value("${elasticsearch.scheme}")
private String esScheme;
@Value("${elasticsearch.username}")
private String esUsername;
@Value("${elasticsearch.password}")
private String esPassword;
@Value("${elasticsearch.index.name}")
private String indexName;
private ElasticsearchClient esClient;
@Value("${milvus.index.embedding-dimension}")
private Integer embeddingDim;
@PostConstruct
public void init() throws IOException {
RestClient restClient = buildRestClient();
ElasticsearchTransport transport = new RestClientTransport(
restClient, new JacksonJsonpMapper()
);
this.esClient = new ElasticsearchClient(transport);
// 创建索引（如果不存在）
createIndexIfNotExists();
}
private RestClient buildRestClient() {
CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
if (esUsername != null && !esUsername.isEmpty()) {
credentialsProvider.setCredentials(
AuthScope.ANY,
new UsernamePasswordCredentials(esUsername, esPassword)
);
}
return RestClient.builder(
new HttpHost(esHost, esPort, esScheme)
).setHttpClientConfigCallback(httpClientBuilder ->
httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider)
).build();
}
/**
* Mapping 理解为索引的"蓝图"或"表结构"，它定义了每个字段的数据类型、是否被索引、如何被分析等关键属性
* @throws IOException
*/
private void createIndexIfNotExists() throws IOException {
ExistsRequest existsRequest = ExistsRequest.of(e -> e.index(indexName));
boolean exists = esClient.indices().exists(existsRequest).value();
if (!exists) {
CreateIndexRequest createIndexRequest = CreateIndexRequest.of(i -> i
.index(indexName)
.settings(IndexSettings.of(s -> s
.numberOfShards("1")
.numberOfReplicas("1")
))
.mappings(m -> m
.properties(FiledEnums.id.getCode(), Property.of(p -> p.keyword(k -> k)))
.properties(FiledEnums.documentId.getCode(), Property.of(p -> p.keyword(k -> k)))
.properties(FiledEnums.content.getCode(), Property.of(p -> p.text(t -> t
.analyzer("ik_max_word") //最细粒度分词（索引时使用）
.searchAnalyzer("ik_smart") //智能分词（搜索时使用）
)))
.properties(FiledEnums.title.getCode(), Property.of(p -> p.text(t -> t
.analyzer("ik_max_word") //最细粒度分词（索引时使用）
.searchAnalyzer("ik_smart") //智能分词（搜索时使用）
)))
.properties(FiledEnums.author.getCode(), Property.of(p -> p.text(t -> t
.analyzer("ik_max_word") //最细粒度分词（索引时使用）
.searchAnalyzer("ik_smart") //智能分词（搜索时使用）
)))
.properties(FiledEnums.category.getCode(), Property.of(p -> p.text(t -> t)))
.properties(FiledEnums.embedding.getCode(), Property.of(p -> p.denseVector(t -> t.dims(embeddingDim))))
.properties(FiledEnums.chunkIndex.getCode(), Property.of(p -> p.integer(t -> t)))
.properties(FiledEnums.totalChunks.getCode(), Property.of(p -> p.integer(t -> t)))
.properties(FiledEnums.createdAt.getCode(), Property.of(p -> p.date(t -> t)))
.properties(FiledEnums.updatedAt.getCode(), Property.of(p -> p.date(t -> t)))
)
);
esClient.indices().create(createIndexRequest);
log.info("Created Elasticsearch index: {}", indexName);
}
}
/**
* 批量插入文档块
*/
public boolean batchInsertDocumentChunks(List<DocumentChunk> chunks) {
try {
var bulkRequest = BulkRequest.of(b -> {
b.index(indexName);
for (DocumentChunk chunk : chunks) {
b.operations(op -> op
.index(idx -> idx
.id(chunk.getId())
.document(chunk)
)
);
}
return b;
});
BulkResponse response = esClient.bulk(bulkRequest);
if (response.errors()) {
log.error("Bulk insert to ES had errors");
return false;
}
log.info("Batch inserted {} chunks to Elasticsearch", chunks.size());
return true;
} catch (IOException e) {
log.error("Failed to batch insert document chunks to Elasticsearch", e);
return false;
}
}
/**
* 全文搜索
*/
public List<DocumentChunk> search(String query, int limit) {
try {
SearchResponse<DocumentChunk> response = esClient.search(s -> s
.index(indexName)
.query(q -> q
.match(m -> m
.field("content")
.query(query)
)
)
.size(limit),
DocumentChunk.class
);
List<DocumentChunk> results = new ArrayList<>();
for (Hit<DocumentChunk> hit : response.hits().hits()) {
if (hit.source() != null) {
results.add(hit.source());
}
}
return results;
} catch (IOException e) {
log.error("Failed to search in Elasticsearch", e);
return new ArrayList<>();
}
}
}向量化服务
java
package com.ai.rag.service;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.ArrayList;
import java.util.List;
@Slf4j
@Service
public class OllamaEmbeddingService {
@Value("${spring.ai.ollama.base-url}")
private String ollamaBaseUrl;
@Value("${spring.ai.ollama.embedding.options.model}")
private String embeddingModel;
private final HttpClient httpClient;
private final ObjectMapper objectMapper;
public OllamaEmbeddingService() {
this.httpClient = HttpClient.newHttpClient();
this.objectMapper = new ObjectMapper();
}
/**
* 生成单个文本的 Embedding 向量
*/
public List<Float> generateEmbedding(String text) {
try {
String requestBody = String.format(
"{\"model\":\"%s\",\"input\":\"%s\"}",
embeddingModel,
escapeJson(text)
);
// log.info("Ollama embedding request: {}", requestBody);
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(ollamaBaseUrl + "/api/embed"))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(requestBody))
.build();
HttpResponse<String> response = httpClient.send(request,
HttpResponse.BodyHandlers.ofString());
// log.info("Ollama embedding response: {}", response.body());
if (response.statusCode() == 200) {
JsonNode jsonNode = objectMapper.readTree(response.body());
JsonNode embeddings = jsonNode.get("embeddings");
if (embeddings != null && embeddings.isArray() && embeddings.size() > 0) {
List<Float> embedding = new ArrayList<>();
for (JsonNode value : embeddings.get(0)) {
embedding.add(value.floatValue());
}
return embedding;
}
} else {
log.error("Ollama embedding failed with status: {}", response.statusCode());
}
} catch (IOException | InterruptedException e) {
log.error("Failed to generate embedding", e);
Thread.currentThread().interrupt();
}
return null;
}
/**
* 批量生成 Embedding 向量
*/
public List<List<Float>> generateEmbeddingsBatch(List<String> texts) {
List<List<Float>> embeddings = new ArrayList<>();
for (String text : texts) {
List<Float> embedding = generateEmbedding(text);
if (embedding != null) {
embeddings.add(embedding);
} else {
log.error("Failed to generate embedding for text: {}", text.substring(0,
Math.min(50, text.length())));
}
}
return embeddings;
}
private String escapeJson(String text) {
return text.replace("\\", "\\\\")
.replace("\"", "\\\"")
.replace("\n", "\\n")
.replace("\r", "\\r");
}
}数据双写
java
package com.ai.rag.service;
import com.ai.rag.bean.DocumentChunk;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
@Slf4j
@Service
public class DocumentChunkService {
private final ElasticsearchService elasticsearchService;
private final MilvusService milvusService;
private final OllamaEmbeddingService ollamaEmbeddingService;
private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
public DocumentChunkService(ElasticsearchService elasticsearchService,
MilvusService milvusService,
OllamaEmbeddingService ollamaEmbeddingService) {
this.elasticsearchService = elasticsearchService;
this.milvusService = milvusService;
this.ollamaEmbeddingService = ollamaEmbeddingService;
}
/**
* 批量文档块双写入库
*/
public boolean batchDualWriteDocumentChunks(List<DocumentChunk> chunks) {
if (chunks == null || chunks.isEmpty()) {
return true;
}
// Step 1: 批量生成 Embedding（优化性能）
List<String> texts = chunks.stream().map(DocumentChunk::getContent)
.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
List<List<Float>> embeddings = ollamaEmbeddingService.generateEmbeddingsBatch(texts);
if (embeddings.size() != chunks.size()) {
log.error("批量生成Embedding失败, expected {} but got {}", chunks.size(), embeddings.size());
return false;
}
for (int i = 0; i < chunks.size(); i++) {
chunks.get(i).setEmbedding(embeddings.get(i));
}
// Step 2: 批量写入 Elasticsearch
boolean esSuccess = elasticsearchService.batchInsertDocumentChunks(chunks);
if (!esSuccess) {
log.error("写入es失败 需完善补偿机制");
// TODO
return false;
}
// Step 3: 批量写入 Milvus
boolean milvusSuccess = milvusService.batchInsertDocumentChunks(chunks);
if (!milvusSuccess) {
log.error("写入milvus失败 需完善补偿机制");
// TODO
return false;
}
return true;
}
}查询服务
java
package com.ai.rag.service;
import com.ai.rag.bean.DocumentChunk;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.*;
@Slf4j
@Service
public class RagQueryService {
private final ElasticsearchService elasticsearchService;
private final MilvusService milvusService;
private final OllamaEmbeddingService ollamaEmbeddingService;
@Value("${spring.ai.ollama.base-url}")
private String ollamaBaseUrl;
@Value("${spring.ai.ollama.chat.options.model}")
private String chatModel;
@Value("${spring.ai.ollama.chat.options.temperature}")
private String temperature;
@Value("${search.top}")
private Integer searchTop;
private final HttpClient httpClient;
// 请在 RagQueryService 中添加以下方法
public List<DocumentChunk> getSearchResults(String query, int limit) {
return elasticsearchService.search(query, limit);
}
public RagQueryService(ElasticsearchService elasticsearchService,
MilvusService milvusService,
OllamaEmbeddingService ollamaEmbeddingService) {
this.elasticsearchService = elasticsearchService;
this.milvusService = milvusService;
this.ollamaEmbeddingService = ollamaEmbeddingService;
this.httpClient = HttpClient.newHttpClient();
}
/**
* 混合检索：向量检索 + 全文检索，并进行结果融合
*/
public List<DocumentChunk> hybridSearch(String query, int topK) {
// Step 1: 向量检索 - 将查询转为向量后检索
List<Float> queryVector = ollamaEmbeddingService.generateEmbedding(query);
log.info("hybridSearch-将查询转为向量:{}", JSONObject.toJSONString(queryVector));
// log.info("hybridSearch-将查询转为向量后检索:{}", JSONObject.toJSONString(queryVector));
List<DocumentChunk> vectorResults = new ArrayList<>();
if (queryVector != null) {
log.info("hybridSearch-从向量库检索开始......");
vectorResults = milvusService.searchByVector(queryVector, topK);
log.info("hybridSearch-从向量库检索返回 {} 条", vectorResults.size());
}
// Step 2: 全文检索
log.info("hybridSearch-从es检索开始......");
List<DocumentChunk> textResults = elasticsearchService.search(query, topK);
log.info("hybridSearch-从es检索返回 {} 条", textResults.size());
// Step 3: 结果融合（RRF 算法去重融合）
return fusionResults(vectorResults, textResults, topK);
}
/**
* 基于 RRF（Reciprocal Rank Fusion）的结果融合
*/
private List<DocumentChunk> fusionResults(List<DocumentChunk> vectorResults,
List<DocumentChunk> textResults, int topK) {
Map<String, Double> scoreMap = new HashMap<>();
Map<String, DocumentChunk> chunkMap = new HashMap<>();
// 计算向量检索的 RRF 分数
for (int i = 0; i < vectorResults.size(); i++) {
DocumentChunk chunk = vectorResults.get(i);
String id = chunk.getId();
double rrfScore = 1.0 / (i + 60); // RRF with k=60
scoreMap.put(id, scoreMap.getOrDefault(id, 0.0) + rrfScore);
chunkMap.putIfAbsent(id, chunk);
}
// 计算文本检索的 RRF 分数
for (int i = 0; i < textResults.size(); i++) {
DocumentChunk chunk = textResults.get(i);
String id = chunk.getId();
double rrfScore = 1.0 / (i + 60);
scoreMap.put(id, scoreMap.getOrDefault(id, 0.0) + rrfScore);
chunkMap.putIfAbsent(id, chunk);
}
// 按 RRF 分数排序并取 topK
List<Map.Entry<String, Double>> sorted = new ArrayList<>(scoreMap.entrySet());
sorted.sort((a, b) -> b.getValue().compareTo(a.getValue()));
List<DocumentChunk> results = new ArrayList<>();
for (int i = 0; i < Math.min(topK, sorted.size()); i++) {
results.add(chunkMap.get(sorted.get(i).getKey()));
}
//log.info("fusionResults-结果融合结果 {}", JSONObject.toJSONString(results));
log.info("hybridSearch-RRF计计算后返回总条数: {}", results.size());
return results;
}
/**
* 完整的 RAG 问答
*/
public String askQuestion(String question) {
// Step 1: 混合检索获取相关文档块
List<DocumentChunk> relevantChunks = hybridSearch(question, searchTop);
if (relevantChunks.isEmpty()) {
return generateFallbackAnswer(question);
}
// Step 2: 构建 Prompt
String context = buildContextFromChunks(relevantChunks);
String prompt = buildPrompt(question, context);
// Step 3: 调用 Ollama 生成回答
return generateAnswer(prompt);
}
private String buildContextFromChunks(List<DocumentChunk> chunks) {
StringBuilder sb = new StringBuilder();
int rank = 1;
for (DocumentChunk chunk : chunks) {
sb.append("【参考文档").append(rank++).append("】\n");
sb.append(chunk.getContent()).append("\n\n");
}
return sb.toString();
}
private String buildPrompt(String question, String context) {
return String.format(
"你是一个专业的智能问答助手。请基于以下提供的参考资料内容，回答用户的问题。\n\n" +
"注意事项：\n" +
"1. 仅使用参考资料中的信息进行回答，不要编造或添加参考资料中不包含的内容\n" +
"2. 如果参考资料中不包含相关信息，请直接告知用户\"根据现有资料无法回答此问题\"\n" +
"3. 回答应当准确、简洁、有条理\n" +
"4. 确保回答与用户的问题相关\n\n" +
"=== 参考资料 ===\n%s\n" +
"=== 用户问题 ===\n%s\n\n" +
"=== 回答 ===\n",
context, question
);
}
private String generateAnswer(String prompt) {
try {
String requestBody = String.format(
"{\"model\":\"%s\",\"prompt\":\"%s\",\"stream\":false,\"temperature\":"+temperature+"}",
chatModel, escapeJson(prompt)
);
log.info("请求大模型开始:{}");
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(ollamaBaseUrl + "/api/generate"))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(requestBody))
.build();
HttpResponse<String> response = httpClient.send(request,
HttpResponse.BodyHandlers.ofString());
log.info("请求大模型响应: {}", response.body());
if (response.statusCode() == 200) {
JSONObject jsonResponse = JSONObject.parseObject(response.body());
String responseBody = jsonResponse.getString("response");
log.info("请求大模型检索结果:{}", responseBody);
return responseBody;
} else {
log.error("请求大模型失败: {}", response.statusCode());
return "对不起，生成回答时出现了错误。";
}
} catch (IOException | InterruptedException e) {
log.error("请求大模型异常", e);
Thread.currentThread().interrupt();
return "对不起，生成回答时出现了错误。";
}
}
private String generateFallbackAnswer(String question) {
String prompt = String.format(
"用户提出了问题：\"%s\"\n" +
"但当前知识库中未检索到相关的资料。请友好地告知用户当前无法回答该问题，" +
"并建议用户提供更多信息或尝试其他问题。\n\n" +
"请以自然、有帮助的态度进行回复。",
question
);
return generateAnswer(prompt);
}
private String escapeJson(String text) {
return text.replace("\\", "\\\\")
.replace("\"", "\\\"")
.replace("\n", "\\n")
.replace("\r", "\\r");
}
}