AI в юриспруденции: анализ документов, Legal AI

Сделай структурированное резюме этого договора: стороны, предмет, ключевые финансовые условия,
срок, условия расторжения, ответственность сторон, подсудность.
Выдели жирным всё нестандартное или потенциально рискованное для [сторона X].
[текст договора]

Проанализируй п. [X.X] этого договора. Насколько типична такая формулировка
для [тип договора]? Какие риски она создаёт для [сторона]?
Предложи 2-3 альтернативных формулировки от умеренной до строгой позиции.
[пункт договора]

Составь чеклист документов для due diligence при покупке 100% доли в российском ООО,
ведущем деятельность в сфере [отрасль]. Организуй по разделам: корпоративные документы,
договорная база, судебные дела, интеллектуальная собственность, налоги, трудовые отношения.

Объясни простым языком, как работает ст. 333 ГК РФ (снижение неустойки судом).
Какие условия нужны для применения? Какова текущая практика арбитражных судов?
Ответь как опытный процессуалист, объясняющий клиенту.

┌─────────────────────────────────────────────────────────────────┐
│                    Legal AI Pipeline                             │
│                                                                  │
│  ┌──────────────┐   ┌─────────────────┐   ┌──────────────────┐  │
│  │  Документ    │──▶│ Document Parser  │──▶│  Chunking +      │  │
│  │  (PDF/DOCX)  │   │ (PyMuPDF/        │   │  Embedding       │  │
│  └──────────────┘   │  python-docx)    │   │  (text-emb-3)    │  │
│                     └─────────────────┘   └────────┬─────────┘  │
│                                                    │             │
│  ┌──────────────┐   ┌─────────────────┐   ┌────────▼─────────┐  │
│  │  Запрос      │──▶│ Legal RAG:       │──▶│  LLM (Claude /   │  │
│  │  юриста      │   │ retrieve docs   │   │  GPT-4) + prompt │  │
│  └──────────────┘   │ from vector DB  │   └────────┬─────────┘  │
│                     └─────────────────┘            │            │
│                                                    │             │
│  ┌─────────────────────────────────────────────────▼──────────┐  │
│  │  Citation Verifier: каждая ссылка проверяется по базе     │  │
│  │  Если не найдена — убрать из ответа или пометить [!]      │  │
│  └────────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

import re
from pathlib import Path
import pymupdf  # PyMuPDF
from docx import Document


def parse_legal_document(file_path: str) -> dict:
    """
    Parse legal document (PDF or DOCX) into structured sections.
    Returns dict with metadata and text chunks.
    """
    path = Path(file_path)
    suffix = path.suffix.lower()

    if suffix == ".pdf":
        text = _parse_pdf(str(path))
    elif suffix in (".docx", ".doc"):
        text = _parse_docx(str(path))
    else:
        raise ValueError(f"Unsupported format: {suffix}")

    return {
        "filename": path.name,
        "full_text": text,
        "sections": _extract_sections(text),
        "clauses": _extract_numbered_clauses(text),
        "parties": _extract_parties(text),
        "dates": _extract_dates(text),
    }


def _parse_pdf(path: str) -> str:
    doc = pymupdf.open(path)
    return "\n".join(page.get_text() for page in doc)


def _parse_docx(path: str) -> str:
    doc = Document(path)
    return "\n".join(p.text for p in doc.paragraphs if p.text.strip())


def _extract_sections(text: str) -> list[dict]:
    """Extract numbered sections from contract."""
    # Match patterns like "1. ", "1.1 ", "Article 1.", "Раздел 1."
    pattern = r"(?:^|\n)((?:Article|Раздел|Статья|Section)?\s*\d+(?:\.\d+)*\.?\s+[А-ЯA-Z][^\n]{10,80})"
    matches = re.findall(pattern, text, re.MULTILINE)
    return [{"heading": m.strip()} for m in matches]


def _extract_numbered_clauses(text: str) -> dict[str, str]:
    """
    Extract individual numbered clauses for targeted analysis.
    e.g. {"8.3": "Поставщик вправе изменить цену..."}
    """
    clauses = {}
    # Match "8.3. Text of clause until next numbered item or blank line"
    pattern = r"(\d+\.\d+)[\.\s]+([^\n]+(?:\n(?!\d+\.\d+)[^\n]+)*)"
    for match in re.finditer(pattern, text):
        clause_num = match.group(1)
        clause_text = re.sub(r"\s+", " ", match.group(2)).strip()
        clauses[clause_num] = clause_text
    return clauses


def _extract_parties(text: str) -> list[str]:
    """Extract party names from contract preamble."""
    # Russian legal entities: ООО, АО, ПАО, ИП
    pattern = r"(?:ООО|АО|ПАО|ЗАО|ИП)\s+[«"]([^»"]+)[»"]"
    return list(set(re.findall(pattern, text)))


def _extract_dates(text: str) -> list[str]:
    """Extract dates in Russian format."""
    pattern = r"\d{1,2}\s+(?:января|февраля|марта|апреля|мая|июня|июля|августа|сентября|октября|ноября|декабря)\s+\d{4}\s+г(?:ода)?\."
    return re.findall(pattern, text, re.IGNORECASE)

import anthropic
import json

client = anthropic.Anthropic()

CONTRACT_ANALYSIS_PROMPT = """Ты опытный корпоративный юрист. Проанализируй договор и верни структурированный JSON.

ВАЖНО:
- Цитируй конкретные пункты договора при выявлении рисков
- Не добавляй информацию, которой нет в тексте
- Отмечай RISK_HIGH / RISK_MEDIUM / RISK_LOW для каждого риска

Анализируемый договор:
{contract_text}

Верни строго JSON без пояснений:
{{
  "contract_type": "тип договора",
  "parties": [{{"role": "...", "name": "..."}}],
  "subject": "предмет договора",
  "key_terms": {{
    "price": "...",
    "payment_terms": "...",
    "duration": "...",
    "termination": "..."
  }},
  "risks": [
    {{
      "level": "RISK_HIGH|RISK_MEDIUM|RISK_LOW",
      "clause": "номер пункта",
      "description": "описание риска",
      "recommendation": "рекомендация"
    }}
  ],
  "missing_standard_clauses": ["..."],
  "summary": "краткое резюме на 2-3 предложения"
}}"""


def analyze_contract(
    contract_text: str,
    client_side: str = "покупатель",  # с чьей позиции анализировать
) -> dict:
    """
    Analyze contract and return structured risk assessment.

    Args:
        contract_text: Full text of the contract
        client_side: Whose perspective to analyze from

    Returns:
        Structured dict with risks and recommendations
    """
    # Trim to avoid hitting context limits (keep first 100k chars)
    text = contract_text[:100_000]

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        system=f"Анализируй договор с позиции: {client_side}",
        messages=[{
            "role": "user",
            "content": CONTRACT_ANALYSIS_PROMPT.format(contract_text=text),
        }],
    )

    raw = response.content[0].text
    # Extract JSON from response (model may add commentary)
    start = raw.index("{")
    end = raw.rindex("}") + 1
    result = json.loads(raw[start:end])

    # Sort risks by level
    level_order = {"RISK_HIGH": 0, "RISK_MEDIUM": 1, "RISK_LOW": 2}
    result["risks"].sort(key=lambda r: level_order.get(r.get("level", "RISK_LOW"), 3))

    return result

import httpx
import re


# Паттерны для распознавания ссылок на судебные решения
CITATION_PATTERNS = {
    "ru_arbitration": r"(?:дело\s+)?[АА]\d{2}-\d{4,5}/\d{4}",        # А40-12345/2023
    "ru_court": r"\d{2}-\d{4,5}/\d{4}",                               # 77-12345/2023
    "us_federal": r"\d+\s+[A-Z][a-z]+\.?\s+\d+\s+\(\w+\.?\s+\d{4}\)", # 123 F.3d 456 (9th Cir. 2020)
    "echr": r"[A-Z][a-z]+\s+v\.\s+[A-Z][a-z]+,?\s+(?:App\. No\.|№)\s*\d+",
}


def extract_citations(text: str) -> list[dict]:
    """Extract all legal citations from text."""
    citations = []
    for citation_type, pattern in CITATION_PATTERNS.items():
        for match in re.finditer(pattern, text):
            citations.append({
                "text": match.group(),
                "type": citation_type,
                "position": match.start(),
                "verified": None,  # to be filled by verifier
            })
    return citations


async def verify_ru_citation(case_number: str) -> dict:
    """
    Verify Russian court decision via GAS Pravosudie API.
    Returns verification result with case details if found.
    """
    # ГАС «Правосудие» — официальная база решений судов РФ
    # В реальном продукте: интеграция с API kad.arbitr.ru (арбитраж)
    # или bsr.arbitr.ru (банк судебных решений)
    base_url = "https://kad.arbitr.ru/api/search"

    async with httpx.AsyncClient(timeout=10.0) as http:
        try:
            resp = await http.get(
                base_url,
                params={"number": case_number},
                headers={"User-Agent": "LegalAI-CitationVerifier/1.0"},
            )
            if resp.status_code == 200:
                data = resp.json()
                found = bool(data.get("items"))
                return {
                    "citation": case_number,
                    "verified": found,
                    "source": "kad.arbitr.ru",
                    "details": data.get("items", [{}])[0] if found else None,
                }
        except httpx.RequestError:
            pass

    return {"citation": case_number, "verified": None, "source": "error", "details": None}


def flag_unverified_citations(
    ai_response: str,
    verified_citations: list[dict],
) -> str:
    """
    Add [UNVERIFIED] flag to citations that couldn't be confirmed.
    Critical safety feature for legal AI outputs.
    """
    result = ai_response
    for citation in verified_citations:
        if citation["verified"] is False:
            result = result.replace(
                citation["text"],
                f"{citation['text']} [⚠ НЕ НАЙДЕНО В БАЗЕ — ПРОВЕРИТЬ ВРУЧНУЮ]",
            )
        elif citation["verified"] is None:
            result = result.replace(
                citation["text"],
                f"{citation['text']} [? ВЕРИФИКАЦИЯ НЕДОСТУПНА]",
            )
    return result

from openai import OpenAI
import hashlib
from datetime import datetime

oai = OpenAI()

LEGAL_DOCUMENT_TYPES = [
    "federal_law",         # Федеральный закон
    "civil_code",          # Гражданский кодекс
    "arbitration_case",    # Арбитражное дело
    "court_decision",      # Решение суда общей юрисдикции
    "plenum_resolution",   # Постановление Пленума ВС/ВАС
    "contract_template",   # Шаблон договора
    "legal_commentary",    # Комментарий к законодательству
]


def embed_legal_document(
    text: str,
    doc_type: str,
    jurisdiction: str,       # RU, US, EU
    effective_date: str,     # дата вступления в силу
    source_url: str,
    vector_store,            # Qdrant / pgvector
) -> str:
    """
    Index legal document with metadata critical for legal RAG.
    Metadata determines whether a document is relevant and current.
    """
    if doc_type not in LEGAL_DOCUMENT_TYPES:
        raise ValueError(f"Unknown doc_type: {doc_type}")

    # Chunk legal documents by article/section, not by token count
    # Splitting mid-clause destroys legal meaning
    chunks = _chunk_by_legal_structure(text)

    doc_id = hashlib.sha256(f"{source_url}{effective_date}".encode()).hexdigest()[:16]

    for i, chunk in enumerate(chunks):
        embedding = oai.embeddings.create(
            model="text-embedding-3-large",
            input=chunk,
        ).data[0].embedding

        vector_store.upsert(
            collection_name="legal_knowledge",
            points=[{
                "id": f"{doc_id}_{i}",
                "vector": embedding,
                "payload": {
                    "text": chunk,
                    "doc_type": doc_type,
                    "jurisdiction": jurisdiction,
                    "effective_date": effective_date,
                    "source_url": source_url,
                    "indexed_at": datetime.utcnow().isoformat(),
                    "chunk_index": i,
                    "doc_id": doc_id,
                },
            }],
        )

    return doc_id


def _chunk_by_legal_structure(text: str) -> list[str]:
    """
    Chunk legal text by articles/clauses, not by token count.
    A legal clause must not be split across chunks — it loses meaning.
    """
    # Split on numbered articles (1., 1.1., Article 1., Статья 1.)
    pattern = r"(?=(?:Статья|Article|§)\s+\d+|\n\s*\d+\.\s+[А-ЯA-Z])"
    parts = re.split(pattern, text)
    # Filter empty, keep chunks of reasonable size
    return [p.strip() for p in parts if len(p.strip()) > 50]


def retrieve_legal_context(
    query: str,
    jurisdiction: str,
    doc_types: list[str],
    vector_store,
    top_k: int = 6,
) -> list[dict]:
    """
    Retrieve relevant legal documents with jurisdiction and recency filters.
    """
    query_embedding = oai.embeddings.create(
        model="text-embedding-3-large",
        input=query,
    ).data[0].embedding

    results = vector_store.search(
        collection_name="legal_knowledge",
        query_vector=query_embedding,
        query_filter={
            "jurisdiction": {"$in": [jurisdiction]},
            "doc_type": {"$in": doc_types},
        },
        limit=top_k,
    )

    return [
        {
            "text": r.payload["text"],
            "doc_type": r.payload["doc_type"],
            "source_url": r.payload["source_url"],
            "effective_date": r.payload["effective_date"],
            "score": r.score,
        }
        for r in results
    ]

from dataclasses import dataclass, field


@dataclass
class LegalAIEvalResult:
    """Метрики качества юридического AI-ответа."""

    # Фактическая точность
    citation_accuracy: float = 0.0       # доля верифицированных ссылок
    hallucinated_citations: int = 0      # количество фиктивных ссылок
    legal_accuracy: float = 0.0          # точность правовых утверждений (ручная оценка)

    # Качество анализа
    risk_recall: float = 0.0             # доля реальных рисков, обнаруженных AI
    risk_precision: float = 0.0          # доля AI-рисков, подтверждённых юристом
    missed_critical_risks: int = 0       # пропущенные критические риски

    # Форматирование и полезность
    structure_score: float = 0.0         # 1-5: структурированность ответа
    actionability_score: float = 0.0     # 1-5: насколько ответ применим на практике

    notes: list[str] = field(default_factory=list)

    @property
    def is_safe_for_production(self) -> bool:
        """
        Минимальные условия для Production: нет фиктивных ссылок,
        нет пропущенных критических рисков, accuracy > 0.9.
        """
        return (
            self.hallucinated_citations == 0
            and self.missed_critical_risks == 0
            and self.legal_accuracy >= 0.9
        )