Spring AI应用：利用DeepSeek+嵌入模型+Milvus向量数据库实现检索增强生成--RAG应用（超详细）

helloworld_工程师2025-04-10 10:56

Spring AI应用：利用DeepSeek+嵌入模型+Milvus向量数据库实现检索增强生成--RAG应用（超详细）

在当今数字化时代，人工智能（AI）技术的快速发展为各行业带来了前所未有的机遇。其中，检索增强生成（RAG）技术作为一种结合了检索和生成的混合模型，已经在自然语言处理领域取得了显著的成果。本文将详细介绍如何利用Spring AI框架、DeepSeek大模型、嵌入模型以及Milvus向量数据库实现一个高效的RAG应用。通过这一实践，读者将能够构建一个能够处理复杂查询并生成高质量答案的智能系统。

一、技术背景与应用场景

（一）检索增强生成（RAG）技术

检索增强生成（Retrieval-Augmented Generation，RAG）是一种结合了检索（Retrieval）和生成（Generation）的混合模型。它通过检索模块从大规模文档集合中提取与查询相关的文档片段，然后将这些片段作为上下文信息输入到生成模块中，从而生成更准确、更相关的答案。RAG技术在问答系统、文档摘要、内容推荐等领域具有广泛的应用前景。

（二）技术选型

  1. Spring AI框架：Spring AI是Spring框架的扩展，专门用于构建AI驱动的应用程序。它提供了与各种AI模型的无缝集成，简化了开发流程。
  2. DeepSeek大模型：DeepSeek是一个强大的预训练语言模型，能够处理复杂的自然语言任务。通过Spring AI框架，可以轻松调用DeepSeek模型。
  3. Milvus向量数据库：Milvus是一个开源的向量数据库，专门用于存储和检索高维向量数据。它支持多种索引类型，能够高效地处理大规模数据。
  4. 嵌入模型：嵌入模型用于将文本转换为向量表示，以便存储到Milvus数据库中。常用的嵌入模型包括BERT、Sentence-BERT等。

二、系统架构设计

（一）整体架构

整个RAG应用的架构可以分为以下几个主要部分：

  1. 前端界面：用户通过前端界面输入查询问题，并接收系统生成的答案。
  2. 后端服务：后端服务负责处理用户的查询请求，调用RAG模型生成答案，并将结果返回给前端。
  3. Milvus向量数据库：存储文档的向量表示，用于检索与查询相关的文档片段。
  4. DeepSeek大模型：生成最终的答案。

（二）工作流程

  1. 用户通过前端界面输入查询问题。
  2. 后端服务将查询问题发送到Milvus数据库，检索与问题相关的文档片段。
  3. 将检索到的文档片段作为上下文信息输入到DeepSeek模型中。
  4. DeepSeek模型根据上下文生成最终的答案。
  5. 后端服务将生成的答案返回给前端界面显示给用户。

三、环境准备与依赖安装

（一）环境准备

  1. Java开发环境：安装JDK 1.8或更高版本。
  2. Spring Boot：创建一个Spring Boot项目，用于构建后端服务。
  3. Milvus数据库：安装并启动Milvus服务。
  4. DeepSeek模型：确保DeepSeek模型可用，可以通过API调用。

（二）依赖安装

在pom.xml文件中添加以下依赖：

xml 复制代码 
<dependencies>
    <!-- Spring AI -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai</artifactId>
        <version>1.0.0</version>
    </dependency>
    <!-- Milvus Java SDK -->
    <dependency>
        <groupId>io.milvus</groupId>
        <artifactId>milvus-sdk-java</artifactId>
        <version>2.0.0</version>
    </dependency>
    <!-- DeepSeek Java SDK -->
    <dependency>
        <groupId>org.springframework.ai.deepseek</groupId>
        <artifactId>deepseek-java-sdk</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

四、Milvus向量数据库的搭建与数据准备

（一）连接Milvus数据库

在Spring Boot项目中，创建一个配置类来连接Milvus数据库：

java 复制代码 
import io.milvus.client.*;

@Configuration
public class MilvusConfig {
    @Bean
    public MilvusClient milvusClient() {
        ConnectParam connectParam = new ConnectParam.Builder().withHost("localhost").withPort(19530).build();
        MilvusClient client = new MilvusGrpcClient.Builder().build();
        Response res = client.connect(connectParam);
        if (res.ok()) {
            System.out.println("Connected to Milvus server successfully.");
        } else {
            System.out.println("Failed to connect to Milvus server.");
        }
        return client;
    }
}

（二）创建集合与索引

在Milvus中创建一个集合用于存储文档的向量表示，并创建索引以加速检索：

java 复制代码 
import io.milvus.client.*;

@Service
public class MilvusService {
    @Autowired
    private MilvusClient milvusClient;

    public void createCollection(String collectionName) {
        CollectionSchema collectionSchema = new CollectionSchema.Builder()
                .withCollectionName(collectionName)
                .withDescription("Collection for RAG application")
                .addField(
                        new FieldSchema.Builder()
                                .withName("id")
                                .withDataType(DataType.INT64)
                                .withIsPrimaryKey(true)
                                .withAutoID(true)
                                .build()
                )
                .addField(
                        new FieldSchema.Builder()
                                .withName("vector")
                                .withDataType(DataType.FLOAT_VECTOR)
                                .withDimension(768) // Assuming BERT embeddings
                                .build()
                )
                .build();

        Response res = milvusClient.createCollection(collectionSchema);
        if (res.ok()) {
            System.out.println("Collection created successfully.");
        } else {
            System.out.println("Failed to create collection.");
        }
    }

    public void createIndex(String collectionName) {
        IndexParam indexParam = new IndexParam.Builder()
                .withCollectionName(collectionName)
                .withFieldName("vector")
                .withIndexType(IndexType.IVF_FLAT)
                .withMetricType(MetricType.L2)
                .withParams(new IndexParam.IndexParams.Builder()
                        .withNlist(128)
                        .build())
                .build();

        Response res = milvusClient.createIndex(indexParam);
        if (res.ok()) {
            System.out.println("Index created successfully.");
        } else {
            System.out.println("Failed to create index.");
        }
    }
}

（三）数据插入

将文档数据插入Milvus数据库中。假设我们已经使用嵌入模型将文档转换为向量表示：

java 复制代码 
@Service
public class MilvusService {
    @Autowired
    private MilvusClient milvusClient;

    public void insertData(String collectionName, List<float[]> vectors) {
        List<Long> ids = new ArrayList<>();
        List<List<Float>> vectorList = new ArrayList<>();

        for (float[] vector : vectors) {
            ids.add(null); // Auto-generated ID
            vectorList.add(Arrays.stream(vector).boxed().collect(Collectors.toList()));
        }

        InsertParam insertParam = new InsertParam.Builder()
                .withCollectionName(collectionName)
                .withFields(
                        new FieldParam.Builder()
                                .withName("vector")
                                .withValues(vectorList)
                                .build()
                )
                .build();

        Response res = milvusClient.insert(insertParam);
        if (res.ok()) {
            System.out.println("Data inserted successfully.");
        } else {
            System.out.println("Failed to insert data.");
        }
    }
}

五、DeepSeek大模型的集成与调用

（一）配置DeepSeek客户端

在Spring Boot项目中，创建一个配置类来配置DeepSeek客户端：

java 复制代码 
import org.springframework.ai.client.AiClient;
import org.springframework.ai.client.DefaultAiClient;
import org.springframework.ai.deepseek.client.DeepSeekAiClient;
import org.springframework.ai.deepseek.client.DeepSeekAiClientConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DeepSeekConfig {
    @Bean
    public AiClient deepSeekAiClient() {
        String apiKey = "your-deepseek-api-key"; // Replace with your actual API key
        DeepSeekAiClientConfig config = new DeepSeekAiClientConfig(apiKey);
        return new DeepSeekAiClient(config);
    }
}

（二）调用DeepSeek模型

创建一个服务类来封装与DeepSeek模型的交互逻辑：

java 复制代码 
import org.springframework.ai.client.AiClient;
import org.springframework.ai.client.AiResponse;
import org.springframework.ai.prompt.Prompt;
import org.springframework.ai.prompt.messages.UserMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public
 class DeepSeekService {
    @Autowired
    private AiClient deepSeekAiClient;

    public String generateAnswer(String query, List<String> context) {
        Prompt prompt = new Prompt.Builder()
                .withMessage(new UserMessage(query))
                .withContext(context)
                .build();

        AiResponse response = deepSeekAiClient.generate(prompt);
        return response.getGeneratedText();
    }
}

六、实现RAG检索增强生成逻辑

（一）检索模块

创建一个服务类来实现从Milvus数据库中检索相关文档片段的逻辑：

java 复制代码 
import io.milvus.client.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class RetrievalService {
    @Autowired
    private MilvusClient milvusClient;

    public List<String> retrieveDocuments(String collectionName, float[] queryVector, int topK) {
        List<Long> ids = new ArrayList<>();
        List<List<Float>> vectorList = new ArrayList<>();
        vectorList.add(Arrays.stream(queryVector).boxed().collect(Collectors.toList()));

        SearchParam searchParam = new SearchParam.Builder()
                .withCollectionName(collectionName)
                .withDsl(
                        new SearchParam.Dsl()
                                .withMetricType(MetricType.L2)
                                .withParams(new SearchParam.Dsl.Params.Builder()
                                        .withTopK(topK)
                                        .build())
                                .withVectors(vectorList)
                                .build()
                )
                .build();

        Response res = milvusClient.search(searchParam);
        if (res.ok()) {
            List<List<Float>> resultVectors = res.getVectorIdsList().get(0);
            List<String> retrievedDocuments = new ArrayList<>();
            for (List<Float> vector : resultVectors) {
                // Convert vector back to document (assuming you have a mapping)
                retrievedDocuments.add("Document corresponding to vector");
            }
            return retrievedDocuments;
        } else {
            throw new RuntimeException("Failed to retrieve documents.");
        }
    }
}

（二）生成模块

将检索到的文档片段作为上下文信息输入到DeepSeek模型中，生成最终的答案：

java 复制代码 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class RAGService {
    @Autowired
    private RetrievalService retrievalService;
    @Autowired
    private DeepSeekService deepSeekService;

    public String generateAnswer(String query, String collectionName, int topK) {
        // Convert query to vector using an embedding model (e.g., BERT)
        float[] queryVector = convertQueryToVector(query);

        // Retrieve relevant documents from Milvus
        List<String> retrievedDocuments = retrievalService.retrieveDocuments(collectionName, queryVector, topK);

        // Generate answer using DeepSeek model
        String answer = deepSeekService.generateAnswer(query, retrievedDocuments);
        return answer;
    }

    private float[] convertQueryToVector(String query) {
        // Implement your embedding model logic here
        // For example, using BERT to convert query to vector
        return new float[]{0.1f, 0.2f, 0.3f}; // Placeholder vector
    }
}

七、构建前端界面与后端接口

（一）前端界面

使用HTML和JavaScript构建一个简单的前端界面，用户可以在其中输入查询问题并查看生成的答案：

html 复制代码 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>RAG Application</title>
</head>
<body>
    <h1>RAG Application</h1>
    <form id="queryForm">
        <label for="query">Enter your query:</label>
        <input type="text" id="query" name="query" required>
        <button type="submit">Submit</button>
    </form>
    <div id="answer"></div>

    <script>
        document.getElementById('queryForm').addEventListener('submit', function(event) {
            event.preventDefault();
            const query = document.getElementById('query').value;
            fetch('/generate-answer', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ query })
            })
            .then(response => response.json())
            .then(data => {
                document.getElementById('answer').innerText = data.answer;
            });
        });
    </script>
</body>
</html>

（二）后端接口

在Spring Boot项目中，创建一个控制器类来处理前端的查询请求：

java 复制代码 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class RAGController {
    @Autowired
    private RAGService ragService;

    @PostMapping("/generate-answer")
    public Map<String, String> generateAnswer(@RequestBody Map<String, String> request) {
        String query = request.get("query");
        String answer = ragService.generateAnswer(query, "your_collection_name", 5); // Adjust collection name and topK as needed
        return Map.of("answer", answer);
    }
}

八、系统测试与优化

（一）测试

对整个系统进行测试，确保各个模块能够正常工作。测试内容包括：

  1. Milvus数据库连接：确保能够成功连接到Milvus数据库，并创建集合与索引。
  2. 数据插入与检索：插入测试数据，并验证检索结果的准确性。
  3. DeepSeek模型调用：确保能够成功调用DeepSeek模型，并生成合理的答案。
  4. 前端与后端交互：通过前端界面输入查询问题，验证系统能够返回正确的答案。

（二）优化

根据测试结果，对系统进行优化。优化方向包括：

  1. 性能优化：优化Milvus索引参数，提高检索效率。
  2. 模型优化：根据生成结果的质量，调整DeepSeek模型的参数或选择更适合的模型。
  3. 用户体验优化：优化前端界面，提升用户交互体验。

九、总结与展望

本文详细介绍了如何利用Spring AI框架、DeepSeek大模型、嵌入模型和Milvus向量数据库实现一个检索增强生成（RAG）应用。通过这一实践，我们构建了一个能够处理复杂查询并生成高质量答案的智能系统。未来，我们可以进一步探索以下方向：

  1. 多模态数据支持：将RAG技术扩展到多模态数据（如图像、视频等）的处理。
  2. 实时数据更新：实现对Milvus数据库的实时更新，以支持动态数据的检索。
  3. 跨语言支持：探索跨语言的RAG应用，支持多种语言的查询和生成。

通过不断探索和优化，RAG技术将在更多领域发挥重要作用，为用户提供更加智能和便捷的服务。

相关推荐
坐吃山猪2 小时前
SpringBoot01-配置文件
java·开发语言
我叫汪枫2 小时前
《Java餐厅的待客之道：BIO, NIO, AIO三种服务模式的进化》
java·开发语言·nio
yaoxtao2 小时前
java.nio.file.InvalidPathException异常
java·linux·ubuntu
M1A13 小时前
小红书重磅升级！公众号文章一键导入，深度内容轻松入驻
后端
Swift社区4 小时前
从 JDK 1.8 切换到 JDK 21 时遇到 NoProviderFoundException 该如何解决？
java·开发语言
0wioiw04 小时前
Go基础（④指针）
开发语言·后端·golang
DKPT5 小时前
JVM中如何调优新生代和老生代？
java·jvm·笔记·学习·spring
phltxy5 小时前
JVM——Java虚拟机学习
java·jvm·学习
李姆斯6 小时前
复盘上瘾症：到底什么时候该“复盘”，什么时候不需要“复盘”
前端·后端·团队管理
热门推荐
012025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！022025年数学建模国赛C题超详细解题思路032025全国大学生数学建模C题保姆级思路模型（持续更新）：NIPT 的时点选择与胎儿的异常判定042025高教社杯国赛数学建模选题建议+初步分析052025国赛B题保姆级教程思路分析 碳化硅外延层厚度的确定06不再让Windows更新！&Edge游戏助手卸载及关闭自动更新07KGG转MP3工具|非KGM文件|解密音频08UV安装并设置国内源09奈飞工厂官网，国内Netflix影视在线看|中文网页电脑版入口10（E题｜AI 辅助智能体测）2025年高教杯全国大学生数学建模国赛解题思路|完整代码论文集合