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

原创于 2025-08-30 15:03:12 发布 · 313 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

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

Java 专栏收录该内容

873 篇文章

订阅专栏

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

引言

在人工智能技术快速发展的今天，如何将AI能力有效集成到企业应用中成为了技术团队面临的重要挑战。Spring AI作为Spring生态系统中的AI集成框架，结合RAG（检索增强生成）技术，为企业构建智能文档问答系统提供了强大的技术支撑。本文将深入探讨如何使用Spring AI和RAG技术构建高效、准确的企业级智能问答系统。

技术架构概述

Spring AI框架核心组件

Spring AI提供了统一的API来集成各种AI模型和服务，主要包括以下核心组件：

AI模型抽象层：提供统一的接口访问不同AI提供商的服务
提示工程支持：内置提示模板和变量替换机制
向量化集成：支持多种向量数据库和嵌入模型
工具调用框架：标准化AI代理的工具执行能力

RAG技术架构

RAG（Retrieval-Augmented Generation）技术通过以下流程实现智能问答：

// RAG处理流程伪代码
public String ragProcess(String question) {
    // 1. 问题向量化
    Embedding questionEmbedding = embeddingModel.embed(question);
    
    // 2. 语义检索
    List<Document> relevantDocs = vectorStore.similaritySearch(questionEmbedding);
    
    // 3. 上下文构建
    String context = buildContext(relevantDocs);
    
    // 4. 增强生成
    String prompt = buildPrompt(question, context);
    return aiModel.generate(prompt);
}

环境搭建与配置

Maven依赖配置

<dependencies>
    <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-pgvector-store-spring-boot-starter</artifactId>
        <version>0.8.1</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

应用配置

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-3.5-turbo
          temperature: 0.7
    
    vectorstore:
      pgvector:
        enabled: true
        index-type: HNSW
        dimensions: 1536

核心功能实现

文档处理与向量化

@Service
public class DocumentProcessingService {
    
    @Autowired
    private EmbeddingModel embeddingModel;
    
    @Autowired
    private VectorStore vectorStore;
    
    public void processDocument(MultipartFile file) {
        try {
            // 文档解析
            String content = parseDocument(file);
            
            // 文本分块
            List<TextChunk> chunks = chunkText(content);
            
            // 向量化并存储
            chunks.forEach(chunk -> {
                Embedding embedding = embeddingModel.embed(chunk.getText());
                Document document = new Document(chunk.getText(), 
                    Map.of("source", file.getOriginalFilename()));
                vectorStore.add(List.of(embedding), List.of(document));
            });
        } catch (Exception e) {
            throw new RuntimeException("文档处理失败", e);
        }
    }
    
    private List<TextChunk> chunkText(String text) {
        // 实现文本分块逻辑
        return TextSplitter.split(text, 1000, 200);
    }
}

智能问答服务

@Service
public class QAService {
    
    @Autowired
    private ChatClient chatClient;
    
    @Autowired
    private VectorStore vectorStore;
    
    @Autowired
    private EmbeddingModel embeddingModel;
    
    public String answerQuestion(String question) {
        // 1. 检索相关文档
        List<Document> relevantDocs = retrieveRelevantDocuments(question);
        
        // 2. 构建提示
        String prompt = buildRAGPrompt(question, relevantDocs);
        
        // 3. 生成回答
        return chatClient.call(prompt);
    }
    
    private List<Document> retrieveRelevantDocuments(String question) {
        Embedding questionEmbedding = embeddingModel.embed(question);
        return vectorStore.similaritySearch(questionEmbedding, 5);
    }
    
    private String buildRAGPrompt(String question, List<Document> documents) {
        StringBuilder context = new StringBuilder();
        documents.forEach(doc -> 
            context.append("文档内容: ").append(doc.getContent()).append("\n\n"));
        
        return String.format("""
            基于以下上下文信息，请回答用户的问题。
            如果上下文信息不足以回答问题，请如实告知。
            
            上下文信息:
            %s
            
            用户问题: %s
            
            请提供准确、详细的回答:
            """, context.toString(), question);
    }
}

高级特性实现

多轮对话支持

@Service
public class ConversationService {
    
    @Autowired
    private ChatClient chatClient;
    
    private final Map<String, List<ChatMessage>> conversationHistory = new ConcurrentHashMap<>();
    
    public String continueConversation(String sessionId, String userMessage) {
        List<ChatMessage> history = conversationHistory.getOrDefault(sessionId, 
            new ArrayList<>());
        
        // 添加用户消息
        history.add(new ChatMessage("user", userMessage));
        
        // 构建对话上下文
        String context = buildConversationContext(history);
        
        // 生成回复
        String assistantReply = chatClient.call(context);
        
        // 保存助手回复
        history.add(new ChatMessage("assistant", assistantReply));
        conversationHistory.put(sessionId, history);
        
        return assistantReply;
    }
    
    private String buildConversationContext(List<ChatMessage> history) {
        StringBuilder context = new StringBuilder();
        context.append("以下是当前的对话历史:\n\n");
        
        history.forEach(message -> 
            context.append(message.getRole())
                  .append(": ")
                  .append(message.getContent())
                  .append("\n"));
        
        context.append("\n请基于以上对话历史继续对话:");
        return context.toString();
    }
}

工具调用集成

@Configuration
public class ToolConfiguration {
    
    @Bean
    public FunctionToolWrapper databaseQueryTool() {
        return FunctionToolWrapper.builder()
            .name("queryDatabase")
            .description("查询企业数据库获取相关信息")
            .function(new QueryDatabaseFunction())
            .build();
    }
    
    @Bean
    public FunctionToolWrapper apiCallTool() {
        return FunctionToolWrapper.builder()
            .name("callInternalAPI")
            .description("调用内部API获取数据")
            .function(new InternalAPIFunction())
            .build();
    }
}

@Service
public class ToolEnhancedQAService {
    
    @Autowired
    private List<FunctionToolWrapper> tools;
    
    @Autowired
    private ChatClient chatClient;
    
    public String enhancedAnswer(String question) {
        // 构建工具调用提示
        String toolPrompt = buildToolPrompt(question);
        
        // 执行工具调用
        String result = chatClient.call(toolPrompt);
        
        // 解析工具调用结果并生成最终回答
        return processToolResult(result);
    }
}

性能优化与监控

缓存策略

@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 CachedQAService {
    
    @Autowired
    private QAService qaService;
    
    @Cacheable(value = "qaCache", key = "#question")
    public String getCachedAnswer(String question) {
        return qaService.answerQuestion(question);
    }
}

监控与指标

@Configuration
public class MetricsConfig {
    
    @Bean
    public MeterRegistry meterRegistry() {
        return new SimpleMeterRegistry();
    }
}

@Service
public class MonitoredQAService {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    @Autowired
    private QAService qaService;
    
    private final Timer responseTimer;
    
    public MonitoredQAService(MeterRegistry meterRegistry) {
        this.responseTimer = Timer.builder("qa.response.time")
            .description("问答响应时间")
            .register(meterRegistry);
    }
    
    public String answerWithMetrics(String question) {
        return responseTimer.record(() -> qaService.answerQuestion(question));
    }
}

安全考虑

输入验证与过滤

@Service
public class SecurityService {
    
    private static final Set<String> BLACKLISTED_TERMS = Set.of(
        "敏感词1", "敏感词2", "恶意指令"
    );
    
    public void validateInput(String input) {
        if (input == null || input.trim().isEmpty()) {
            throw new IllegalArgumentException("输入不能为空");
        }
        
        if (input.length() > 1000) {
            throw new IllegalArgumentException("输入过长");
        }
        
        // 检查黑名单词
        for (String term : BLACKLISTED_TERMS) {
            if (input.toLowerCase().contains(term.toLowerCase())) {
                throw new SecurityException("输入包含不允许的内容");
            }
        }
    }
}

访问控制

@RestController
@RequestMapping("/api/qa")
public class QAController {
    
    @PostMapping
    @PreAuthorize("hasRole('USER')")
    public ResponseEntity<String> askQuestion(@RequestBody QuestionRequest request) {
        // 实现问答逻辑
        return ResponseEntity.ok(qaService.answerQuestion(request.getQuestion()));
    }
    
    @PostMapping("/admin/upload")
    @PreAuthorize("hasRole('ADMIN')")
    public ResponseEntity<String> uploadDocument(@RequestParam MultipartFile file) {
        // 文档上传逻辑
        return ResponseEntity.ok("文档上传成功");
    }
}

部署与运维

Docker容器化

FROM openjdk:17-jdk-slim

WORKDIR /app

COPY target/spring-ai-rag-app.jar app.jar

EXPOSE 8080

ENV JAVA_OPTS="-Xmx512m -Xms256m"

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

Kubernetes部署

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-ai-rag-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: spring-ai-rag
  template:
    metadata:
      labels:
        app: spring-ai-rag
    spec:
      containers:
      - name: app
        image: spring-ai-rag:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"
---
apiVersion: v1
kind: Service
metadata:
  name: spring-ai-rag-service
spec:
  selector:
    app: spring-ai-rag
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

测试策略

单元测试

@SpringBootTest
public class QAServiceTest {
    
    @MockBean
    private ChatClient chatClient;
    
    @MockBean
    private VectorStore vectorStore;
    
    @Autowired
    private QAService qaService;
    
    @Test
    public void testAnswerQuestionWithRelevantContext() {
        // 模拟向量存储返回相关文档
        when(vectorStore.similaritySearch(any(), anyInt()))
            .thenReturn(List.of(new Document("相关文档内容")));
        
        // 模拟AI模型返回答案
        when(chatClient.call(anyString()))
            .thenReturn("这是基于上下文的答案");
        
        String answer = qaService.answerQuestion("测试问题");
        
        assertNotNull(answer);
        assertEquals("这是基于上下文的答案", answer);
    }
}

集成测试

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Testcontainers
public class IntegrationTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13");
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }
    
    @Test
    public void testFullIntegration() {
        // 完整的集成测试逻辑
    }
}