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）是一种结合信息检索和文本生成的技术。其核心思想是：

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

这种架构有效解决了大语言模型的"幻觉"问题，提高了回答的准确性和可信度。

系统设计与实现

环境准备

首先，我们需要配置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

总结与展望

本文详细介绍了基于Spring AI和RAG技术构建企业级智能文档问答系统的完整方案。通过结合向量数据库、大语言模型和传统的Spring Boot技术栈，我们实现了一个高效、可靠的知识检索系统。

关键优势：

  1. 准确性高：基于真实文档内容生成回答，减少AI幻觉
  2. 扩展性强：支持多种文档格式和AI模型提供商
  3. 性能优异：通过缓存、批量处理等优化策略确保系统响应速度
  4. 安全可靠：完善的输入验证和访问控制机制

未来改进方向：

  1. 支持更多类型的知识源（数据库、API等）
  2. 实现更精细的权限控制和审计日志
  3. 集成更多的AI模型和算法
  4. 提供可视化的问题分析和效果评估工具

随着AI技术的不断发展，基于RAG的智能问答系统将在企业知识管理领域发挥越来越重要的作用。Spring AI框架的出现大大降低了AI应用的开发门槛，让开发者能够更专注于业务逻辑的实现。

# RAG
Logo
武汉城市开发者社区

为武汉地区的开发者提供学习、交流和合作的平台。社区聚集了众多技术爱好者和专业人士，涵盖了多个领域，包括人工智能、大数据、云计算、区块链等。社区定期举办技术分享、培训和活动，为开发者提供更多的学习和交流机会。

更多推荐

cover

Browser Use 浏览器自动化 Agent：让浏览器自动为你工作

avatar 武汉城市开发者社区
cover

前端中的浏览器指纹识别与隐私保护技术：原理、实现策略与隐私合规实践

avatar 武汉城市开发者社区

什么是MCP

什么是MCP,以及MCP与RAG的关系

avatar 武汉城市开发者社区