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技术将在更多领域发挥重要作用，为用户提供更加智能和便捷的服务。

相关推荐
一只叫煤球的猫3 小时前
写代码很6，面试秒变菜鸟？不卖课，面试官视角走心探讨
前端·后端·面试
bobz9654 小时前
tcp/ip 中的多路复用
后端
bobz9654 小时前
tls ingress 简单记录
后端
皮皮林5515 小时前
IDEA 源码阅读利器，你居然还不会？
java·intellij idea
你的人类朋友5 小时前
什么是OpenSSL
后端·安全·程序员
bobz9655 小时前
mcp 直接操作浏览器
后端
前端小张同学8 小时前
服务器部署 gitlab 占用空间太大怎么办，优化思路。
后端
databook8 小时前
Manim实现闪光轨迹特效
后端·python·动效
武子康8 小时前
大数据-98 Spark 从 DStream 到 Structured Streaming：Spark 实时计算的演进
大数据·后端·spark
该用户已不存在9 小时前
6个值得收藏的.NET ORM 框架
前端·后端·.net
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南0346个Nano-banana 精选提示词，持续更新中04Claude Code 平替：OpenAI发布 Codex CLI ，GPT-5 国内直接使用05UV安装并设置国内源06保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）07A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程08Spec-Kit 使用指南09解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题10KGG转MP3工具|非KGM文件|解密音频