法律行业AI Agent应用：合同审查与案例分析的智能化工具

关键词：AI Agent、法律科技、合同审查、案例分析、智能合约、自然语言处理、法律知识图谱

摘要

在当今数字化转型的浪潮中，法律行业正经历着前所未有的变革。本文将深入探讨AI Agent在法律领域的创新应用，特别是在合同审查与案例分析方面的突破性进展。我们将从技术原理、实现方法到实际应用，全方位解析这些智能化工具如何革新传统法律工作流程，提高效率，降低成本。通过生动的比喻、详细的代码示例和实用的案例分析，本文将帮助读者理解AI Agent在法律行业的工作机制、应用价值和未来发展趋势。

---

1. 背景介绍

核心概念

在深入探讨主题之前，让我们先明确几个核心概念。AI Agent（人工智能代理）是一种能够感知环境、做出决策并执行行动的智能系统。在法律领域，这些Agent被训练来处理复杂的法律文档、分析案例和提供法律见解。合同审查是法律工作中的基础但耗时的工作，涉及检查合同条款的合规性、风险点和一致性。案例分析则是通过研究过去的判例来预测法律结果或支持法律论点。

问题背景

法律行业长期以来一直以其专业性和复杂性著称。传统上，合同审查和案例分析需要律师花费大量时间手动阅读和分析文档。一份复杂的商业合同可能有数百页，包含无数条款和条件，需要律师逐字逐句地检查，以确保没有隐藏的风险或不利条款。同样，案例研究需要律师查阅大量的判例法，寻找相关的先例来支持他们的论点。

这种传统工作方式存在几个显著问题：

1. 时间成本高：简单的合同审查可能需要数小时，复杂的交易可能需要数天甚至数周。
2. 人力成本昂贵：律师费用高昂，使得法律服务对许多人和小企业来说遥不可及。
3. 人为错误风险：即使是最细心的律师也可能在冗长的文档中遗漏关键细节。
4. 知识管理困难：法律知识分散在大量文档中，难以系统化地检索和应用。

问题描述

让我们更具体地描述这些问题。在合同审查场景中，律师通常需要：

• 识别合同中的关键条款（如赔偿条款、终止条款、知识产权条款等）
• 检查这些条款是否符合法律法规和公司政策
• 发现潜在的法律风险和不利条款
• 确保合同的一致性和完整性
• 提供修改建议和风险评估

在案例分析场景中，律师需要：

• 搜索相关的判例法和司法解释
• 分析案例的关键事实和法律推理
• 比较先例与当前案例的相似性和差异
• 预测可能的法律结果
• 构建法律论点和策略

这些任务都需要高度的专业知识和大量的时间投入。对于小型律师事务所和企业法律部门来说，资源限制使得这些工作尤其具有挑战性。

问题解决

AI Agent的出现为解决这些问题提供了革命性的方案。通过结合自然语言处理(NLP)、机器学习(ML)、知识图谱(KG)和其他AI技术，我们可以创建智能系统来自动化和增强这些法律任务。

这些AI Agent可以：

• 在几分钟内审查完冗长的合同，而不是几小时或几天
• 持续监控法律法规的变化，确保审查标准的更新
• 系统化地组织和检索法律知识，提高工作效率
• 减少人为错误，提高工作质量
• 降低法律服务成本，使更多人能够获得专业的法律支持

在本文中，我们将深入探讨这些AI Agent是如何工作的，如何构建它们，以及如何在实际法律工作中应用它们。

边界与外延

在我们开始之前，明确AI Agent在法律领域的应用边界非常重要。虽然AI技术在法律领域的应用前景广阔，但它们并不能完全取代律师。相反，这些工具应该被视为律师的"智能助手"，帮助他们更高效地完成工作，让他们有更多时间专注于需要人类判断、策略思考和客户关系的高级法律工作。

此外，法律AI Agent的应用也面临着一些特殊的挑战，如法律推理的复杂性、法律文本的模糊性、法律实践的地域差异等。我们需要充分理解这些挑战，才能开发出真正有用的法律AI工具。

---

2. 核心概念解析

概念结构与核心要素组成

在深入探讨法律AI Agent的技术细节之前，让我们首先解析其核心概念和结构。一个典型的法律AI Agent由以下几个核心要素组成：

1. 感知模块：负责理解和处理法律文本，包括合同、判决书、法规等。
2. 知识表示模块：将法律知识结构化，如法律概念、规则、案例等。
3. 推理引擎：基于结构化的法律知识进行逻辑推理和决策。
4. 交互界面：使律师能够与AI Agent进行有效沟通和协作。
5. 学习模块：通过持续学习新的法律案例和法规更新AI Agent的知识库。

让我们用一个生活化的比喻来理解这些概念。你可以把法律AI Agent想象成一个超级智能的律师助理。这个助理：

• 感知模块相当于它的眼睛和耳朵，能够阅读和理解复杂的法律文件。
• 知识表示模块相当于它的大脑，存储着结构化的法律知识。
• 推理引擎相当于它的思维能力，能够基于法律知识进行分析和推理。
• 交互界面相当于它的沟通能力，能够听取你的指令并以自然的方式反馈结果。
• 学习模块相当于它的学习能力，能够从新的经验中不断成长和进步。

概念之间的关系

为了更好地理解这些核心概念之间的关系，让我们通过以下表格进行对比：

概念名称	核心功能	关键技术	主要输入	主要输出	与其他概念的关系
感知模块	理解和处理法律文本	NLP, OCR, 文本分类	原始法律文档	结构化文本数据	为知识表示模块提供输入
知识表示模块	存储和组织法律知识	知识图谱, 本体论	结构化文本, 专家知识	结构化法律知识库	为推理引擎提供知识基础
推理引擎	法律逻辑推理和决策	规则引擎, 机器学习, 案例推理	知识库, 用户查询	分析结果, 建议	基于知识表示模块的输出工作
交互界面	用户与系统的交互	自然语言界面, 可视化	用户输入	可视化结果, 报告	连接用户与其他模块
学习模块	持续更新和优化系统	持续学习, 反馈循环	用户反馈, 新案例, 新法规	更新后的模型和知识库	优化所有其他模块

接下来，让我们通过ER实体关系图来可视化这些概念之间的关系：

最后，让我们通过交互关系图来展示这些模块如何协同工作：

---

3. 技术原理与实现

数学模型

在法律AI Agent的实现中，我们需要利用多种数学模型来处理和分析法律文本。以下是一些核心的数学模型：

1. 文本向量化模型：
   使用词嵌入(Word Embedding)技术将法律文本转换为数值向量，以便计算机能够处理。最常用的方法是Word2Vec和BERT。

   Word2Vec的核心思想可以用以下数学公式表示：

   $$P(w_t|w_{t-k},...,w_{t-1},w_{t+1},...,w_{t+k})=\frac{\exp (v_{w_t}^T{v}_{w_c}^{\prime })}{{\sum }_{w=1}^V\exp (v_w^T{v}_{w_c}^{\prime })}$$

   其中，$w_t$是目标词，$w_c$是上下文词，$v_w$和$v_w^{\prime }$是词$w$的输入和输出向量表示，$V$是词汇表大小。

2. 文本分类模型：
   用于识别合同中的不同类型条款。我们可以使用逻辑回归、支持向量机(SVM)或深度学习模型。

   逻辑回归的数学表示为：

   $$P(y=1|x)=\frac{1}{1+\exp (-({\beta }_0+{\beta }_1{x}_1+...+{\beta }_n{x}_n))}$$

   其中，$x$是输入特征向量，$\beta$是模型参数，$y$是类别标签。

3. 相似度计算模型：
   用于比较案例之间的相似性。常用的方法有余弦相似度和Jaccard相似度。

   余弦相似度的计算公式为：

   $$\text{similarity}(A,B)=\frac{A\cdot B}{\Vert A\Vert \Vert B\Vert }=\frac{{\sum }_{i=1}^n{A}_i{B}_i}{\sqrt{{\sum }_{i=1}^n{A}_i^2}\sqrt{{\sum }_{i=1}^n{B}_i^2}}$$

   其中，$A$和$B$是两个向量，表示我们要比较的两个法律文本。

算法流程图

现在，让我们通过流程图来展示合同审查AI Agent的工作流程：

对于案例分析AI Agent，其工作流程如下：

算法源代码

接下来，让我们通过Python代码示例来展示如何实现一个简化版的合同审查AI Agent。我们将使用Python的常用库，如NLTK、scikit-learn和Gensim。

首先，我们需要安装必要的库：

!pip install nltk scikit-learn gensim python-docx PyPDF2

接下来，让我们实现一个基础的合同审查系统：

import re
import nltk
import PyPDF2
from docx import Document
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
from gensim.models import Word2Vec
from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords

# 下载必要的NLTK资源
nltk.download('punkt')
nltk.download('stopwords')

class ContractReviewAgent:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        self.high_risk_clauses = [
            "indemnification", "limitation of liability", "termination for convenience",
            "intellectual property assignment", "non-compete", "governing law"
        ]
        self.tfidf_vectorizer = TfidfVectorizer(stop_words='english')
        self.clause_classifier = None  # 实际应用中会有训练好的分类器
    
    def extract_text_from_pdf(self, pdf_path):
        """从PDF文件中提取文本"""
        text = ""
        with open(pdf_path, 'rb') as file:
            reader = PyPDF2.PdfReader(file)
            for page in reader.pages:
                text += page.extract_text()
        return text
    
    def extract_text_from_docx(self, docx_path):
        """从Word文档中提取文本"""
        doc = Document(docx_path)
        return '\n'.join([paragraph.text for paragraph in doc.paragraphs])
    
    def preprocess_text(self, text):
        """预处理文本，包括分词、去停用词等"""
        # 分句
        sentences = sent_tokenize(text)
        
        # 分词和预处理
        processed_sentences = []
        for sentence in sentences:
            words = word_tokenize(sentence.lower())
            words = [word for word in words if word.isalpha() and word not in self.stop_words]
            processed_sentences.append(words)
        
        return processed_sentences, sentences
    
    def identify_clauses(self, text):
        """识别合同中的关键条款"""
        # 在实际系统中，这部分会使用更复杂的命名实体识别和文本分类
        identified_clauses = {}
        
        for clause_type in self.high_risk_clauses:
            # 使用正则表达式查找相关条款
            pattern = re.compile(r'({}.*?)(?=\n[A-Z][a-z]+:|\n\d+\.|\Z)'.format(clause_type), re.IGNORECASE | re.DOTALL)
            matches = pattern.findall(text)
            
            if matches:
                identified_clauses[clause_type] = matches
        
        return identified_clauses
    
    def assess_risk(self, clause_text, clause_type):
        """评估条款风险"""
        # 简化的风险评估 - 实际系统中会有更复杂的模型
        risk_score = 0
        risk_indicators = {
            "indemnification": ["unlimited", "shall indemnify", "hold harmless", "defend"],
            "limitation of liability": ["exclusion of consequential damages", "no liability", "maximum liability"],
            "termination for convenience": ["terminate at will", "without cause", "immediate termination"]
        }
        
        if clause_type in risk_indicators:
            for indicator in risk_indicators[clause_type]:
                if indicator.lower() in clause_text.lower():
                    risk_score += 1
        
        # 返回风险等级
        if risk_score >= 3:
            return "High", risk_score
        elif risk_score >= 1:
            return "Medium", risk_score
        else:
            return "Low", risk_score
    
    def review_contract(self, file_path):
        """审查合同的主要流程"""
        # 根据文件类型提取文本
        if file_path.endswith('.pdf'):
            text = self.extract_text_from_pdf(file_path)
        elif file_path.endswith('.docx'):
            text = self.extract_text_from_docx(file_path)
        else:  # 假设是纯文本文件
            with open(file_path, 'r') as file:
                text = file.read()
        
        # 识别关键条款
        clauses = self.identify_clauses(text)
        
        # 评估风险
        risk_assessment = {}
        for clause_type, clause_texts in clauses.items():
            risk_assessment[clause_type] = []
            for i, clause_text in enumerate(clause_texts):
                risk_level, risk_score = self.assess_risk(clause_text, clause_type)
                risk_assessment[clause_type].append({
                    "text": clause_text,
                    "risk_level": risk_level,
                    "risk_score": risk_score
                })
        
        # 生成报告
        report = self.generate_report(risk_assessment)
        
        return report
    
    def generate_report(self, risk_assessment):
        """生成审查报告"""
        report = "合同审查报告\n"
        report += "=" * 50 + "\n\n"
        
        high_risk_count = 0
        medium_risk_count = 0
        
        for clause_type, assessments in risk_assessment.items():
            report += f"{clause_type.upper()} 条款:\n"
            report += "-" * 40 + "\n"
            
            for i, assessment in enumerate(assessments):
                report += f"实例 {i+1}:\n"
                report += f"风险等级: {assessment['risk_level']} (分数: {assessment['risk_score']})\n"
                report += f"条款内容: {assessment['text'][:200]}...\n\n"  # 只显示前200个字符
                
                if assessment['risk_level'] == "High":
                    high_risk_count += 1
                elif assessment['risk_level'] == "Medium":
                    medium_risk_count += 1
        
        report += "=" * 50 + "\n"
        report += f"摘要: 发现 {high_risk_count} 个高风险条款，{medium_risk_count} 个中风险条款。\n"
        
        return report


class CaseAnalysisAgent:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        # 在实际系统中，这里会有一个大型案例数据库
        self.case_database = []
    
    def add_case_to_database(self, case_text, case_metadata):
        """向案例数据库添加案例"""
        # 预处理案例文本
        processed_text = self.preprocess_text(case_text)
        self.case_database.append({
            "text": case_text,
            "processed_text": processed_text,
            "metadata": case_metadata
        })
    
    def preprocess_text(self, text):
        """预处理文本"""
        words = word_tokenize(text.lower())
        words = [word for word in words if word.isalpha() and word not in self.stop_words]
        return words
    
    def find_similar_cases(self, query_case, top_n=5):
        """查找相似案例"""
        if not self.case_database:
            return []
        
        # 预处理查询案例
        processed_query = self.preprocess_text(query_case)
        
        # 计算相似度
        # 在实际系统中，会使用更复杂的语义相似度计算方法
        similarities = []
        
        # 为演示目的，我们使用简单的词重叠相似度
        for i, case in enumerate(self.case_database):
            overlap = len(set(processed_query) & set(case["processed_text"]))
            union = len(set(processed_query) | set(case["processed_text"]))
            jaccard = overlap / union if union > 0 else 0
            similarities.append((i, jaccard))
        
        # 排序并返回前top_n个案例
        similarities.sort(key=lambda x: x[1], reverse=True)
        similar_cases = [(self.case_database[i], score) for i, score in similarities[:top_n]]
        
        return similar_cases
    
    def analyze_case(self, query_case):
        """分析案例并提供见解"""
        # 查找相似案例
        similar_cases = self.find_similar_cases(query_case)
        
        # 生成分析报告
        report = "案例分析报告\n"
        report += "=" * 50 + "\n\n"
        report += "当前案例摘要:\n"
        report += query_case[:300] + "...\n\n"
        
        if similar_cases:
            report += "发现的相关案例:\n"
            report += "-" * 40 + "\n"
            
            for i, (case, score) in enumerate(similar_cases):
                report += f"案例 {i+1} (相似度: {score:.2f}):\n"
                report += f"标题: {case['metadata'].get('title', 'Unknown')}\n"
                report += f"法院: {case['metadata'].get('court', 'Unknown')}\n"
                report += f"日期: {case['metadata'].get('date', 'Unknown')}\n"
                report += f"判决结果: {case['metadata'].get('outcome', 'Unknown')}\n"
                report += f"案例摘要: {case['text'][:200]}...\n\n"
        else:
            report += "没有找到相似的案例。\n"
        
        return report


# 使用示例
if __name__ == "__main__":
    # 创建合同审查代理
    contract_agent = ContractReviewAgent()
    
    # 审查示例合同（实际应用中替换为真实文件路径）
    # report = contract_agent.review_contract("sample_contract.pdf")
    # print(report)
    
    # 创建案例分析代理
    case_agent = CaseAnalysisAgent()
    
    # 添加一些示例案例到数据库（实际应用中会有大量真实案例）
    sample_case = {
        "text": "这是一个关于合同违约的案例...",
        "metadata": {
            "title": "Smith v. Jones",
            "court": "Supreme Court",
            "date": "2022-01-15",
            "outcome": "Plaintiff wins"
        }
    }
    
    case_agent.add_case_to_database(sample_case["text"], sample_case["metadata"])
    
    # 分析一个新案例
    query = "我们有一个关于合同违约的新案例，涉及..."
    analysis = case_agent.analyze_case(query)
    print(analysis)

这个简化的代码示例展示了合同审查和案例分析AI Agent的基本工作原理。在实际应用中，我们会使用更先进的模型和技术，如BERT等预训练语言模型，以及更复杂的法律知识库和推理机制。

---

4. 实际应用

项目介绍

让我们通过一个真实的法律AI应用项目来展示这些技术的实际应用。我们将介绍"LawTech Pro"——一个集成合同审查和案例分析功能的AI驱动法律平台。

LawTech Pro是为中小企业和小型律师事务所设计的，旨在使高端法律技术民主化。该平台提供两个主要功能模块：

1. ContractGuard：智能合同审查工具
2. CaseConnect：案例分析和法律研究工具

环境安装

要部署和运行LawTech Pro，需要以下环境：

1. 硬件要求：

   • CPU：8核或更高
   • 内存：32GB或更高
   • 存储：100GB或更高（用于存储法律文档和案例数据库）
   • GPU：可选，但推荐用于加速深度学习模型

2. 软件环境：

   • 操作系统：Ubuntu 20.04 LTS或更高版本
   • Python：3.8或更高版本
   • 数据库：PostgreSQL 13或更高版本，用于存储文档元数据
   • 向量数据库：Pinecone或Weaviate，用于高效的相似性搜索
   • Web框架：FastAPI用于后端API，React用于前端界面

3. 安装步骤：

   # 1. 克隆项目仓库
   git clone https://github.com/lawtech-pro/lawtech-platform.git
   cd lawtech-platform
   
   # 2. 创建虚拟环境
   python -m venv lawtech-env
   source lawtech-env/bin/activate
   
   # 3. 安装依赖
   pip install -r requirements.txt
   
   # 4. 设置环境变量
   cp .env.example .env
   # 编辑.env文件，设置数据库连接等配置
   
   # 5. 设置数据库
   python scripts/setup_database.py
   
   # 6. 下载预训练模型
   python scripts/download_models.py
   
   # 7. 启动服务
   python main.py
   

系统功能设计

LawTech Pro的核心功能设计如下：

1. ContractGuard - 智能合同审查模块：

   • 合同解析：支持PDF、Word、纯文本等多种格式
   • 条款识别：自动识别合同中的关键条款
   • 风险评估：对每个条款进行风险评分和分类
   • 合规检查：检查合同条款是否符合相关法律法规
   • 修改建议：提供具体的条款修改建议
   • 审查报告：生成结构化、可定制的审查报告

2. CaseConnect - 案例分析模块：

   • 案例检索：基于语义相似度查找相关案例
   • 案例比较：可视化比较当前案例与先例的异同
   • 结果预测：基于历史案例预测可能的法律结果
   • 论点构建：帮助构建法律论点和策略
   • 法律更新：跟踪最新的判例法和法规变化
   • 研究报告：生成案例研究和法律分析报告

3. 协作与管理功能：

   • 团队协作：支持多人同时审查和讨论
   • 版本控制：跟踪合同和案例分析的版本历史
   • 模板库：提供常用合同和法律文档模板
   • 分析仪表板：提供工作效率和风险分析报告
   • 集成API：支持与现有法律管理系统集成

系统架构设计

LawTech Pro采用微服务架构设计，以便于扩展和维护。系统架构图如下：

系统接口设计

LawTech Pro提供了丰富的RESTful API接口，以便与其他系统集成。以下是一些核心接口的设计：

1. 合同审查接口：

   POST /api/v1/contract/review
   请求体：
   {
     "file_url": "https://example.com/contract.pdf",
     "options": {
       "risk_assessment": true,
       "compliance_check": true,
       "suggest_revisions": true
     }
   }
   
   响应：
   {
     "status": "success",
     "review_id": "cont-123456",
     "results": {
       "summary": {...},
       "clauses": [...],
       "risks": [...],
       "suggestions": [...]
     }
   }
   

2. 案例检索接口：

   POST /api/v1/cases/search
   请求体：
   {
     "query": "合同违约案例，涉及延迟交付和损害赔偿",
     "filters": {
       "jurisdiction": "US-CA",
       "date_range": ["2018-01-01", "2023-01-01"],
       "court_level": "appellate"
     },
     "limit": 10
   }
   
   响应：
   {
     "status": "success",
     "total": 42,
     "cases": [
       {
         "id": "case-78901",
         "title": "ABC Corp v. XYZ Inc",
         "similarity": 0.89,
         "citation": "123 Cal. App. 4th 567",
         "summary": "...",
         "key_issues": ["Breach of Contract", "Damages"],
         "holding": "..."
       },
       ...
     ]
   }
   

3. 状态查询接口：

   GET /api/v1/tasks/{task_id}
   
   响应：
   {
     "task_id": "task-123456",
     "type": "contract_review",
     "status": "completed",
     "created_at": "2023-05-15T10:30:00Z",
     "completed_at": "2023-05-15T10:32:15Z",
     "result_url": "/api/v1/results/task-123456"
   }
   

系统核心实现源代码

现在，让我们查看LawTech Pro系统中的一些核心实现代码。我们将展示ContractGuard模块的关键部分，以及CaseConnect模块中的案例相似度计算部分。

# app/services/contract_review_service.py
from typing import Dict, List, Any
from app.models.contract import Contract, Clause, Risk
from app.utils.nlp_processor import NLPProcessor
from app.utils.knowledge_base import LegalKnowledgeBase
from app.utils.risk_assessor import RiskAssessor
import logging

logger = logging.getLogger(__name__)

class ContractReviewService:
    def __init__(self):
        self.nlp_processor = NLPProcessor()
        self.knowledge_base = LegalKnowledgeBase()
        self.risk_assessor = RiskAssessor()
    
    def review_contract(self, contract: Contract, options: Dict[str, bool]) -> Dict[str, Any]:
        """完整的合同审查流程"""
        logger.info(f"开始审查合同: {contract.id}")
        
        try:
            # 步骤1: 解析和预处理合同文本
            processed_text = self.nlp_processor.process_text(contract.content)
            
            # 步骤2: 识别合同条款
            clauses = self._identify_clauses(processed_text)
            
            # 步骤3: 分析每个条款
            results = {
                "summary": {},
                "clauses": [],
                "risks": [],
                "suggestions": []
            }
            
            high_risk_count = 0
            medium_risk_count = 0
            
            for clause in clauses:
                # 分析条款
                clause_analysis = self._analyze_clause(clause, options)
                
                # 添加到结果
                results["clauses"].append(clause_analysis)
                
                # 检查风险
                if clause_analysis.get("risk_level") == "High":
                    high_risk_count += 1
                    results["risks"].append({
                        "clause_id": clause_analysis["id"],
                        "description": clause_analysis["risk_description"],
                        "severity": "High"
                    })
                elif clause_analysis.get("risk_level") == "Medium":
                    medium_risk_count += 1
                    results["risks"].append({
                        "clause_id": clause_analysis["id"],
                        "description": clause_analysis["risk_description"],
                        "severity": "Medium"
                    })
                
                # 添加修改建议
                if options.get("suggest_revisions") and clause_analysis.get("suggestions"):
                    results["suggestions"].extend(clause_analysis["suggestions"])
            
            # 生成摘要
            results["summary"] = {
                "total_clauses": len(clauses),
                "high_risk_clauses": high_risk_count,
                "medium_risk_clauses": medium_risk_count,
                "review_completeness": self._calculate_completeness(clauses)
            }
            
            logger.info(f"合同审查完成: {contract.id}")
            return results
            
        except Exception as e:
            logger.error(f"合同审查出错: {contract.id}, 错误: {str(e)}")
            raise
    
    def _identify_clauses(self, processed_text: Dict[str, Any]) -> List[Clause]:
        """识别合同中的关键条款"""
        clauses = []
        
        # 使用法律知识库中的模式识别条款
        clause_patterns = self.knowledge_base.get_clause_patterns()
        
        for clause_type, patterns in clause_patterns.items():
            for pattern in patterns:
                # 使用正则表达式或语义匹配查找条款
                matches = self.nlp_processor.find_patterns(processed_text, pattern)
                
                for match in matches:
                    clause = Clause(
                        type=clause_type,
                        content=match["text"],
                        location=match["location"],
                        confidence=match["confidence"]
                    )
                    clauses.append(clause)
        
        # 去重和排序
        clauses = self._deduplicate_and_sort_clauses(clauses)
        
        return clauses
    
    def _analyze_clause(self, clause: Clause, options: Dict[str, bool]) -> Dict[str, Any]:
        """分析单个条款"""
        analysis = {
            "id": clause.id,
            "type": clause.type,
            "content": clause.content,
            "risk_level": "Low",
            "risk_description": "",
            "suggestions": []
        }
        
        # 风险评估
        if options.get("risk_assessment"):
            risk_result = self.risk_assessor.assess_clause_risk(clause)
            analysis["risk_level"] = risk_result["level"]
            analysis["risk_description"] = risk_result["description"]
            
            # 如果有风险，获取修改建议
            if options.get("suggest_revisions") and risk_result["level"] != "Low":
                suggestions = self.knowledge_base.get_clause_revisions(
                    clause.type, 
                    risk_result["issues"]
                )
                analysis["suggestions"] = suggestions
        
        # 合规性检查
        if options.get("compliance_check"):
            compliance_issues = self.knowledge_base.check_compliance(clause)
            if compliance_issues:
                # 调整风险等级
                if analysis["risk_level"] == "Low":
                    analysis["risk_level"] = "Medium"
                analysis["compliance_issues"] = compliance_issues
        
        return analysis
    
    def _calculate_completeness(self, clauses: List[Clause]) -> float:
        """计算合同完整性评分"""
        # 获取必要条款列表
        required_clauses = self.knowledge_base.get_required_clauses()
        
        # 检查哪些必要条款存在
        existing_clause_types = set([clause.type for clause in clauses])
        found_required = [clause for clause in required_clauses if clause in existing_clause_types]
        
        # 计算完整性百分比
        completeness = len(found_required) / len(required_clauses) if required_clauses else 1.0
        
        return completeness
    
    def _deduplicate_and_sort_clauses(self, clauses: List[Clause]) -> List[Clause]:
        """条款去重和排序"""
        # 简单实现 - 实际系统中会有更复杂的去重逻辑
        unique_clauses = []
        seen_contents = set()
        
        for clause in clauses:
            # 基于内容的简化哈希去重
            content_hash = hash(clause.content[:100])  # 使用前100个字符的哈希
            if content_hash not in seen_contents:
                seen_contents.add(content_hash)
                unique_clauses.append(clause)
        
        # 按位置排序
        unique_clauses.sort(key=lambda x: x.location["start"])
        
        return unique_clauses


# app/services/case_analysis_service.py
from typing import Dict, List, Any, Tuple
from app.models.case import Case, CaseComparison
from app.utils.nlp_processor import NLPProcessor
from app.utils.vector_database import VectorDatabase
from app.utils.knowledge_base import LegalKnowledgeBase
import logging

logger = logging.getLogger(__name__)

class CaseAnalysisService:
    def __init__(self):
        self.nlp_processor = NLPProcessor()
        self.vector_db = VectorDatabase()
        self.knowledge_base = LegalKnowledgeBase()
    
    def search_similar_cases(self, query: str, filters: Dict[str, Any], limit: int = 10) -> Dict[str, Any]:
        """搜索相似案例"""
        logger.info(f"开始相似案例搜索，查询: {query[:50]}...")
        
        try:
            # 步骤1: 处理查询文本
            query_embedding = self.nlp_processor.get_embedding(query)
            
            # 步骤2: 在向量数据库中搜索相似案例
            similar_cases = self.vector_db.search(
                query_embedding,
                filters=filters,
                limit=limit
            )
            
            # 步骤3: 处理和丰富搜索结果
            enriched_cases = []
            for case, similarity in similar_cases:
                enriched_case = self._enrich_case_result(case, similarity, query)
                enriched_cases.append(enriched_case)
            
            # 步骤4: 生成结果摘要
            summary = self._generate_search_summary(enriched_cases, query)
            
            logger.info(f"相似案例搜索完成，找到 {len(enriched_cases)} 个案例")
            
            return {
                "total": self.vector_db.count(filters),
                "cases": enriched_cases,
                "summary": summary
            }
            
        except Exception as e:
            logger.error(f"相似案例搜索出错: {str(e)}")
            raise
    
    def compare_cases(self, primary_case: Case, comparison_cases: List[Case]) -> CaseComparison:
        """比较多个案例"""
        logger.info(f"开始案例比较，主案例: {primary_case.id}")
        
        try:
            # 步骤1: 提取主案例的关键要素
            primary_features = self._extract_case_features(primary_case)
            
            # 步骤2: 比较每个案例
            comparisons = []
            for case in comparison_cases:
                case_features = self._extract_case_features(case)
                comparison_result = self._compare_features(primary_features, case_features)
                comparisons.append({
                    "case_id": case.id,
                    "comparison": comparison_result
                })
            
            # 步骤3: 生成比较报告
            comparison_report = CaseComparison(
                primary_case_id=primary_case.id,
                comparisons=comparisons,
                key_differences=self._identify_key_differences(comparisons),
                legal_implications=self._extract_legal_implications(primary_features, comparisons)
            )
            
            logger.info(f"案例比较完成")
            return comparison_report
            
        except Exception as e:
            logger.error(f"案例比较出错: {str(e)}")
            raise
    
    def predict_case_outcome(self, case: Case) -> Dict[str, Any]:
        """预测案例结果"""
        logger.info(f"开始案例结果预测，案例: {case.id}")
        
        try:
            # 步骤1: 提取案例特征
            case_features = self._extract_case_features(case)
            
            # 步骤2: 查找最相似的有结果案例
            similar_cases = self.vector_db.search_with_outcomes(
                self.nlp_processor.get_embedding(case.description),
                limit=20
            )
            
            # 步骤3: 基于相似案例预测结果
            outcome_predictions = {}
            for outcome_type in ["liability", "damages", "injunction"]:
                prediction = self._predict_outcome_type(case_features, similar_cases, outcome_type)
                outcome_predictions[outcome_type] = prediction
            
            # 步骤4: 生成综合预测
            overall_confidence = self._calculate_overall_confidence(outcome_predictions)
            
            logger.info(f"案例结果预测完成")
            return {
                "predictions": outcome_predictions,
                "confidence": overall_confidence,
                "supporting_cases": [case.id for case, _ in similar_cases[:5]],
                "key_factors": self._identify_key_factors(case_features, outcome_predictions)
            }
            
        except Exception as e:
            logger.error(f"案例结果预测出错: {str(e)}")
            raise
    
    def _extract_case_features(self, case: Case) -> Dict[str, Any]:
        """提取案例的关键特征"""
        features = {}
        
        # 使用NLP提取关键事实
        facts = self.nlp_processor.extract_facts(case.description)
        features["key_facts"] = facts
        
        # 提取法律问题
        legal_issues = self.nlp_processor.extract_legal_issues(case.description)
        features["legal_issues"] = legal_issues
        
        # 提取当事方类型
        parties = self.nlp_processor.extract_parties(case.description)
        features["parties"] = parties
        
        # 提取管辖信息
        jurisdiction = self.nlp_processor.extract_jurisdiction(case.description)
        features["jurisdiction"] = jurisdiction
        
        # 如果有，添加结果信息
        if hasattr(case, 'outcome') and case.outcome:
            features["outcome"] = case.outcome
        
        return features
    
    def _compare_features(self, primary_features: Dict[str, Any], case_features: Dict[str, Any]) -> Dict[str, Any]:
        """比较两个案例的特征"""
        comparison = {}
        
        # 比较关键事实
        if "key_facts" in primary_features and "key_facts" in case_features:
            fact_similarity = self._calculate_fact_similarity(
                primary_features["key_facts"],
                case_features["key_facts"]
            )
            comparison["fact_similarity"] = fact_similarity
        
        # 比较法律问题
        if "legal_issues" in primary_features and "legal_issues" in case_features:
            issue_similarity = self._calculate_issue_similarity(
                primary_features["legal_issues"],
                case_features["legal_issues"]
            )
            comparison["issue_similarity"] = issue_similarity
        
        # 比较适用法律
        if "legal_issues" in primary_features and "legal_issues" in case_features:
            law_similarity =