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

原创于 2025-09-04 14:01:33 发布 · 397 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

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

Java 专栏收录该内容

873 篇文章

订阅专栏

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

引言

随着人工智能技术的快速发展，企业对于智能化文档处理的需求日益增长。传统的文档管理系统往往只能提供简单的关键词搜索，无法理解用户的自然语言查询意图。Spring AI结合RAG（Retrieval-Augmented Generation）技术，为企业构建智能文档问答系统提供了全新的解决方案。

技术栈概述

核心组件

Spring AI: Spring生态系统中的AI集成框架
RAG架构: 检索增强生成技术
向量数据库: Milvus/Chroma/Redis
Embedding模型: OpenAI/Ollama
Spring Boot: 后端开发框架

系统架构设计

整体架构

用户界面 → Spring Boot应用 → RAG引擎 → 向量数据库 → 文档存储
      ↓           ↓           ↓           ↓
自然语言查询  请求处理   语义检索+生成  向量相似度匹配

核心模块

1. 文档预处理模块

@Component
public class DocumentProcessor {
    
    @Autowired
    private EmbeddingModel embeddingModel;
    
    public List<DocumentChunk> processDocument(MultipartFile file) {
        // 文档解析
        String content = extractContent(file);
        
        // 文本分块
        List<String> chunks = splitIntoChunks(content);
        
        // 生成向量
        List<Embedding> embeddings = embeddingModel.embed(chunks);
        
        return createDocumentChunks(chunks, embeddings);
    }
    
    private List<String> splitIntoChunks(String content) {
        // 基于语义的分块策略
        return TextSplitter.semanticSplit(content, 500); // 每块约500字符
    }
}

2. 向量存储模块

@Repository
public class VectorStoreService {
    
    @Autowired
    private MilvusClient milvusClient;
    
    public void storeDocuments(List<DocumentChunk> chunks) {
        List<Float> vectors = chunks.stream()
            .map(DocumentChunk::getEmbedding)
            .map(Embedding::getVector)
            .collect(Collectors.toList());
        
        List<Map<String, String>> metadata = chunks.stream()
            .map(this::createMetadata)
            .collect(Collectors.toList());
        
        milvusClient.insert("documents", vectors, metadata);
    }
    
    public List<DocumentChunk> searchSimilar(String query, int topK) {
        Embedding queryEmbedding = embeddingModel.embed(query);
        
        SearchParam searchParam = SearchParam.newBuilder()
            .withCollectionName("documents")
            .withVector(queryEmbedding.getVector())
            .withTopK(topK)
            .build();
        
        return milvusClient.search(searchParam);
    }
}

3. RAG引擎模块

@Service
public class RAGEngine {
    
    @Autowired
    private VectorStoreService vectorStore;
    
    @Autowired
    private ChatClient chatClient;
    
    public String generateAnswer(String question) {
        // 检索相关文档片段
        List<DocumentChunk> relevantChunks = vectorStore.searchSimilar(question, 5);
        
        // 构建提示词
        String context = buildContext(relevantChunks);
        String prompt = buildPrompt(question, context);
        
        // 生成回答
        ChatResponse response = chatClient.generate(prompt);
        
        return response.getContent();
    }
    
    private String buildContext(List<DocumentChunk> chunks) {
        return chunks.stream()
            .map(DocumentChunk::getContent)
            .collect(Collectors.joining("\n\n"));
    }
    
    private String buildPrompt(String question, String context) {
        return String.format("""
            基于以下上下文信息，请回答用户的问题。
            如果上下文信息不足以回答问题，请如实告知。
            
            上下文：
            %s
            
            问题：%s
            
            回答：
            """, context, question);
    }
}

实战案例：企业知识库问答

场景描述

某科技公司拥有大量的技术文档、API文档和产品手册，员工经常需要查询这些文档来解决技术问题。传统的关键词搜索效率低下，且无法理解复杂的自然语言查询。

实现步骤

1. 环境搭建

# application.yml
spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
    vectorstore:
      milvus:
        uri: localhost:19530
        collection-name: company_docs

2. 文档入库

@RestController
public class DocumentController {
    
    @PostMapping("/api/documents/upload")
    public ResponseEntity<String> uploadDocument(
            @RequestParam("file") MultipartFile file) {
        
        List<DocumentChunk> chunks = documentProcessor.processDocument(file);
        vectorStoreService.storeDocuments(chunks);
        
        return ResponseEntity.ok("文档上传成功");
    }
}

3. 问答接口

@RestController
public class QAController {
    
    @PostMapping("/api/ask")
    public ResponseEntity<AnswerResponse> askQuestion(
            @RequestBody QuestionRequest request) {
        
        String answer = ragEngine.generateAnswer(request.getQuestion());
        
        return ResponseEntity.ok(new AnswerResponse(answer));
    }
}

性能优化策略

1. 缓存机制

@Cacheable(value = "answers", key = "#question")
public String getCachedAnswer(String question) {
    return ragEngine.generateAnswer(question);
}

2. 异步处理

@Async
public CompletableFuture<String> asyncGenerateAnswer(String question) {
    return CompletableFuture.supplyAsync(() -> 
        ragEngine.generateAnswer(question));
}

3. 批量处理

public Map<String, String> batchAnswer(List<String> questions) {
    return questions.parallelStream()
        .collect(Collectors.toMap(
            Function.identity(),
            this::generateAnswer
        ));
}

高级特性实现

1. 多模态支持

public class MultiModalRAG {
    
    public String processImageQuestion(String question, MultipartFile image) {
        // 提取图像特征
        ImageEmbedding imageEmbedding = visionModel.embed(image);
        
        // 多模态检索
        List<MultiModalChunk> relevantChunks = 
            multiModalVectorStore.search(question, imageEmbedding);
        
        return generateMultiModalAnswer(question, relevantChunks);
    }
}

2. 对话历史管理

@Service
public class ConversationService {
    
    @Autowired
    private ConversationMemory memory;
    
    public String continueConversation(String sessionId, String message) {
        // 获取对话历史
        List<Message> history = memory.getConversationHistory(sessionId);
        
        // 构建包含历史的提示词
        String enhancedPrompt = buildPromptWithHistory(message, history);
        
        // 生成回答并保存到历史
        String response = chatClient.generate(enhancedPrompt);
        memory.saveMessage(sessionId, message, response);
        
        return response;
    }
}

3. 事实核查与防幻觉

public class FactChecker {
    
    public VerifiedAnswer generateVerifiedAnswer(String question) {
        String rawAnswer = ragEngine.generateAnswer(question);
        
        // 提取答案中的关键事实
        List<String> facts = extractFacts(rawAnswer);
        
        // 验证事实准确性
        Map<String, Boolean> verificationResults = verifyFacts(facts);
        
        // 生成带有验证标记的答案
        return createVerifiedAnswer(rawAnswer, verificationResults);
    }
}

部署与监控

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
  template:
    spec:
      containers:
      - name: rag-app
        image: rag-system:latest
        resources:
          limits:
            memory: "2Gi"
            cpu: "1"

监控指标

@RestController
public class MetricsController {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    @PostMapping("/api/ask")
    public ResponseEntity<AnswerResponse> askQuestion(
            @RequestBody QuestionRequest request) {
        
        Timer.Sample sample = Timer.start(meterRegistry);
        String answer = ragEngine.generateAnswer(request.getQuestion());
        sample.stop(Timer.builder("rag.response.time")
            .register(meterRegistry));
        
        // 记录成功率
        meterRegistry.counter("rag.requests.total").increment();
        
        return ResponseEntity.ok(new AnswerResponse(answer));
    }
}