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

Spring AI与RAG构建智能问答系统

原创于 2025-09-05 11:02:22 发布 · 437 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#Spring AI #RAG #Java #微服务 #人工智能 #向量数据库 #企业应用

Java 专栏收录该内容

873 篇文章

订阅专栏

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

引言

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

技术架构概述

核心组件

Spring AI框架：提供统一的AI模型接入接口
RAG架构：检索增强生成技术栈
向量数据库：Milvus/Chroma/Redis等
Embedding模型：OpenAI/Ollama等
文档处理管道：文档加载、分块、向量化

系统架构设计

客户端 → Spring Boot应用 → RAG服务 → 向量数据库
                         ↓
                    AI模型服务

环境准备与依赖配置

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.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- 向量数据库客户端 -->
    <dependency>
        <groupId>io.milvus</groupId>
        <artifactId>milvus-sdk-java</artifactId>
        <version>2.3.4</version>
    </dependency>
</dependencies>

核心实现步骤

1. 文档处理与向量化

@Service
public class DocumentProcessor {
    
    @Autowired
    private EmbeddingClient embeddingClient;
    
    public List<DocumentChunk> processDocument(String documentContent) {
        // 文档分块
        List<String> chunks = splitDocument(documentContent);
        
        // 生成向量嵌入
        List<List<Double>> embeddings = embeddingClient.embed(chunks);
        
        return createDocumentChunks(chunks, embeddings);
    }
    
    private List<String> splitDocument(String content) {
        // 基于语义的分块算法
        return TextSplitter.semanticSplit(content, 500); // 每块约500字符
    }
}

2. 向量存储与管理

@Repository
public class VectorStoreService {
    
    @Autowired
    private MilvusClient milvusClient;
    
    public void storeVectors(List<DocumentChunk> chunks) {
        List<Float> vectors = chunks.stream()
            .map(chunk -> convertToFloatVector(chunk.getEmbedding()))
            .collect(Collectors.toList());
        
        List<Map<String, String>> metadata = chunks.stream()
            .map(chunk -> createMetadata(chunk))
            .collect(Collectors.toList());
        
        milvusClient.insert("documents_collection", vectors, metadata);
    }
    
    public List<DocumentChunk> searchSimilarVectors(List<Double> queryVector, int topK) {
        List<Float> floatVector = convertToFloatVector(queryVector);
        
        SearchParam searchParam = SearchParam.newBuilder()
            .withCollectionName("documents_collection")
            .withVector(floatVector)
            .withTopK(topK)
            .build();
        
        return milvusClient.search(searchParam);
    }
}

3. RAG服务实现

@Service
public class RagService {
    
    @Autowired
    private ChatClient chatClient;
    
    @Autowired
    private VectorStoreService vectorStoreService;
    
    public String answerQuestion(String question) {
        // 1. 生成问题向量
        List<Double> questionEmbedding = embeddingClient.embed(question);
        
        // 2. 检索相关文档片段
        List<DocumentChunk> relevantChunks = 
            vectorStoreService.searchSimilarVectors(questionEmbedding, 5);
        
        // 3. 构建上下文
        String context = buildContext(relevantChunks);
        
        // 4. 生成回答
        Prompt prompt = new Prompt(
            "基于以下上下文信息回答问题。\n" +
            "上下文: " + context + "\n" +
            "问题: " + question + "\n" +
            "回答:"
        );
        
        return chatClient.generate(prompt).getGeneration().getText();
    }
    
    private String buildContext(List<DocumentChunk> chunks) {
        return chunks.stream()
            .map(DocumentChunk::getContent)
            .collect(Collectors.joining("\n\n"));
    }
}

4. REST API接口

@RestController
@RequestMapping("/api/rag")
public class RagController {
    
    @Autowired
    private RagService ragService;
    
    @PostMapping("/question")
    public ResponseEntity<ApiResponse> answerQuestion(
            @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("/documents")
    public ResponseEntity<ApiResponse> processDocument(
            @RequestBody DocumentProcessRequest request) {
        try {
            documentService.processAndStoreDocument(request.getContent());
            return ResponseEntity.ok(ApiResponse.success("文档处理成功"));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(ApiResponse.error("文档处理失败"));
        }
    }
}

高级特性实现

1. 多模型支持

@Configuration
public class AiModelConfig {
    
    @Bean
    @ConditionalOnProperty(name = "ai.provider", havingValue = "openai")
    public ChatClient openAiChatClient() {
        return new OpenAiChatClient();
    }
    
    @Bean
    @ConditionalOnProperty(name = "ai.provider", havingValue = "ollama")
    public ChatClient ollamaChatClient() {
        return new OllamaChatClient();
    }
}

2. 缓存优化

@Service
public class CachedRagService {
    
    @Autowired
    private RagService ragService;
    
    @Cacheable(value = "rag_answers", key = "#question")
    public String answerQuestionWithCache(String question) {
        return ragService.answerQuestion(question);
    }
}

3. 性能监控

@Component
public class RagMetrics {
    
    private final MeterRegistry meterRegistry;
    
    public RagMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    @Around("execution(* com.example.service.RagService.answerQuestion(..))")
    public Object monitorAnswerTime(ProceedingJoinPoint pjp) throws Throwable {
        Timer.Sample sample = Timer.start(meterRegistry);
        try {
            return pjp.proceed();
        } finally {
            sample.stop(Timer.builder("rag.answer.time")
                .description("RAG问答处理时间")
                .register(meterRegistry));
        }
    }
}

部署与运维

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: AI_PROVIDER
          value: "openai"
        - name: MILVUS_HOST
          value: "milvus-service"
---
apiVersion: v1
kind: Service
metadata:
  name: rag-service
spec:
  selector:
    app: rag-system
  ports:
  - port: 80
    targetPort: 8080

性能优化策略

1. 向量索引优化

public void optimizeVectorIndex() {
    IndexType indexType = IndexType.IVF_FLAT;
    Map<String, Object> extraParams = new HashMap<>();
    extraParams.put("nlist", 1024);
    
    milvusClient.createIndex("documents_collection", indexType, extraParams);
}

2. 批量处理优化

public void batchProcessDocuments(List<String> documents) {
    // 使用并行流处理大量文档
    documents.parallelStream()
        .map(this::processDocument)
        .forEach(this::storeVectors);
}

3. 内存管理

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

错误处理与容错

1. 重试机制

@Retryable(value = {ApiException.class}, 
           maxAttempts = 3, 
           backoff = @Backoff(delay = 1000))
public String reliableAnswerQuestion(String question) {
    return ragService.answerQuestion(question);
}

2. 降级策略

@Fallback(fallbackMethod = "fallbackAnswer")
public String answerQuestionWithFallback(String question) {
    return ragService.answerQuestion(question);
}

public String fallbackAnswer(String question) {
    return "系统暂时无法处理您的问题，请稍后再试";
}

测试策略

单元测试

@SpringBootTest
class RagServiceTest {
    
    @MockBean
    private VectorStoreService vectorStoreService;
    
    @MockBean
    private ChatClient chatClient;
    
    @Autowired
    private RagService ragService;
    
    @Test
    void testAnswerQuestion() {
        // 模拟向量搜索返回结果
        when(vectorStoreService.searchSimilarVectors(any(), anyInt()))
            .thenReturn(createMockChunks());
        
        // 模拟AI回答
        when(chatClient.generate(any())).thenReturn(
            new Generation("这是测试回答"));
        
        String answer = ragService.answerQuestion("测试问题");
        assertNotNull(answer);
    }
}

集成测试

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class RagControllerIntegrationTest {
    
    @LocalServerPort
    private int port;
    
    @Test
    void testQuestionEndpoint() {
        QuestionRequest request = new QuestionRequest("什么是Spring AI?");
        
        ResponseEntity<ApiResponse> response = restTemplate.postForEntity(
            "http://localhost:" + port + "/api/rag/question",
            request,
            ApiResponse.class
        );
        
        assertEquals(HttpStatus.OK, response.getStatusCode());
        assertTrue(response.getBody().isSuccess());
    }
}

安全考虑

1. API认证

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/api/rag/**").authenticated()
                .anyRequest().permitAll())
            .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt);
        return http.build();
    }
}

2. 输入验证

public class QuestionRequest {
    
    @NotBlank
    @Size(max = 1000)
    private String question;
    
    // getters and setters
}

总结与展望

本文详细介绍了如何使用Spring AI和RAG技术构建企业级智能文档问答系统。通过合理的架构设计、性能优化和安全考虑，我们可以构建出既高效又可靠的AI应用系统。

未来的发展方向包括：

多模态支持：支持图片、音频等非文本内容
实时学习：系统能够从用户反馈中持续学习优化
个性化推荐：基于用户历史提供个性化答案
边缘计算：在边缘设备上部署轻量级模型

Spring AI生态系统的不断成熟将为开发者提供更多强大的工具和框架，帮助企业更好地利用AI技术提升业务价值。