Spring AI + 法律大模型，实战构建智能法律咨询助手（2026.04.08）

// 传统方式：直接调用 OpenAI API
public class OpenAIService {
    private static final String API_URL = "https://api.openai.com/v1/chat/completions";
    
    public String chat(String message) {
        // 1. 手动构建请求体（格式复杂，容易出错）
        String requestBody = "{"
            + "\"model\": \"gpt-4\","
            + "\"messages\": [{\"role\": \"user\", \"content\": \"" + message + "\"}]"
            + "}";
        
        // 2. 手动设置 HTTP 请求头（API Key 硬编码）
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + apiKey);
        headers.set("Content-Type", "application/json");
        
        // 3. 手动处理 HTTP 请求与响应解析
        RestTemplate restTemplate = new RestTemplate();
        ResponseEntity<String> response = restTemplate.postForEntity(
            API_URL, 
            new HttpEntity<>(requestBody, headers), 
            String.class
        );
        
        // 4. 手动解析 JSON 提取回答内容
        // ... 复杂的 JSON 解析逻辑
        return parsedResponse;
    }
}

@RestController
public class ChatController {
    // 直接注入 ChatModel，底层可能是 OpenAI、通义千问或 Ollama
    @Resource
    private ChatModel chatModel;
    
    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        // 同步调用
        return chatModel.call(message);
    }
}

@RestController
public class LegalAssistantController {
    private final ChatClient chatClient;
    
    public LegalAssistantController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }
    
    @GetMapping("/legal-advice")
    public String getLegalAdvice(@RequestParam String question) {
        // Fluent API 风格的调用
        return chatClient.prompt()
            .user("作为法律专家，请回答：" + question)
            .call()
            .content();
    }
}

┌─────────────────────────────────────────────────────────────┐
│                     用户输入（法律问题）                      │
└─────────────────────────┬───────────────────────────────────┘
                          ▼
┌─────────────────────────────────────────────────────────────┐
│                   Spring Boot Controller                     │
│                    （REST API 入口）                          │
└─────────────────────────┬───────────────────────────────────┘
                          ▼
┌─────────────────────────────────────────────────────────────┐
│                   法律 AI 服务层（@Service）                  │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │ 意图识别模块  │→│ 法律检索模块  │→│ 答案生成模块  │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└─────────────────────────┬───────────────────────────────────┘
            ▼                           ▼
┌──────────────────────┐    ┌──────────────────────────────┐
│   向量数据库（Milvus） │    │     大模型（OpenAI/通义）     │
│   • 法律条文向量库     │    │   • 理解用户问题意图          │
│   • 判例文书向量库     │    │   • 生成专业法律回答          │
│   • 合同模板向量库     │    │   • 引用检索到的法条          │
└──────────────────────┘    └──────────────────────────────┘

spring:
  ai:
     OpenAI 配置（或切换为通义千问、Ollama）
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4
          temperature: 0.7
     向量数据库配置（以 Milvus 为例）
    vectorstore:
      milvus:
        host: localhost
        port: 19530
        database-name: legal_db
        collection-name: legal_documents
     Embedding 模型配置
    embedding:
      model: text-embedding-3-small

// 法律文档实体
@Data
@Builder
public class LegalDocument {
    private String id;          // 文档ID
    private String title;       // 文档标题（如《民法典》第XXX条）
    private String content;     // 文档内容
    private String category;    // 文档类型：LAW（法律）/CASE（判例）/CONTRACT（合同）
    private String lawNumber;   // 法条编号（如"民法典第577条"）
    private String publishDate; // 发布日期
    private List<Double> embedding;  // 向量表示
}

// 文档读取器（支持 PDF/TXT/Markdown）
@Component
public class LegalDocumentReader {
    
    public List<LegalDocument> readFromFile(String filePath) {
        // 使用 Spring AI 的 DocumentReader
        DocumentReader reader = new TikaDocumentReader(new FileSystemResource(filePath));
        List<org.springframework.ai.document.Document> documents = reader.get();
        
        // 转换为法律文档实体
        return documents.stream()
            .map(doc -> LegalDocument.builder()
                .id(doc.getId())
                .content(doc.getContent())
                .title(extractTitle(doc.getContent()))
                .category(detectCategory(doc.getContent()))
                .build())
            .collect(Collectors.toList());
    }
}

@Service
@Slf4j
public class LegalVectorIndexService {
    
    @Autowired
    private EmbeddingModel embeddingModel;
    
    @Autowired
    private VectorStore vectorStore;
    
    /
      将法律文档向量化并存入向量数据库
     /
    public void indexLegalDocuments(List<LegalDocument> documents) {
        for (LegalDocument doc : documents) {
            // 1. 文本切片：将长文档切分成适合检索的片段
            List<String> chunks = splitIntoChunks(doc.getContent(), 500);
            
            for (String chunk : chunks) {
                // 2. 向量化：将文本转换为向量
                List<Double> embedding = embeddingModel.embed(chunk);
                
                // 3. 存入向量库
                VectorStoreDocument vectorDoc = new VectorStoreDocument(
                    UUID.randomUUID().toString(),
                    chunk,
                    Map.of(
                        "title", doc.getTitle(),
                        "category", doc.getCategory(),
                        "lawNumber", doc.getLawNumber()
                    ),
                    embedding
                );
                vectorStore.add(List.of(vectorDoc));
            }
        }
        log.info("已索引 {} 条法律文档", documents.size());
    }
    
    /
      文本切片策略
     /
    private List<String> splitIntoChunks(String text, int chunkSize) {
        // 按句子/段落边界切分，避免切断法律术语
        TextSplitter splitter = new TokenTextSplitter(chunkSize, 50); // 50字符重叠
        return splitter.split(text);
    }
}

@Service
@Slf4j
public class LegalSearchService {
    
    @Autowired
    private VectorStore vectorStore;
    
    @Autowired
    private EmbeddingModel embeddingModel;
    
    /
      语义检索相关法律条文
      @param query 用户查询（如"合同违约怎么赔偿"）
      @param topK 返回最相似的 K 条结果
      @return 相关法律条文列表
     /
    public List<LegalDocument> searchRelevantLaws(String query, int topK) {
        // 1. 将用户问题转换为向量
        List<Double> queryVector = embeddingModel.embed(query);
        
        // 2. 在向量库中做相似度检索
        List<VectorStoreDocument> results = vectorStore.similaritySearch(
            SimilaritySearchRequest.builder()
                .queryVector(queryVector)
                .topK(topK)
                .similarityThreshold(0.7)  // 相似度阈值
                .build()
        );
        
        // 3. 转换结果并返回
        return results.stream()
            .map(this::convertToLegalDocument)
            .collect(Collectors.toList());
    }
    
    /
      混合检索：关键词匹配 + 向量语义检索
     /
    public List<LegalDocument> hybridSearch(String query, int topK) {
        // 先进行关键词精确检索（如法条编号）
        List<LegalDocument> keywordResults = keywordSearch(query);
        
        // 再进行向量语义检索
        List<LegalDocument> semanticResults = searchRelevantLaws(query, topK);
        
        // 合并去重，按相关性排序
        return mergeAndRank(keywordResults, semanticResults);
    }
}

@Service
@Slf4j
public class LegalRAGService {
    
    @Autowired
    private ChatClient chatClient;
    
    @Autowired
    private LegalSearchService searchService;
    
    /
      RAG 智能法律问答
      @param userQuestion 用户的法律问题
      @return 基于法律条文的专业回答
     /
    public String answerLegalQuestion(String userQuestion) {
        // Step 1: 检索相关法律条文
        List<LegalDocument> relevantLaws = searchService.searchRelevantLaws(userQuestion, 5);
        
        if (relevantLaws.isEmpty()) {
            log.warn("未检索到相关法律条文，使用通用知识回答");
            return fallbackAnswer(userQuestion);
        }
        
        // Step 2: 构建增强提示词（包含检索到的法律条文）
        String context = buildLegalContext(relevantLaws);
        String enhancedPrompt = buildRAGPrompt(userQuestion, context);
        
        // Step 3: 调用大模型生成答案
        String answer = chatClient.prompt()
            .system("你是一位专业的法律AI助手，必须严格依据提供的法律条文回答问题。如果条文不足以回答问题，请明确告知用户。严禁编造法律内容。")
            .user(enhancedPrompt)
            .call()
            .content();
        
        // Step 4: 添加法条引用
        return addLegalCitations(answer, relevantLaws);
    }
    
    /
      构建 RAG 增强提示词
     /
    private String buildRAGPrompt(String question, String context) {
        return String.format("""
            请基于以下法律条文回答用户的法律咨询问题：
            
            【相关法律条文】
            %s
            
            【用户问题】
            %s
            
            【回答要求】
            1. 优先引用上述法律条文作为依据
            2. 回答应当专业、准确、通俗易懂
            3. 如涉及多部法律，说明适用关系
            4. 包含免责声明：本回答仅供参考，具体法律问题请咨询执业律师
            """, context, question);
    }
    
    /
      构建法律上下文
     /
    private String buildLegalContext(List<LegalDocument> laws) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < laws.size(); i++) {
            LegalDocument law = laws.get(i);
            sb.append(String.format("[%d] 【%s】%s\n",
                i + 1,
                law.getTitle(),
                law.getContent()));
        }
        return sb.toString();
    }
}

@RestController
@RequestMapping("/api/legal")
@Slf4j
public class LegalAssistantController {
    
    @Autowired
    private LegalRAGService legalRAGService;
    
    /
      法律咨询接口
     /
    @PostMapping("/consult")
    public ResponseEntity<LegalConsultResponse> consult(@RequestBody LegalConsultRequest request) {
        long startTime = System.currentTimeMillis();
        
        String answer = legalRAGService.answerLegalQuestion(request.getQuestion());
        
        return ResponseEntity.ok(LegalConsultResponse.builder()
            .question(request.getQuestion())
            .answer(answer)
            .timestamp(LocalDateTime.now())
            .responseTime(System.currentTimeMillis() - startTime)
            .disclaimer("本回答仅供参考，具体法律问题请咨询专业律师")
            .build());
    }
    
    /
      流式输出接口（打字机效果）
     /
    @GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> streamLegalAdvice(@RequestParam String question) {
        return Flux.create(sink -> {
            String answer = legalRAGService.answerLegalQuestion(question);
            // 逐字输出模拟流式响应
            for (char c : answer.toCharArray()) {
                sink.next(String.valueOf(c));
                try { Thread.sleep(30); } catch (InterruptedException ignored) {}
            }
            sink.complete();
        });
    }
}

@Service
@Slf4j
public class LegalToolsService {
    
    @Autowired
    private LegalSearchService searchService;
    
    /
      工具：查询法律条文
      使用 @Tool 注解标记为 AI 可调用的工具
     /
    @Tool(description = "根据关键词查询相关法律条文内容")
    public String searchLawByKeyword(@ToolParam(description = "法律关键词，如'合同违约'") String keyword) {
        List<LegalDocument> results = searchService.searchRelevantLaws(keyword, 3);
        if (results.isEmpty()) {
            return "未找到相关法律条文";
        }
        return results.stream()
            .map(doc -> doc.getTitle() + "：" + doc.getContent())
            .collect(Collectors.joining("\n\n"));
    }
    
    /
      工具：计算违约金
     /
    @Tool(description = "根据合同金额和违约天数计算违约金")
    public double calculatePenalty(
        @ToolParam(description = "合同金额") double contractAmount,
        @ToolParam(description = "违约天数") int defaultDays,
        @ToolParam(description = "违约金比例，默认0.05%%") double penaltyRate) {
        return contractAmount  penaltyRate  defaultDays;
    }
}

┌─────────────────────────────────────────────────┐
│                    用户界面                      │
│          Web/小程序/公众号/API 调用              │
└─────────────────────────────────────────────────┘
                       ↓
┌─────────────────────────────────────────────────┐
│              接入层（Spring Boot）               │
│          REST API、WebSocket、SSE 流式输出       │
└─────────────────────────────────────────────────┘
                       ↓
┌─────────────────────────────────────────────────┐
│            核心引擎层（Spring AI）               │
│  • ChatModel（对话模型统一接口）                 │
│  • EmbeddingModel（文本向量化）                 │
│  • VectorStore（向量数据库抽象）                │
│  • Function Calling（AI 调用 Java 工具）        │
└─────────────────────────────────────────────────┘
                       ↓
┌─────────────────────────────────────────────────┐
│               模型与数据层                       │
│  • LLM：OpenAI / 通义千问 / DeepSeek / 法律大模型│
│  • 向量库：Milvus / PGVector / Chroma           │
│  • 数据源：法律条文库 + 判例库 + 合同模板库      │
└─────────────────────────────────────────────────┘