Spring AI与RAG技术实战：构建企业级智能文档问答系统

原创于 2025-08-31 10:02:38 发布 · 439 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#Spring AI #RAG #Java #智能问答 #向量数据库 #Milvus #Spring Boot

Java 专栏收录该内容

873 篇文章

订阅专栏

Spring AI与RAG技术实战：构建企业级智能文档问答系统

引言

随着人工智能技术的快速发展，企业对于智能化文档处理的需求日益增长。传统的文档检索方式往往无法满足用户对精准、智能问答的需求。Spring AI结合RAG（Retrieval-Augmented Generation）技术，为企业提供了一种全新的智能文档问答解决方案。本文将深入探讨如何利用Spring AI框架和RAG技术构建高效的企业级智能文档问答系统。

技术架构概述

核心组件

我们的智能文档问答系统基于以下核心技术栈：

Spring AI: 提供统一的AI应用开发接口
RAG架构: 检索增强生成，结合语义搜索和LLM生成能力
向量数据库: 使用Milvus存储文档向量
Embedding模型: OpenAI或Ollama提供的文本向量化服务
Spring Boot: 作为基础Web框架

系统架构设计

客户端 → Spring Boot应用 → RAG引擎 → 向量数据库
                         ↓
                      LLM服务

环境准备与依赖配置

Maven依赖配置

首先，在pom.xml中添加必要的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        <version>0.8.1</version>
    </dependency>
    
    <dependency>
        <groupId>io.milvus</groupId>
        <artifactId>milvus-sdk-java</artifactId>
        <version>2.3.4</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
</dependencies>

应用配置

在application.yml中配置相关参数：

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      base-url: https://api.openai.com
  
  data:
    redis:
      host: localhost
      port: 6379

milvus:
  host: localhost
  port: 19530

核心功能实现

1. 文档预处理与向量化

文档预处理是RAG系统的第一步，我们需要将文档转换为向量表示：

@Service
public class DocumentProcessor {
    
    @Autowired
    private EmbeddingClient embeddingClient;
    
    @Autowired
    private MilvusService milvusService;
    
    public void processDocument(String documentId, String content) {
        // 文本分块处理
        List<String> chunks = splitTextIntoChunks(content);
        
        // 生成向量
        List<List<Double>> embeddings = generateEmbeddings(chunks);
        
        // 存储到向量数据库
        storeEmbeddings(documentId, chunks, embeddings);
    }
    
    private List<String> splitTextIntoChunks(String text) {
        // 实现文本分块逻辑
        return Arrays.asList(text.split("\\n\\n"));
    }
    
    private List<List<Double>> generateEmbeddings(List<String> chunks) {
        return embeddingClient.embed(chunks);
    }
    
    private void storeEmbeddings(String documentId, 
                                List<String> chunks, 
                                List<List<Double>> embeddings) {
        milvusService.storeVectors(documentId, chunks, embeddings);
    }
}

2. 语义检索实现

基于向量相似度的语义检索是RAG的核心：

@Service
public class SemanticSearchService {
    
    @Autowired
    private EmbeddingClient embeddingClient;
    
    @Autowired
    private MilvusService milvusService;
    
    public List<SearchResult> searchRelevantDocuments(String query, int topK) {
        // 将查询转换为向量
        List<Double> queryVector = embeddingClient.embed(query);
        
        // 在向量数据库中搜索相似文档
        return milvusService.searchSimilarVectors(queryVector, topK);
    }
}

@Data
@AllArgsConstructor
class SearchResult {
    private String documentId;
    private String chunkText;
    private double similarityScore;
}

3. RAG问答引擎

结合检索结果和LLM生成回答：

@Service
public class RAGQuestionAnsweringService {
    
    @Autowired
    private SemanticSearchService searchService;
    
    @Autowired
    private ChatClient chatClient;
    
    public String answerQuestion(String question) {
        // 检索相关文档片段
        List<SearchResult> relevantDocs = searchService
            .searchRelevantDocuments(question, 5);
        
        // 构建提示词
        String prompt = buildPrompt(question, relevantDocs);
        
        // 调用LLM生成回答
        return chatClient.generate(prompt);
    }
    
    private String buildPrompt(String question, List<SearchResult> relevantDocs) {
        StringBuilder promptBuilder = new StringBuilder();
        promptBuilder.append("基于以下文档内容，请回答这个问题：")
                    .append(question)
                    .append("\n\n相关文档内容：\n");
        
        for (SearchResult result : relevantDocs) {
            promptBuilder.append(result.getChunkText())
                        .append("\n---\n");
        }
        
        promptBuilder.append("\n请基于以上信息给出准确的回答。");
        
        return promptBuilder.toString();
    }
}

4. Milvus向量数据库集成

@Service
public class MilvusService {
    
    private final MilvusClient milvusClient;
    
    public MilvusService(@Value("${milvus.host}") String host, 
                        @Value("${milvus.port}") int port) {
        this.milvusClient = new MilvusServiceClient(
            ConnectParam.newBuilder()
                .withHost(host)
                .withPort(port)
                .build()
        );
    }
    
    public void storeVectors(String documentId, 
                           List<String> chunks, 
                           List<List<Double>> embeddings) {
        // 实现向量存储逻辑
        List<InsertParam.Field> fields = new ArrayList<>();
        fields.add(new InsertParam.Field("document_id", 
            Collections.nCopies(chunks.size(), documentId)));
        fields.add(new InsertParam.Field("chunk_text", chunks));
        fields.add(new InsertParam.Field("embedding", embeddings));
        
        InsertParam insertParam = InsertParam.newBuilder()
            .withCollectionName("documents")
            .withFields(fields)
            .build();
        
        milvusClient.insert(insertParam);
    }
    
    public List<SearchResult> searchSimilarVectors(List<Double> queryVector, int topK) {
        // 实现向量搜索逻辑
        SearchParam searchParam = SearchParam.newBuilder()
            .withCollectionName("documents")
            .withMetricType(MetricType.L2)
            .withTopK(topK)
            .withVectors(Collections.singletonList(queryVector))
            .withParams("{\"nprobe\":10}")
            .build();
        
        SearchResults searchResults = milvusClient.search(searchParam);
        return processSearchResults(searchResults);
    }
}

REST API设计

问答接口

@RestController
@RequestMapping("/api/rag")
public class RAGController {
    
    @Autowired
    private RAGQuestionAnsweringService qaService;
    
    @PostMapping("/ask")
    public ResponseEntity<AnswerResponse> askQuestion(@RequestBody QuestionRequest request) {
        try {
            String answer = qaService.answerQuestion(request.getQuestion());
            return ResponseEntity.ok(new AnswerResponse(answer));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new AnswerResponse("系统繁忙，请稍后重试"));
        }
    }
    
    @Data
    public static class QuestionRequest {
        private String question;
    }
    
    @Data
    @AllArgsConstructor
    public static class AnswerResponse {
        private String answer;
    }
}

文档管理接口

@RestController
@RequestMapping("/api/documents")
public class DocumentController {
    
    @Autowired
    private DocumentProcessor documentProcessor;
    
    @PostMapping("/upload")
    public ResponseEntity<String> uploadDocument(@RequestBody DocumentUploadRequest request) {
        try {
            documentProcessor.processDocument(
                request.getDocumentId(), 
                request.getContent()
            );
            return ResponseEntity.ok("文档处理成功");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("文档处理失败：" + e.getMessage());
        }
    }
    
    @Data
    public static class DocumentUploadRequest {
        private String documentId;
        private String content;
    }
}

性能优化策略

1. 缓存机制

使用Redis缓存频繁访问的查询结果：

@Service
public class CachedRAGService {
    
    @Autowired
    private RAGQuestionAnsweringService ragService;
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    private static final String CACHE_PREFIX = "rag_answer:";
    
    @Cacheable(value = "ragAnswers", key = "#question")
    public String getCachedAnswer(String question) {
        String cacheKey = CACHE_PREFIX + DigestUtils.md5DigestAsHex(question.getBytes());
        
        // 先尝试从缓存获取
        String cachedAnswer = redisTemplate.opsForValue().get(cacheKey);
        if (cachedAnswer != null) {
            return cachedAnswer;
        }
        
        // 缓存未命中，调用RAG服务
        String answer = ragService.answerQuestion(question);
        
        // 缓存结果，设置1小时过期
        redisTemplate.opsForValue().set(cacheKey, answer, 1, TimeUnit.HOURS);
        
        return answer;
    }
}

2. 批量处理优化

对于大量文档处理，采用批量操作：

public void batchProcessDocuments(List<Document> documents) {
    int batchSize = 100;
    List<List<Document>> batches = partition(documents, batchSize);
    
    batches.parallelStream().forEach(batch -> {
        batch.forEach(doc -> documentProcessor.processDocument(
            doc.getId(), doc.getContent()));
    });
}

错误处理与监控

全局异常处理

@ControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGlobalException(Exception ex) {
        ErrorResponse error = new ErrorResponse(
            "系统错误", 
            ex.getMessage(), 
            System.currentTimeMillis()
        );
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(error);
    }
    
    @Data
    @AllArgsConstructor
    public static class ErrorResponse {
        private String error;
        private String message;
        private long timestamp;
    }
}

监控指标

集成Micrometer进行性能监控：

@Component
public class RAGMetrics {
    
    private final MeterRegistry meterRegistry;
    private final Counter questionCounter;
    private final Timer responseTimer;
    
    public RAGMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.questionCounter = meterRegistry.counter("rag.questions.total");
        this.responseTimer = meterRegistry.timer("rag.response.time");
    }
    
    public void recordQuestion() {
        questionCounter.increment();
    }
    
    public Timer.Sample startTiming() {
        return Timer.start(meterRegistry);
    }
    
    public void stopTiming(Timer.Sample sample, String status) {
        sample.stop(responseTimer.tag("status", status));
    }
}

部署与运维

Docker容器化部署

FROM openjdk:17-jdk-slim

WORKDIR /app

COPY target/rag-system.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

Kubernetes部署配置

apiVersion: apps/v1
kind: Deployment
metadata:
  name: rag-system
spec:
  replicas: 3
  selector:
    matchLabels:
      app: rag-system
  template:
    metadata:
      labels:
        app: rag-system
    spec:
      containers:
      - name: rag-app
        image: rag-system:latest
        ports:
        - containerPort: 8080
        env:
        - name: OPENAI_API_KEY
          valueFrom:
            secretKeyRef:
              name: openai-secret
              key: api-key
---
apiVersion: v1
kind: Service
metadata:
  name: rag-service
spec:
  selector:
    app: rag-system
  ports:
  - port: 80
    targetPort: 8080