Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Otázky a odpovede pre viacero dokumentov

Lekcia 14 z 16 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Keď sa odpoveď nachádza vo viacerých súboroch
  2. Odoslanie všetkého v jednom volaní
  3. Oddelenie extrakcie od dopytovania
  4. Prechod na dokumentový RAG
  5. Komplexný workflow porovnania
  6. Kľúčové poznatky

Aktualizované 2. novembra 2026 — OCR. Verzia OCR 4.0 (mistral-ocr-4-0) bola vyradená 30. septembra 2026. Používaj OCR 4.1 (mistral-ocr-4-1), ktorá je všeobecne dostupná od 31. augusta za rovnakú cenu, alebo alias mistral-ocr-latest, ktorý na ňu odkazuje od 16. júla. OCR 4.1 pridáva skóre spoľahlivosti na úrovni blokov. Doplnok z 3. novembra 2026: Lokálny súbor PDF sa odosiela v kódovaní base64 ako {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; typ document_base64 zo starších príkladov neexistuje ani v dokumentácii, ani v SDK mistralai a tieto príklady by zlyhali. Zdroje: OCR Processor · Document QnA. Opravené 3. novembra 2026: Predchádzajúci kód čítal page.document_annotation stránku po stránke; v SDK mistralai verzie 3.7.0 je anotácia dokumentu jediným poľom v odpovedi (response.document_annotation) a anotácia obrázka sa číta z image.image_annotation.

Keď sa odpoveď nachádza vo viacerých súboroch

V mnohých profesionálnych scenároch nenájdeš odpoveď na otázku v jednom jedinom dokumente. Možno budeš potrebovať porovnať zmluvy, skrížovať faktúry s objednávkami alebo analyzovať sériu správ. Existujú tri stratégie a najlepším prístupom je vybrať si podľa objemu dát, namiesto toho, aby si hneď siahol po tej najzložitejšej možnosti.

Odoslanie všetkého v jednom volaní

Najpriamejšou metódou je naskladať viacero blokov document_url do tej istej správy. Model vidí obe zmluvy vedľa seba a dokáže ich skutočne porovnať, čo spracovanie stránka po stránke nedokáže. Tu prechádzame na mistral-large-latest, pretože porovnávanie zahŕňa logické uvažovanie, nielen čítanie.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": (
                        "Compare the payment terms "
                        "of these two contracts."
                    )
                },
                {
                    "type": "document_url",
                    "document_url": "https://example.com/contract-A.pdf"
                },
                {
                    "type": "document_url",
                    "document_url": "https://example.com/contract-B.pdf"
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

Obmedzenie sa objaví rýchlo: súčet veľkostí dokumentov nesmie prekročiť kontextové okno modelu. Dva desaťstranové brožúry prejdú bez problémov; dve rámcové zmluvy so sto stranami nie.

Oddelenie extrakcie od dopytovania

Pri veľkých objemoch dát je odporúčanou stratégiou oddeliť tieto dva kroky. Každý dokument prevedieš cez OCR, zachováš výsledný Markdown a následne manuálne zostavíš kontext, ktorý odošleš do LLM. Výhodou je kontrola: orezanie na 5 000 znakov viditeľné v príklade, ponechanie názvu každého dokumentu ako nadpisu sekcie a systémová správa, ktorá stanovuje rolu právneho asistenta. Ty rozhoduješ presne o tom, čo sa dostane do kontextového okna, namiesto toho, aby sa to dialo automaticky.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def extract_text(url: str) -> str:
    """Extrahuje text z dokumentu pomocou OCR."""
    response = client.ocr.process(
        model="mistral-ocr-latest",
        document={"type": "document_url", "document_url": url}
    )
    return "\n\n".join(p.markdown for p in response.pages)


# Extrakcia OCR pre každý dokument
documents = {
    "Contract A": extract_text("https://example.com/contract-A.pdf"),
    "Contract B": extract_text("https://example.com/contract-B.pdf"),
    "Contract C": extract_text("https://example.com/contract-C.pdf"),
}

# Zostavenie promptu s kontextom
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # V prípade potreby obmedziť
    for name, text in documents.items()
)

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": (
                "You are a legal assistant. Analyze the "
                "provided documents and answer questions."
            )
        },
        {
            "role": "user",
            "content": (
                f"Here are the documents:\n\n{context}\n\n"
                f"Question: Which contract offers the best "
                f"early termination conditions?"
            )
        }
    ]
)

Prechod na dokumentový RAG

Pri viac než niekoľkých desiatkach dokumentov už žiadne kontextové okno nebude stačiť. Musíš potom odosielať iba relevantné pasáže, čo si vyžaduje rozdelenie textov, ich vektorizáciu pomocou mistral-embed a vyhľadávanie podľa podobnosti v čase dopytu. Rozdeľovanie (chunking) s prekrytím 200 znakov zabraňuje tomu, aby veta rozpolená medzi chunkmi stratila význam, a top_k určuje, koľko pasáží nakoniec sprevádza otázku.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def create_embeddings(text: str) -> list[float]:
    """Vytvára vektory (embeddings) pre text."""
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=[text]
    )
    return response.data[0].embedding


def chunker(text: str, size: int = 1000, overlap: int = 200) -> list[str]:
    """Rozdeľuje text na chunky s prekrytím."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap
    return chunks


# Zjednodušený pipeline RAG
def index_document(name: str, text: str) -> list[dict]:
    """Indexuje dokument pre vyhľadávanie."""
    chunks = chunker(text)
    index = []

    for i, chunk in enumerate(chunks):
        embedding = create_embeddings(chunk)
        index.append({
            "document": name,
            "chunk_id": i,
            "text": chunk,
            "embedding": embedding
        })

    return index


def search(query: str, index: list[dict], top_k: int = 5) -> list[dict]:
    """Vyhľadáva najrelevantnejšie chunky."""
    q_embedding = create_embeddings(query)

    # Výpočet kozínusovej podobnosti
    import numpy as np
    scores = []
    for item in index:
        score = np.dot(q_embedding, item["embedding"])
        scores.append((score, item))

    scores.sort(key=lambda x: x[0], reverse=True)
    return [item for _, item in scores[:top_k]]

Zhrňme si logiku výberu. Odoslanie viacerých dokumentov v jednom volaní zostáva neprekonateľné svojou jednoduchosťou a funguje dobre pre dva alebo tri krátke dokumenty. Samostatné OCR nasledované QnA poskytuje flexibilitu a dáva ti kontrolu nad tým, čo sa odosiela do LLM, za cenu trochu viac kódu. Dokumentový RAG je náročnejší na nastavenie, ale stáva sa nevyhnutným s rastom korpusu, pretože je to jediný prístup, ktorý škáluje.

Komplexný workflow porovnania

Tieto dve techniky možno kombinovať: nič ti nebráni najprv extrahovať štruktúrované dáta pomocou anotácie a potom tieto dáta odovzdať LLM na analýzu. Pri dávke faktúr sa každý dokument zredukuje na tri polia – dodávateľ, suma, dátum – predtým, než jedna jediná požiadavka požiada model o identifikáciu trendov a anomálií. Náklady na tokeny sa stanú zanedbateľnými a analýza sa zameria na čisto extrahované čísla namiesto textu interpretovaného za behu.

import os
from pydantic import BaseModel, Field
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

class InvoiceSummary(BaseModel):
    vendor: str = Field(..., description="Vendor name")
    amount_inc_tax: float = Field(..., description="Amount including tax")
    date: str = Field(..., description="Date (YYYY-MM-DD)")

def compare_invoices(paths: list[str]) -> str:
    """Porovnáva viacero faktúr a vráti analýzu."""
    import base64

    invoices = []
    for path in paths:
        with open(path, "rb") as f:
            doc_b64 = base64.b64encode(f.read()).decode("utf-8")

        response = client.ocr.process(
            model="mistral-ocr-latest",
            document={
                "type": "document_url",
                "document_url": f"data:application/pdf;base64,{doc_b64}"
            },
            document_annotation_format=response_format_from_pydantic_model(
                InvoiceSummary
            )
        )

        if response.document_annotation:
            invoice = InvoiceSummary.model_validate_json(
                response.document_annotation
            )
            invoices.append(invoice)

    # Komparatívna analýza pomocou LLM
    summary = "\n".join(
        f"- {f.vendor}: €{f.amount_inc_tax} ({f.date})"
        for f in invoices
    )

    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {
                "role": "user",
                "content": (
                    f"Here are {len(invoices)} invoices:\n{summary}\n\n"
                    f"Analyze trends and anomalies."
                )
            }
        ]
    )

    return response.choices[0].message.content

Kľúčové poznatky

  • Tri prístupy pre QnA s viacerými dokumentmi: inline, samostatné OCR, RAG
  • Inline prístup funguje pre 2–3 krátke dokumenty
  • Samostatné OCR + QnA ponúka väčšiu kontrolu nad spotrebovanými tokenmi
  • RAG je nevyhnutný pre veľké korpusy (desiatky dokumentov)
  • Kombinuj štruktúrované anotácie s QnA pre presné analýzy