חיפוש סמנטי חכם לחוקים: צמצמו את זמן המחקר ב-40%

עורכי דין מבלים שעות בחיפוש אחר נורמות ופסיקה רלוונטיות. חיפוש מילות מפתח סטנדרטי לרוב מפספס מסמכים רלוונטיים אם הניסוח אינו תואם. בנינו מערכת בינה מלאכותית שמבינה את משמעות השאילתה ומוצאת את הסעיפים הנדרשים תוך שניות. המומחיות שלנו ב-RAG ובמודלי שפה מאפשרת לנו לבנות מערכות עם דיוק ציטוטים של 94%.

חיפוש AI מוצא נורמות פי 200 מהר יותר מעיון ידני. חיפוש סמנטי באמצעות embeddings פותר בעיות של מילים נרדפות, ו-RAG מבטיח שתשובות נבנות אך ורק על מסמכים אמיתיים. התוצאה: זמן חיפוש מופחת פי 200, דיוק ציטוטים גבוה פי 2 מפתרונות סטנדרטיים.

כיצד חיפוש AI לחקיקה חוסך זמן לעורכי דין

חיפוש משפטי הוא אחד היישומים החזקים ביותר של RAG: הקורפוס החקיקתי יציב (נורמות משתנות אך לא נעלמות), מסמכים מובנים (סעיפים, חלקים, פסקאות), ודיוק הציטוטים הוא קריטי. AI אינו מפרש את החוק—הוא מחפש, מבנה ובוחר נורמות רלוונטיות לשאלה ספציפית.

from anthropic import Anthropic
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from pydantic import BaseModel
from typing import Optional
import json

client = Anthropic()

class LegalDocument(BaseModel):
    doc_id: str
    title: str
    doc_type: str  # "федеральный_закон", "постановление", "определение_вс"
    number: str  # "149-ФЗ", "А40-12345/2023"
    date: str
    content: str
    articles: list[dict] = []  # [{"article": "ст. 10", "text": "..."}]
    tags: list[str] = []

class LegalSearchResult(BaseModel):
    document: LegalDocument
    relevant_excerpt: str
    article_reference: str  # "Статья 10, ч. 2"
    relevance_score: float
    reasoning: str

class LegalSearchEngine:
    def __init__(self, db_path: str = "./legal_db"):
        self.embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
        self.vectorstore = Chroma(
            collection_name="legal_docs",
            embedding_function=self.embeddings,
            persist_directory=db_path,
        )
        self.splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            separators=["\nСтатья ", "\n\n", "\n", " "],
        )

    def index_document(self, doc: LegalDocument):
        """Индексирует правовой документ"""
        # Разбиваем по статьям для точного цитирования
        chunks = []
        metadatas = []
        for article in doc.articles:
            # Каждая статья = отдельный чанк
            chunk_text = f"{doc.title}\n{article['article']}\n{article['text']}"
            chunks.append(chunk_text)
            metadatas.append({
                "doc_id": doc.doc_id,
                "doc_type": doc.doc_type,
                "title": doc.title,
                "number": doc.number,
                "date": doc.date,
                "article": article["article"],
            })
        if not chunks and doc.content:
            # Если нет разбивки по статьям — делим по тексту
            splits = self.splitter.split_text(doc.content)
            for i, split in enumerate(splits):
                chunks.append(split)
                metadatas.append({
                    "doc_id": doc.doc_id,
                    "doc_type": doc.doc_type,
                    "title": doc.title,
                    "number": doc.number,
                    "date": doc.date,
                    "article": f"часть_{i}",
                })
        self.vectorstore.add_texts(texts=chunks, metadatas=metadatas)

    def search(self, query: str, k: int = 10, filters: dict = None) -> list[dict]:
        """Семантический поиск по правовой базе"""
        where_filter = {}
        if filters:
            if filters.get("doc_type"):
                where_filter["doc_type"] = filters["doc_type"]
            if filters.get("date_from"):
                where_filter["date"] = {"$gte": filters["date_from"]}
        results = self.vectorstore.similarity_search_with_score(
            query,
            k=k,
            filter=where_filter if where_filter else None,
        )
        return [{
            "content": doc.page_content,
            "metadata": doc.metadata,
            "score": score,
        } for doc, score in results]

מדוע RAG מתאים למסמכים משפטיים

RAG (Retrieval-Augmented Generation) פותר את הבעיה המרכזית של LLM—הזיות. במקום ליצור תשובה מזיכרון המודל, המערכת מוצאת תחילה קטעים רלוונטיים במאגר המאונדקס, ואז מעבירה אותם למודל לניתוח. זה נותן ציטוטים מדויקים ומפחית את הסיכון לנורמות מומצאות. לדוגמה, סעיף 81 לחוק העבודה של הפדרציה הרוסית מגדיר בבירור היעדרות—המערכת מוצאת אותו אפילו לפי תיאור מצב.

אנו משתמשים בחיפוש היברידי: סמנטי (embeddings) בתוספת מסננים בוליאניים לפי סוג מסמך, תאריך, מספר סעיף. מסד הנתונים הווקטורי Chroma או Qdrant מאחסן embeddings ממדיים 1536, ו-RecursiveCharacterTextSplitter מפצל מסמכים לאורך גבולות סעיפים.

כיצד חיפוש סמנטי עולה על המסורתי

חיפוש סמנטי לא רק מוצא התאמות מדויקות—הוא מבין הקשר. לדוגמה, השאילתה "פיטורים בשל היעדרות" מוצאת את כל סעיפי חוק העבודה על פיטורים ביוזמת המעסיק, גם אם הניסוח שונה. זה מושג באמצעות embeddings שמייצגים טקסט כווקטורים (ממדיים 1536). מסמכים דומים סמנטית ממוקמים קרוב זה לזה במרחב הווקטורי. התוצאה: מהירות חיפוש גבוהה פי 200, דיוק ציטוטים 94%.

מנתח שאילתות משפטיות AI

class LegalAnalyst:
    def __init__(self, search_engine: LegalSearchEngine):
        self.search = search_engine

    def analyze_question(self, question: str, jurisdiction: str = "РФ") -> dict:
        """Анализирует правовой вопрос и находит релевантные нормы"""
        # Шаг 1: Определяем правовые концепции в вопросе
        concepts = self._extract_legal_concepts(question)

        # Шаг 2: Ищем релевантные нормы
        all_results = []
        for concept in concepts:
            results = self.search.search(concept, k=5)
            all_results.extend(results)

        # Дедупликация
        seen = set()
        unique_results = []
        for r in all_results:
            key = f"{r['metadata']['doc_id']}_{r['metadata']['article']}"
            if key not in seen:
                seen.add(key)
                unique_results.append(r)

        # Шаг 3: AI анализирует и структурирует ответ
        return self._synthesize_answer(question, unique_results[:10], jurisdiction)

    def _extract_legal_concepts(self, question: str) -> list[str]:
        """Извлекает ключевые правовые концепции для поиска"""
        response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=512,
            messages=[{
                "role": "user",
                "content": f"""Извлеки 3-5 ключевых правовых концепций/терминов из вопроса для поиска в правовой базе.
Вопрос: {question}
Верни JSON: {{"concepts": ["концепция 1", "концепция 2", ...]}}
Концепции должны быть юридическими терминами, точными для поиска."""
            }]
        )
        text = response.content[0].text
        data = json.loads(text[text.find("{"):text.rfind("}") + 1])
        return data.get("concepts", [question])

    def _synthesize_answer(self, question: str, results: list[dict], jurisdiction: str) -> dict:
        """Синтезирует ответ из найденных правовых норм"""
        context = "\n\n".join([
            f"[{r['metadata']['title']}, {r['metadata']['article']}]\n{r['content']}"
            for r in results
        ])
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=4096,
            system=f"""Ты — правовой аналитик по законодательству {jurisdiction}.
КРИТИЧЕСКИ ВАЖНО:
- Цитируй ТОЛЬКО нормы из предоставленных документов
- Всегда указывай источник: закон + статья + часть
- Не интерпретируй расширительно — только то, что написано в законе
- Если норма не найдена — прямо сообщай об этом
- Различай: закон устанавливает / суд практикует / доктрина считает
Структура ответа:
1. Применимые нормы (с цитатами и ссылками)
2. Судебная практика (если есть)
3. Вывод
4. Что не покрыто найденными нормами""",
            messages=[{
                "role": "user",
                "content": f"""Вопрос: {question}
Найденные правовые нормы: {context}
Дай структурированный правовой анализ."""
            }]
        )
        return {
            "question": question,
            "answer": response.content[0].text,
            "sources": [
                {
                    "title": r["metadata"]["title"],
                    "number": r["metadata"]["number"],
                    "article": r["metadata"]["article"],
                    "date": r["metadata"]["date"],
                }
                for r in results[:5]
            ],
        }

חיפוש פסיקה

class CaseLawSearchEngine:
    """Специализированный поиск по судебным решениям"""

    def find_precedents(
        self,
        legal_issue: str,
        court_level: str = "all",  # "верховный", "арбитражный", "общей_юрисдикции"
        outcome_filter: str = None,  # "удовлетворено", "отказано"
    ) -> list[dict]:
        """Ищет релевантные судебные прецеденты"""
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=2048,
            system="""Ты анализируешь судебные решения для поиска прецедентов.
Структурируй информацию: суть спора, правовая позиция суда, ссылки на нормы, исход.
ВАЖНО: Не придумывай реквизиты дел. Работай только с предоставленными документами.""",
            messages=[{
                "role": "user",
                "content": f"""Найди прецеденты по вопросу: {legal_issue}
Параметры поиска:
- Уровень суда: {court_level}
- Исход: {outcome_filter or "любой"}
На основе найденных дел в базе данных покажи:
1. Дела с аналогичным правовым вопросом
2. Правовую позицию суда по каждому делу
3. Тенденции в судебной практике
4. Ключевые аргументы, принятые судом"""
            }]
        )
        return {"analysis": response.content[0].text}

מקרה מעשי: מחלקה משפטית ארגונית

הקשר: מחלקה משפטית של קונצרן ייצור (12 עורכי דין). משימות עיקריות: בדיקת חוזים, סכסוכי עבודה, סוגיות מס. בסיס משפטי: חוק אזרחי, חוק עבודה, חוק מס, 200+ חוקים פדרליים, פסיקת בית המשפט העליון ובית המשפט העליון לבוררות.

יישום:

• אינדוקס של 1800 מסמכים (חוקים + פסקי דין מרכזיים של בית המשפט העליון)
• ממשק ב-Confluence הארגוני
• משיב אוטומטי לשאלות משפטיות טיפוסיות בנושאי משאבי אנוש וחוזים

מדדים:

• זמן למציאת נורמות רלוונטיות: 45 דקות → 8 דקות (חיפוש ראשוני)
• דיוק ציטוטים: 94% (6% דרשו אימות ידני)
• שאלות טיפוסיות (נסיעות עסקים, מחלה, מע"מ): 70% נפתרו ללא עורך דין
• חיסכון בזמן עורכי דין: ~40%

עיקרון חשוב: המערכת תמיד מציגה מקורות ומזהירה שהתשובה היא התייחסות אנליטית, לא ייעוץ משפטי.

החזר השקעה ממוצע הוא 4–6 חודשים, עם הפחתה של 30% בעלויות תפעוליות למחקר משפטי. לצוות שלנו ניסיון של למעלה מ-10 שנים ב-AI ו-MLOps, וביצע למעלה מ-50 פרויקטים של יישום מערכות חיפוש חכמות.

צרו קשר כדי לקבל הערכת עלות פרויקט למשימות שלכם.

מה כלול בעבודה

הצוות שלנו מספק:

• ביקורת והכנת מסמכים משפטיים (ניקוי, מבנה)
• אינדוקס ובניית מסד נתונים וקטורי
• הגדרת האנליסט AI לתחום הנושא (כולל כוונון עדין של מודלים משפטיים)
• פיתוח ממשק (אינטגרציה עם web, Confluence/SharePoint)
• הדרכת משתמשים ותיעוד
• תמיכה טכנית לאחר הפריסה

תהליך העבודה

1. ניתוח: לימוד בסיס המסמכים שלכם, זיהוי שאילתות טיפוסיות, הגדרת מדדי דיוק.
2. עיצוב: בחירת הסט (Chroma/Qdrant, LLM, מודל embedding), עיצוב סכמת מטא-דאטה.
3. אינדוקס: העלאת מסמכים, הגדרת פיצול ברמת סעיף, יצירת embeddings.
4. כוונון AI: כיול prompts, דוגמאות few-shot, בדיקה על שאלות אמיתיות.
5. אינטגרציה: שילוב המערכת בתהליך העבודה שלכם (Confluence, Telegram, ממשק web).
6. בדיקות: מדידת דיוק, זמן תגובה, כיסוי.
7. פריסה: פריסה על התשתית שלכם או בענן.

לוח זמנים משוער

אנו מבטיחים דיוק ציטוטים וסודיות נתונים. קבלו ייעוץ—נעריך את הפרויקט שלכם תוך יומיים. צרו קשר כדי לדון בפרטים.