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 分钟前
ocr-不动产权识别
java·linux·ocr
supermfc5 分钟前
CentOS7部署DeepSeek
后端·deepseek
lcf_zhangxing7 分钟前
odoo中为动态模型添加记录规则
后端
喵手12 分钟前
Java 反射：动态代理，你真了解它吗？
java·后端·java ee
jackson凌12 分钟前
【Java学习笔记】Java第一课，梦开始的地方！！!
java·笔记
倚栏听风雨14 分钟前
IDEA插件 - 静态代码语法检查
java
雷渊15 分钟前
在RocketMQ中，既然普通消息类型可以通过key来路由到指定队列中实现顺序消息，为什么还需要顺序消息这个类型呢？
java·后端·面试
南雨北斗21 分钟前
11.Laravel 9.0 目录功能详解
后端
程序员小假22 分钟前
如何使用Java开发在线生成 pdf 文档 ？
java·后端
江城月下36 分钟前
SOLID原则详解：提升软件设计质量的关键
java·spring·mybatis·软件工程·设计原则·设计规范
热门推荐
01我决定放弃搞 Java 了02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04汽车上的各种质量：整备质量、总质量、装载质量、簧上质量、簧下质量05DeepSeek RAGFlow构建本地知识库系统06如何在WPS和Word/Excel中直接使用DeepSeek功能07游戏引擎学习第217天08从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程10【上海大学计算机组成原理实验报告】七、程序转移机制