第2252篇：法律AI工程实践——合同审查和法律检索系统的落地挑战

适读人群：法律科技工程师、Java后端开发者、企业法务技术团队 | 阅读时长：约16分钟 | 核心价值：深度剖析法律AI的落地挑战，从合同智能审查到法律检索的完整工程实现

一家制造业公司的法务总监跟我聊过一次，他说他们公司每年要签几千份合同，法务部只有3个人，根本看不过来。很多合同就是采购部门直接盖章签了，事后出了问题才来找法务，但那时候已经很被动了。

他最怕的不是那些明显有问题的合同（这种法务一般能识别），而是藏得很深的风险条款：乍看没问题，但结合具体的业务场景和法律背景，才会发现某个措辞非常不利。

比如违约金条款写的是"按合同总金额的10%计算"，但合同里规定了对乙方违约的各种情形，却没有限制甲方违约的情形，实际上是一个不对等的合同。这种问题，即使有经验的律师也需要仔细阅读才能发现。

---

法律AI的核心挑战

法律AI在所有行业AI中有几个独特的挑战：

1. 精准性要求极高：错误的法律分析可能导致重大损失，不能容忍模糊答案
2. 上下文高度依赖：同一条款的风险程度，取决于行业背景、交易对手、适用法律
3. 专业知识壁垒：需要法律领域的专业知识，通用LLM往往不够精准
4. 可解释性要求：必须能说明"为什么"这里有风险，而不是只说"有风险"

---

合同解析：结构化提取

@Service
public class ContractParserService {

    @Autowired
    private LLMClient llmClient;
    
    @Autowired
    private PDFExtractor pdfExtractor;

    /**
     * 将合同文档解析为结构化数据
     */
    public StructuredContract parse(ContractDocument document) {
        // 1. 提取文本（保留格式信息）
        String rawText = pdfExtractor.extract(document.getFileData());
        
        // 2. 识别合同基本信息
        ContractBasicInfo basicInfo = extractBasicInfo(rawText);
        
        // 3. 识别条款结构
        List<ContractClause> clauses = extractClauses(rawText);
        
        // 4. 分类每个条款
        for (ContractClause clause : clauses) {
            ClauseType type = classifyClause(clause.getText());
            clause.setType(type);
        }
        
        return StructuredContract.builder()
            .documentId(document.getId())
            .basicInfo(basicInfo)
            .clauses(clauses)
            .rawText(rawText)
            .build();
    }

    /**
     * 提取合同基本信息
     */
    private ContractBasicInfo extractBasicInfo(String text) {
        String prompt = String.format("""
            从以下合同文本中提取基本信息（JSON格式）：
            
            %s
            
            需要提取：
            {
              "contract_type": "合同类型（采购/销售/服务/劳动/租赁等）",
              "party_a": "甲方（需方/买方）名称",
              "party_b": "乙方（供方/卖方）名称",
              "signing_date": "签订日期YYYY-MM-DD",
              "effective_date": "生效日期",
              "expiry_date": "到期日期",
              "total_amount": "合同总金额（数字，元）",
              "currency": "货币类型",
              "governing_law": "适用法律/管辖地",
              "dispute_resolution": "争议解决方式（仲裁/诉讼/协商）"
            }
            """,
            text.length() > 3000 ? text.substring(0, 3000) : text
        );
        
        return parseFromLLM(prompt, ContractBasicInfo.class);
    }

    /**
     * 条款类型分类
     */
    private ClauseType classifyClause(String clauseText) {
        // 关键词快速分类
        String lower = clauseText.toLowerCase();
        if (contains(lower, "违约", "赔偿", "罚款")) return ClauseType.BREACH_PENALTY;
        if (contains(lower, "知识产权", "著作权", "专利")) return ClauseType.IP;
        if (contains(lower, "保密", "不得披露", "机密")) return ClauseType.CONFIDENTIALITY;
        if (contains(lower, "不可抗力", "force majeure")) return ClauseType.FORCE_MAJEURE;
        if (contains(lower, "付款", "结算", "发票")) return ClauseType.PAYMENT;
        if (contains(lower, "验收", "质量", "标准")) return ClauseType.QUALITY;
        if (contains(lower, "解除", "终止", "撤销")) return ClauseType.TERMINATION;
        if (contains(lower, "仲裁", "法院", "管辖")) return ClauseType.DISPUTE_RESOLUTION;
        return ClauseType.OTHER;
    }
}

---

风险检测：逐条分析

@Service
public class ContractRiskAnalyzer {

    @Autowired
    private LLMClient llmClient;
    
    @Autowired
    private LegalKnowledgeBase legalKB;
    
    @Autowired
    private ContractTemplateRepository templateRepo;

    /**
     * 分析合同的风险条款
     */
    public ContractRiskReport analyzeRisk(StructuredContract contract, 
                                           String clientRole) {
        List<RiskItem> riskItems = new ArrayList<>();
        
        // 逐类型分析
        for (ClauseType type : ClauseType.values()) {
            List<ContractClause> clauses = contract.getClausesByType(type);
            if (clauses.isEmpty()) continue;
            
            List<RiskItem> clauseRisks = analyzeClauseType(
                type, clauses, clientRole, contract.getBasicInfo());
            riskItems.addAll(clauseRisks);
        }
        
        // 整体结构性风险
        riskItems.addAll(analyzeStructuralRisks(contract, clientRole));
        
        // 按严重程度排序
        riskItems.sort(Comparator.comparing(RiskItem::getSeverity).reversed());
        
        return ContractRiskReport.builder()
            .contractId(contract.getDocumentId())
            .clientRole(clientRole)
            .riskItems(riskItems)
            .overallRiskLevel(calculateOverallRisk(riskItems))
            .summary(generateSummary(contract, riskItems))
            .recommendations(generateRecommendations(riskItems))
            .build();
    }

    /**
     * 分析特定类型条款的风险
     */
    private List<RiskItem> analyzeClauseType(ClauseType type, 
                                               List<ContractClause> clauses,
                                               String clientRole,
                                               ContractBasicInfo basicInfo) {
        // 获取该类型的风险检查规则
        List<RiskCheckRule> rules = legalKB.getRules(type);
        
        // 获取同类合同的标准条款（用于对比）
        String standardClause = templateRepo.getStandardClause(
            type, basicInfo.getContractType());
        
        String clauseText = clauses.stream()
            .map(ContractClause::getText)
            .collect(Collectors.joining("\n\n"));
        
        String prompt = String.format("""
            你是资深商业律师，请分析以下合同条款对"%s"（%s）的风险。
            
            条款类型：%s
            条款内容：
            %s
            
            标准参考条款（供对比）：
            %s
            
            风险检查重点：
            %s
            
            请输出JSON格式的风险分析：
            [
              {
                "risk_description": "具体风险描述",
                "risk_clause": "引起风险的具体条款原文",
                "severity": "HIGH/MEDIUM/LOW",
                "reasoning": "风险依据（引用具体法律条文或商业惯例）",
                "suggestion": "修改建议（具体的措辞修改方向）"
              }
            ]
            
            注意：
            1. 只报告真实存在的风险，不要过度解读
            2. 风险描述要具体，结合"%s"的业务实际
            3. 如果条款对客户有利，不需要提报告
            """,
            basicInfo.getPartyByRole(clientRole),
            clientRole.equals("PARTY_A") ? "甲方" : "乙方",
            type.getDisplayName(),
            clauseText,
            standardClause != null ? standardClause : "无标准参考",
            formatRules(rules),
            basicInfo.getContractType()
        );
        
        LLMResponse response = llmClient.complete(
            "你是精通中国合同法和商业实践的资深律师。",
            prompt,
            LLMConfig.builder()
                .model("deepseek-v3")
                .temperature(0.1)
                .responseFormat(ResponseFormat.JSON)
                .build()
        );
        
        return parseRiskItems(response.getContent(), type);
    }

    /**
     * 结构性风险分析
     * 检查合同整体的不对等性、缺失条款等
     */
    private List<RiskItem> analyzeStructuralRisks(StructuredContract contract, 
                                                    String clientRole) {
        List<RiskItem> risks = new ArrayList<>();
        
        // 检查必要条款是否缺失
        List<ClauseType> requiredTypes = List.of(
            ClauseType.BREACH_PENALTY, ClauseType.DISPUTE_RESOLUTION,
            ClauseType.FORCE_MAJEURE, ClauseType.TERMINATION
        );
        
        for (ClauseType required : requiredTypes) {
            if (contract.getClausesByType(required).isEmpty()) {
                risks.add(RiskItem.builder()
                    .type(required)
                    .severity(RiskSeverity.MEDIUM)
                    .riskDescription("合同缺少" + required.getDisplayName() + "条款")
                    .suggestion("建议在合同中明确约定" + required.getDisplayName())
                    .build());
            }
        }
        
        // 检查违约责任的对等性
        List<ContractClause> breachClauses = contract.getClausesByType(ClauseType.BREACH_PENALTY);
        if (!breachClauses.isEmpty()) {
            checkBreachPenaltyBalance(breachClauses, clientRole, risks);
        }
        
        return risks;
    }
}

---

法律检索：RAG在法律场景的特殊处理

@Service
public class LegalSearchService {

    @Autowired
    private LegalDocumentRepository legalDocRepo;
    
    @Autowired
    private HybridSearchEngine searchEngine;
    
    @Autowired
    private LLMClient llmClient;

    /**
     * 法律问题检索回答
     * 特殊要求：必须精确引用法律条文，不能臆造
     */
    public LegalAnswer search(String legalQuery) {
        // 1. 查询改写：补充法律专业术语
        String expandedQuery = expandLegalQuery(legalQuery);
        
        // 2. 检索相关法律文件
        List<LegalDocument> retrieved = searchEngine.search(
            expandedQuery, 
            SearchScope.builder()
                .documentTypes(List.of("LAW", "REGULATION", "JUDICIAL_INTERPRETATION", 
                                       "CASE_LAW"))
                .build(),
            8
        );
        
        if (retrieved.isEmpty()) {
            return LegalAnswer.noResults();
        }
        
        // 3. 按相关性和权威性排序
        retrieved.sort(Comparator.comparingDouble(
            d -> -(d.getRelevanceScore() * 0.6 + d.getAuthorityScore() * 0.4)));
        
        // 4. 生成回答（强制引用来源）
        String answer = generateWithCitations(legalQuery, retrieved);
        
        return LegalAnswer.builder()
            .answer(answer)
            .citations(buildCitations(retrieved))
            .disclaimer("以上内容仅供参考，具体法律问题请咨询专业律师。")
            .build();
    }

    private String generateWithCitations(String query, List<LegalDocument> docs) {
        String context = docs.stream()
            .map(d -> String.format("[%s] %s\n%s", 
                d.getId(), d.getTitle(), d.getRelevantContent()))
            .collect(Collectors.joining("\n\n---\n\n"));
        
        String prompt = String.format("""
            基于以下法律文件，回答问题：%s
            
            法律文件：
            %s
            
            回答要求：
            1. 只引用上述文件中的内容，用[文件ID]标注来源
            2. 如果文件中没有明确回答，直接说明"相关法律规定未检索到"
            3. 区分"法律明确规定"和"通常理解/实践惯例"
            4. 回答要准确，不能有模糊表述
            5. 不超过500字
            """,
            query, context
        );
        
        return llmClient.complete(
            "你是精通中国法律的专业法律顾问，回答必须严格基于法律条文。",
            prompt,
            LLMConfig.builder().temperature(0.0).build()
        ).getContent();
    }
}

---

工程边界：法律AI不能做的事

在法律场景做AI，有几个硬边界：

不能做：

• 给出"你应该签这份合同"的最终建议（这是法律咨询，需要执照）
• 预测官司结果（法律结果受太多未知因素影响）
• 代替律师出具法律意见书

可以做：

• 识别合同中的风险条款并解释原因
• 搜索相关法律法规并摘录要点
• 对比两份合同的差异
• 生成合同草稿（但必须律师审核）

这个边界不是保守，而是诚实。系统的价值在于提高法务和律师的工作效率，而不是替代他们的专业判断。一个清楚自己边界的AI工具，比一个什么都敢声称的AI更值得信赖。