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

原创于 2025-09-04 12:02:18 发布 · 393 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#Spring AI #RAG #企业级应用 #智能问答 #Java #向量数据库 #AI集成

Java 专栏收录该内容

873 篇文章

订阅专栏

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

引言

在人工智能技术飞速发展的今天，企业面临着海量文档管理和知识检索的挑战。传统的基于关键词的搜索方式已经无法满足用户对精准、智能问答的需求。Spring AI结合RAG（检索增强生成）技术，为企业提供了构建智能文档问答系统的强大解决方案。本文将深入探讨如何利用Spring AI框架和RAG技术构建高效、准确的企业级智能问答系统。

技术架构概述

Spring AI框架

Spring AI是Spring生态系统中的AI集成框架，提供了统一的API来访问各种AI模型和服务。它支持OpenAI、Azure OpenAI、Amazon Bedrock等多种AI服务提供商，并提供了简洁的编程模型。

RAG技术原理

RAG（Retrieval-Augmented Generation）是一种结合信息检索和文本生成的技术。其核心思想是：

首先从知识库中检索与问题相关的文档片段
然后将检索到的上下文与原始问题一起提供给大语言模型
最后生成基于检索内容的准确回答

系统设计与实现

环境准备

首先，我们需要配置Spring AI依赖：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>0.8.1</version>
</dependency>

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-transformers-spring-boot-starter</artifactId>
    <version>0.8.1</version>
</dependency>

文档处理模块

文档加载与分割

@Component
public class DocumentProcessor {
    
    @Autowired
    private TextSplitter textSplitter;
    
    public List<Document> processDocument(Resource resource) {
        // 加载文档
        DocumentReader reader = new PdfDocumentReader();
        Document document = reader.read(resource);
        
        // 分割文档为小块
        return textSplitter.split(document);
    }
    
    // 支持多种文档格式
    public DocumentReader getDocumentReader(String fileType) {
        switch (fileType.toLowerCase()) {
            case "pdf":
                return new PdfDocumentReader();
            case "docx":
                return new DocxDocumentReader();
            case "txt":
                return new TextDocumentReader();
            default:
                throw new IllegalArgumentException("Unsupported file type: " + fileType);
        }
    }
}

向量化与存储

向量数据库集成

@Configuration
public class VectorStoreConfig {
    
    @Value("${spring.ai.vectorstore.milvus.host}")
    private String milvusHost;
    
    @Value("${spring.ai.vectorstore.milvus.port}")
    private int milvusPort;
    
    @Bean
    public VectorStore vectorStore(EmbeddingModel embeddingModel) {
        MilvusVectorStoreConfig config = MilvusVectorStoreConfig.builder()
            .host(milvusHost)
            .port(milvusPort)
            .collectionName("enterprise_docs")
            .dimension(1536) // OpenAI embedding dimension
            .build();
            
        return new MilvusVectorStore(config, embeddingModel);
    }
    
    @Bean
    public EmbeddingModel embeddingModel() {
        return new OpenAiEmbeddingModel(
            OpenAiEmbeddingOptions.builder()
                .withModel("text-embedding-ada-002")
                .build()
        );
    }
}

RAG服务实现

核心RAG服务

@Service
public class RagService {
    
    @Autowired
    private VectorStore vectorStore;
    
    @Autowired
    private ChatClient chatClient;
    
    public String answerQuestion(String question) {
        // 1. 检索相关文档
        List<Document> relevantDocs = retrieveRelevantDocuments(question);
        
        // 2. 构建提示词
        String context = buildContext(relevantDocs);
        String prompt = buildPrompt(question, context);
        
        // 3. 生成回答
        return generateAnswer(prompt);
    }
    
    private List<Document> retrieveRelevantDocuments(String question) {
        // 使用相似度搜索获取相关文档
        return vectorStore.similaritySearch(
            SearchRequest.builder()
                .query(question)
                .topK(5) // 获取最相关的5个文档片段
                .build()
        );
    }
    
    private String buildContext(List<Document> documents) {
        StringBuilder contextBuilder = new StringBuilder();
        for (Document doc : documents) {
            contextBuilder.append(doc.getContent()).append("\n\n");
        }
        return contextBuilder.toString();
    }
    
    private String buildPrompt(String question, String context) {
        return String.format("""
            基于以下上下文信息，请回答用户的问题。
            如果上下文中的信息不足以回答问题，请如实告知"我不知道"。
            
            上下文：
            %s
            
            问题：%s
            
            回答：
            """, context, question);
    }
    
    private String generateAnswer(String prompt) {
        ChatResponse response = chatClient.call(
            new UserMessage(prompt)
        );
        return response.getResult().getOutput().getContent();
    }
}

API接口设计

REST控制器

@RestController
@RequestMapping("/api/rag")
public class RagController {
    
    @Autowired
    private RagService ragService;
    
    @PostMapping("/ask")
    public ResponseEntity<ApiResponse<String>> askQuestion(
            @RequestBody QuestionRequest request) {
        try {
            String answer = ragService.answerQuestion(request.getQuestion());
            return ResponseEntity.ok(ApiResponse.success(answer));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(ApiResponse.error("处理问题时发生错误"));
        }
    }
    
    @PostMapping("/upload")
    public ResponseEntity<ApiResponse<String>> uploadDocument(
            @RequestParam("file") MultipartFile file) {
        try {
            // 文档上传和处理逻辑
            return ResponseEntity.ok(ApiResponse.success("文档上传成功"));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(ApiResponse.error("文档上传失败"));
        }
    }
}

@Data
class QuestionRequest {
    private String question;
}

@Data
class ApiResponse<T> {
    private boolean success;
    private String message;
    private T data;
    
    public static <T> ApiResponse<T> success(T data) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setSuccess(true);
        response.setMessage("成功");
        response.setData(data);
        return response;
    }
    
    public static <T> ApiResponse<T> error(String message) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setSuccess(false);
        response.setMessage(message);
        return response;
    }
}

高级特性实现

多轮对话支持

@Service
public class ConversationService {
    
    @Autowired
    private RagService ragService;
    
    private final Map<String, List<ChatMessage>> conversationMemory = new ConcurrentHashMap<>();
    
    public String handleConversation(String sessionId, String userMessage) {
        // 获取或创建会话历史
        List<ChatMessage> history = conversationMemory.getOrDefault(sessionId, new ArrayList<>());
        
        // 添加上下文到问题中
        String contextualQuestion = buildContextualQuestion(userMessage, history);
        
        // 获取回答
        String answer = ragService.answerQuestion(contextualQuestion);
        
        // 更新会话历史
        history.add(new UserMessage(userMessage));
        history.add(new AssistantMessage(answer));
        
        // 限制历史记录长度
        if (history.size() > 10) {
            history = history.subList(history.size() - 10, history.size());
        }
        
        conversationMemory.put(sessionId, history);
        
        return answer;
    }
    
    private String buildContextualQuestion(String currentQuestion, List<ChatMessage> history) {
        if (history.isEmpty()) {
            return currentQuestion;
        }
        
        StringBuilder contextBuilder = new StringBuilder();
        contextBuilder.append("以下是之前的对话上下文：\n\n");
        
        for (ChatMessage message : history) {
            if (message instanceof UserMessage) {
                contextBuilder.append("用户: ").append(message.getContent()).append("\n");
            } else if (message instanceof AssistantMessage) {
                contextBuilder.append("助手: ").append(message.getContent()).append("\n");
            }
        }
        
        contextBuilder.append("\n当前问题: ").append(currentQuestion);
        contextBuilder.append("\n请基于以上对话上下文回答当前问题。");
        
        return contextBuilder.toString();
    }
}

性能优化策略

缓存机制

@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(30, TimeUnit.MINUTES)
            .maximumSize(1000));
        return cacheManager;
    }
}

@Service
public class CachedRagService {
    
    @Autowired
    private RagService ragService;
    
    @Cacheable(value = "answers", key = "#question")
    public String getCachedAnswer(String question) {
        return ragService.answerQuestion(question);
    }
    
    @CacheEvict(value = "answers", allEntries = true)
    public void clearCache() {
        // 缓存清除
    }
}

异步处理

@EnableAsync
@Configuration
public class AsyncConfig {
    
    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("rag-executor-");
        executor.initialize();
        return executor;
    }
}

@Service
public class AsyncRagService {
    
    @Autowired
    private RagService ragService;
    
    @Async
    public CompletableFuture<String> answerQuestionAsync(String question) {
        return CompletableFuture.completedFuture(ragService.answerQuestion(question));
    }
}

部署与监控

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: SPRING_AI_OPENAI_API_KEY
          valueFrom:
            secretKeyRef:
              name: openai-secret
              key: api-key
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
---
apiVersion: v1
kind: Service
metadata:
  name: rag-service
spec:
  selector:
    app: rag-system
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

监控配置

management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus
  metrics:
    export:
      prometheus:
        enabled: true
  endpoint:
    health:
      show-details: always

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
    vectorstore:
      milvus:
        host: localhost
        port: 19530