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

Spring AI是Spring生态系统中的AI集成框架，提供了统一的API来访问各种AI模型和服务。它支持OpenAI、Azure OpenAI、Google Vertex AI等多种AI服务提供商。本文详细介绍了如何使用Spring AI和RAG技术构建企业级智能文档问答系统。通过结合向量数据库、大语言模型和Spring生态系统的强大功能，我们能够创建出既准确又高效的智能问答解决方案。支持多模

Jxinna

745人浏览 · 2025-08-29 19:02:37

Jxinna · 2025-08-29 19:02:37 发布

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

引言

随着人工智能技术的快速发展，企业对于智能化文档处理的需求日益增长。传统的文档管理系统往往只能提供基于关键词的搜索，无法理解用户的自然语言查询意图。Spring AI结合RAG（检索增强生成）技术，为企业提供了一种全新的智能文档问答解决方案。本文将详细介绍如何使用Spring AI框架构建企业级智能文档问答系统。

技术栈概述

Spring AI框架

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

RAG技术原理

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

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

系统架构设计

整体架构

用户界面层 → API网关层 → 业务逻辑层 → 数据访问层
                                   ↓
                               向量数据库
                                   ↓
                               文档存储

核心组件

文档处理模块：负责文档的解析、分块和向量化
向量存储模块：使用Milvus或Chroma存储文档向量
检索模块：实现语义相似度检索
生成模块：集成大语言模型生成回答
缓存模块：使用Redis缓存频繁查询结果

实现步骤详解

1. 环境准备

首先添加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>

2. 文档处理实现

@Service
public class DocumentProcessor {
    
    @Autowired
    private EmbeddingClient embeddingClient;
    
    public List<DocumentChunk> processDocument(MultipartFile file) {
        // 解析文档内容
        String content = parseDocumentContent(file);
        
        // 文档分块
        List<String> chunks = splitIntoChunks(content);
        
        // 生成向量
        List<DocumentChunk> documentChunks = new ArrayList<>();
        for (String chunk : chunks) {
            List<Double> embedding = embeddingClient.embed(chunk);
            documentChunks.add(new DocumentChunk(chunk, embedding));
        }
        
        return documentChunks;
    }
    
    private String parseDocumentContent(MultipartFile file) {
        // 支持PDF、Word、TXT等多种格式
        String fileName = file.getOriginalFilename();
        if (fileName.endsWith(".pdf")) {
            return parsePdf(file);
        } else if (fileName.endsWith(".docx")) {
            return parseDocx(file);
        } else {
            return parseText(file);
        }
    }
    
    private List<String> splitIntoChunks(String content) {
        // 基于语义的分块算法
        return TextSplitter.semanticSplit(content, 500); // 每块约500字符
    }
}

3. 向量存储与检索

@Service
public class VectorStoreService {
    
    @Autowired
    private MilvusClient milvusClient;
    
    public void storeDocuments(List<DocumentChunk> chunks) {
        List<Float> vectors = chunks.stream()
            .map(chunk -> convertToFloat(chunk.getEmbedding()))
            .collect(Collectors.toList());
        
        List<String> texts = chunks.stream()
            .map(DocumentChunk::getText)
            .collect(Collectors.toList());
        
        milvusClient.insert("documents", vectors, texts);
    }
    
    public List<String> retrieveSimilarDocuments(String query, int topK) {
        List<Double> queryEmbedding = embeddingClient.embed(query);
        List<Float> queryVector = convertToFloat(queryEmbedding);
        
        return milvusClient.search("documents", queryVector, topK);
    }
}

4. RAG问答服务

@Service
public class RagQAService {
    
    @Autowired
    private ChatClient chatClient;
    
    @Autowired
    private VectorStoreService vectorStoreService;
    
    public String answerQuestion(String question) {
        // 检索相关文档
        List<String> relevantDocs = vectorStoreService.retrieveSimilarDocuments(question, 3);
        
        // 构建提示词
        String prompt = buildRagPrompt(question, relevantDocs);
        
        // 调用AI模型生成回答
        ChatResponse response = chatClient.generate(prompt);
        
        return response.getGeneration().getText();
    }
    
    private String buildRagPrompt(String question, List<String> contexts) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("基于以下文档内容，请回答用户的问题。\n\n");
        
        prompt.append("相关文档内容：\n");
        for (int i = 0; i < contexts.size(); i++) {
            prompt.append(String.format("[文档%d]: %s\n", i + 1, contexts.get(i)));
        }
        
        prompt.append("\n用户问题：");
        prompt.append(question);
        prompt.append("\n\n请根据上述文档内容提供准确、简洁的回答。");
        
        return prompt.toString();
    }
}

5. REST API接口

@RestController
@RequestMapping("/api/rag")
public class RagController {
    
    @Autowired
    private RagQAService ragQAService;
    
    @Autowired
    private DocumentProcessor documentProcessor;
    
    @PostMapping("/upload")
    public ResponseEntity<String> uploadDocument(@RequestParam("file") MultipartFile file) {
        try {
            List<DocumentChunk> chunks = documentProcessor.processDocument(file);
            vectorStoreService.storeDocuments(chunks);
            return ResponseEntity.ok("文档上传成功");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("文档上传失败: " + e.getMessage());
        }
    }
    
    @PostMapping("/ask")
    public ResponseEntity<AnswerResponse> askQuestion(@RequestBody QuestionRequest request) {
        try {
            String answer = ragQAService.answerQuestion(request.getQuestion());
            return ResponseEntity.ok(new AnswerResponse(answer));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new AnswerResponse("系统繁忙，请稍后重试"));
        }
    }
}

性能优化策略

1. 缓存优化

@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(1))
            .disableCachingNullValues();
        
        return RedisCacheManager.builder(connectionFactory)
            .cacheDefaults(config)
            .build();
    }
}

@Service
public class RagQAService {
    
    @Cacheable(value = "answers", key = "#question")
    public String answerQuestion(String question) {
        // 原有的问答逻辑
    }
}

2. 异步处理

@Async
public CompletableFuture<String> processDocumentAsync(MultipartFile file) {
    return CompletableFuture.supplyAsync(() -> {
        List<DocumentChunk> chunks = documentProcessor.processDocument(file);
        vectorStoreService.storeDocuments(chunks);
        return "处理完成";
    });
}

3. 批量操作

public void batchStoreDocuments(List<DocumentChunk> chunks) {
    // 分批处理，避免内存溢出
    int batchSize = 100;
    for (int i = 0; i < chunks.size(); i += batchSize) {
        List<DocumentChunk> batch = chunks.subList(i, 
            Math.min(i + batchSize, chunks.size()));
        vectorStoreService.storeDocuments(batch);
    }
}

安全考虑

1. 输入验证

public void validateQuestion(String question) {
    if (question == null || question.trim().isEmpty()) {
        throw new IllegalArgumentException("问题不能为空");
    }
    if (question.length() > 1000) {
        throw new IllegalArgumentException("问题长度超过限制");
    }
    // 防止SQL注入和XSS攻击
    if (!isSafeText(question)) {
        throw new SecurityException("检测到不安全内容");
    }
}

2. 访问控制

@PreAuthorize("hasRole('USER')")
@PostMapping("/ask")
public ResponseEntity<AnswerResponse> askQuestion(@RequestBody QuestionRequest request) {
    // 需要用户权限才能访问
}

监控与日志

1. Prometheus监控

@Bean
public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
    return registry -> registry.config().commonTags("application", "rag-system");
}

@Timed(value = "rag.question.time", description = "Time taken to answer question")
public String answerQuestion(String question) {
    // 问答逻辑
}

2. 结构化日志

@Slf4j
@Service
public class RagQAService {
    
    public String answerQuestion(String question) {
        log.info("Processing question: {}", question);
        try {
            // 处理逻辑
            log.debug("Retrieved {} relevant documents", relevantDocs.size());
            return answer;
        } catch (Exception e) {
            log.error("Failed to answer question: {}", question, e);
            throw e;
        }
    }
}

部署与运维

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:
          limits:
            memory: "1Gi"
            cpu: "500m"