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

原创于 2025-09-04 13:02:05 发布 · 893 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

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

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.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

向量数据库集成

我们选择Redis作为向量数据库，用于存储文档的向量表示：

@Configuration
public class VectorStoreConfig {
    
    @Bean
    public VectorStore vectorStore(RedisConnectionFactory connectionFactory) {
        return new RedisVectorStore(connectionFactory, 1536); // OpenAI embedding维度
    }
}

文档处理流程

1. 文档加载与分割

@Service
public class DocumentProcessor {
    
    @Autowired
    private TextSplitter textSplitter;
    
    public List<Document> processDocument(MultipartFile file) throws IOException {
        String content = extractContent(file);
        return textSplitter.split(content);
    }
    
    private String extractContent(MultipartFile file) throws IOException {
        String filename = file.getOriginalFilename();
        if (filename.endsWith(".pdf")) {
            return pdfExtractor.extract(file.getInputStream());
        } else if (filename.endsWith(".docx")) {
            return docxExtractor.extract(file.getInputStream());
        }
        // 其他格式处理
        return new String(file.getBytes(), StandardCharsets.UTF_8);
    }
}

2. 向量化与存储

@Service
public class EmbeddingService {
    
    @Autowired
    private EmbeddingClient embeddingClient;
    
    @Autowired
    private VectorStore vectorStore;
    
    public void storeDocuments(List<Document> documents) {
        List<String> texts = documents.stream()
            .map(Document::getContent)
            .collect(Collectors.toList());
        
        List<List<Double>> embeddings = embeddingClient.embed(texts);
        
        for (int i = 0; i < documents.size(); i++) {
            Document document = documents.get(i);
            Vector vector = new Vector(document.getId(), embeddings.get(i), document.getMetadata());
            vectorStore.add(vector);
        }
    }
}

RAG查询处理

@Service
public class RagService {
    
    @Autowired
    private VectorStore vectorStore;
    
    @Autowired
    private ChatClient chatClient;
    
    public String answerQuestion(String question) {
        // 1. 检索相关文档
        List<Vector> relevantVectors = vectorStore.similaritySearch(
            question, 5, 0.7); // 返回前5个最相关的结果，相似度阈值0.7
        
        // 2. 构建上下文
        String context = buildContext(relevantVectors);
        
        // 3. 构建提示词
        String prompt = buildPrompt(question, context);
        
        // 4. 调用AI模型生成回答
        return chatClient.generate(prompt);
    }
    
    private String buildContext(List<Vector> vectors) {
        return vectors.stream()
            .map(vector -> vector.getMetadata().get("content") + "\n")
            .collect(Collectors.joining("\n---\n"));
    }
    
    private String buildPrompt(String question, String context) {
        return String.format("""
            基于以下上下文信息，请回答用户的问题。
            如果上下文中的信息不足以回答问题，请如实告知。
            
            上下文：
            %s
            
            问题：%s
            
            回答：
            """, context, question);
    }
}

REST API设计

@RestController
@RequestMapping("/api/rag")
public class RagController {
    
    @Autowired
    private RagService ragService;
    
    @Autowired
    private DocumentProcessor documentProcessor;
    
    @Autowired
    private EmbeddingService embeddingService;
    
    @PostMapping("/upload")
    public ResponseEntity<String> uploadDocument(@RequestParam("file") MultipartFile file) {
        try {
            List<Document> documents = documentProcessor.processDocument(file);
            embeddingService.storeDocuments(documents);
            return ResponseEntity.ok("文档上传并处理成功");
        } catch (IOException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("文档处理失败: " + e.getMessage());
        }
    }
    
    @PostMapping("/ask")
    public ResponseEntity<String> askQuestion(@RequestBody QuestionRequest request) {
        try {
            String answer = ragService.answerQuestion(request.getQuestion());
            return ResponseEntity.ok(answer);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("回答问题失败: " + e.getMessage());
        }
    }
}

高级特性实现

1. 多轮对话支持

@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> messages = conversationMemory.getOrDefault(sessionId, new ArrayList<>());
        
        // 添加上下文信息
        String context = extractContextFromHistory(messages);
        String enhancedQuestion = context + "\n" + userMessage;
        
        String response = ragService.answerQuestion(enhancedQuestion);
        
        // 保存对话历史
        messages.add(new ChatMessage("user", userMessage));
        messages.add(new ChatMessage("assistant", response));
        
        // 限制历史记录长度
        if (messages.size() > 10) {
            messages = messages.subList(messages.size() - 10, messages.size());
        }
        
        conversationMemory.put(sessionId, messages);
        return response;
    }
}

2. 答案可信度评估

@Service
public class ConfidenceService {
    
    public double evaluateAnswerConfidence(String question, String answer, List<Vector> sources) {
        // 基于来源数量、相似度分数、答案长度等因素计算可信度
        double sourceConfidence = calculateSourceConfidence(sources);
        double answerQuality = evaluateAnswerQuality(answer);
        
        return (sourceConfidence * 0.6) + (answerQuality * 0.4);
    }
    
    private double calculateSourceConfidence(List<Vector> sources) {
        if (sources.isEmpty()) return 0.0;
        
        return sources.stream()
            .mapToDouble(vector -> vector.getSimilarityScore())
            .average()
            .orElse(0.0);
    }
}

性能优化策略

1. 批量处理优化

@Service
public class BatchEmbeddingService {
    
    @Async
    public CompletableFuture<Void> processDocumentsInBatch(List<Document> documents) {
        int batchSize = 100;
        List<CompletableFuture<Void>> futures = new ArrayList<>();
        
        for (int i = 0; i < documents.size(); i += batchSize) {
            List<Document> batch = documents.subList(i, Math.min(i + batchSize, documents.size()));
            futures.add(processBatchAsync(batch));
        }
        
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
    }
}

2. 缓存机制

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

@Service
public class CachedRagService {
    
    @Cacheable(value = "answers", key = "#question")
    public String getCachedAnswer(String question) {
        return ragService.answerQuestion(question);
    }
}

监控与运维

1. 性能指标监控

@Component
public class RagMetrics {
    
    private final MeterRegistry meterRegistry;
    
    public RagMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    public void recordQueryTime(long milliseconds) {
        meterRegistry.timer("rag.query.time").record(milliseconds, TimeUnit.MILLISECONDS);
    }
    
    public void recordAnswerConfidence(double confidence) {
        meterRegistry.gauge("rag.answer.confidence", confidence);
    }
}

2. 健康检查

@Component
public class RagHealthIndicator implements HealthIndicator {
    
    @Autowired
    private VectorStore vectorStore;
    
    @Autowired
    private ChatClient chatClient;
    
    @Override
    public Health health() {
        try {
            // 检查向量数据库连接
            vectorStore.ping();
            
            // 检查AI服务连接
            chatClient.generate("test");
            
            return Health.up().build();
        } catch (Exception e) {
            return Health.down().withException(e).build();
        }
    }
}

安全考虑

1. 输入验证与过滤

@Service
public class InputValidationService {
    
    private static final Set<String> BLACKLISTED_PATTERNS = Set.of(
        "<script>", "javascript:", "onload=", "onerror="
    );
    
    public boolean validateInput(String input) {
        if (input == null || input.trim().isEmpty()) {
            return false;
        }
        
        // 检查黑名单模式
        for (String pattern : BLACKLISTED_PATTERNS) {
            if (input.toLowerCase().contains(pattern)) {
                return false;
            }
        }
        
        // 长度限制
        return input.length() <= 1000;
    }
}

2. 访问控制

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/api/rag/ask").authenticated()
            .antMatchers("/api/rag/upload").hasRole("ADMIN")
            .anyRequest().permitAll()
            .and()
            .oauth2ResourceServer().jwt();
    }
}

部署与扩展

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
        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