Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

QnA na více dokumentech

Lekce 14 z 16 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Když se odpověď nachází ve více souborech
  2. Odeslání všeho v jediném volání
  3. Oddělení extrakce od dotazování
  4. Přechod na Document RAG
  5. Komplexní pracovní postup porovnávání
  6. Klíčové poznatky

Aktualizováno 2. listopadu 2026 — OCR. Verze OCR 4.0 (mistral-ocr-4-0) byla 30. září 2026 vyřazena z provozu. Používej OCR 4.1 (mistral-ocr-4-1), které je obecně dostupné od 31. srpna za stejnou cenu, nebo alias mistral-ocr-latest, který na něj odkazuje od 16. července. OCR 4.1 přidává skóre důvěryhodnosti na úrovni bloků. Dodatek ze 3. listopadu 2026: Lokální PDF se přenáší v base64 jako {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; typ document_base64 ze starších příkladů neexistuje ani v dokumentaci, ani v SDK mistralai a tyto příklady by selhaly. Zdroje: OCR Processor · Document QnA. Opraveno 3. listopadu 2026: Předchozí kód četl page.document_annotation stránku po stránce; v SDK mistralai verze 3.7.0 je anotace dokumentu jediným polem v odpovědi (response.document_annotation) a anotace obrázku se čte z image.image_annotation.

Když se odpověď nachází ve více souborech

V mnoha profesionálních scénářích nenajdeš odpověď na otázku v jediném dokumentu. Možná budeš muset porovnat smlouvy, zkřížit faktury s objednávkami nebo analyzovat sérii reportů. Existují tři strategie a nejlepší přístup je vybrat podle objemu dat, místo abys hned skočil po té nejpokročilejší možnosti.

Odeslání všeho v jediném volání

Nejpřímější metodou je naskládat více bloků document_url do stejné zprávy. Model vidí obě smlouvy vedle sebe a může je skutečně porovnat, čehož zpracování stránka po stránce nedosáhne. Zde přepínáme na mistral-large-latest, protože porovnávání vyžaduje usuzování, nejen čtení.

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)

Omezení se projeví rychle: součet velikostí dokumentů nesmí překročit kontextové okno modelu. Dvě desetistránkové brožury projdou bez problémů; dvě rámcové smlouvy o dvou stech stranách už ne.

Oddělení extrakce od dotazování

U velkých objemů dat se doporučuje tyto dva kroky oddělit. Každý dokument provedeš přes OCR, uložíš výsledný Markdown a následně ručně sestavíš kontext, který odešleš do LLM. Výhodou je kontrola: ořez na 5 000 znaků viditelný v příkladu, ponechání názvu každého dokumentu jako nadpisu sekce a systémová zpráva, která stanoví roli právního asistenta. Ty sám rozhoduješ, co se dostane do kontextového okna, místo aby se to dělo 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 pomocí 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)


# Extrakce OCR pro 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"),
}

# Sestavení promptu s kontextem
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # Omezit, pokud je třeba
    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?"
            )
        }
    ]
)

Přechod na Document RAG

Při počtu dokumentů přesahujícím několik desítek žádné kontextové okno stačit nebude. Musíš pak odeslat pouze relevantní pasáže, což vyžaduje rozdělení textů, jejich vektorizaci pomocí mistral-embed a vyhledávání podle podobnosti v době dotazu. Rozdělení (chunking) s překryvem 200 znaků zabraňuje tomu, aby věta rozdělená napůl ztratila mezi úseky svůj význam, a top_k určuje, kolik pasáží nakonec doprovodí 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áří vektory (embeddings) pro 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]:
    """Rozděluje text na úseky s překryvem."""
    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 pro vyhledávání."""
    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]:
    """Vyhledává nejrelevantnější úseky."""
    q_embedding = create_embeddings(query)

    # Výpočet kosinové 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]]

Shrňme si logiku výběru. Odeslání více dokumentů v jediném volání zůstává nepřekonatelné svou jednoduchostí a funguje dobře pro dva či tři krátké dokumenty. Samostatné OCR následované QnA poskytuje flexibilitu a dává ti kontrolu nad tím, co je odesláno do LLM, za cenu trochu extra kódu. Document RAG je náročnější na nastavení, ale stává se nezbytným s růstem korpusu, protože je to jediný přístup, který škáluje.

Komplexní pracovní postup porovnávání

Obě techniky lze kombinovat: nic ti nebrání nejprve extrahovat strukturovaná data pomocí anotace a poté tato data předat LLM k analýze. U dávky faktur se každý dokument zredukuje na tři pole – dodavatel, částka, datum – než jediný požadavek požádá model o identifikaci trendů a anomálií. Náklady na tokeny se stanou zanedbatelnými a analýza se zaměří na čistě extrahovaná čísla místo textu interpretovaného za běhu.

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ává více faktur a vrací 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)

    # Srovnávací analýza pomocí 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

Klíčové poznatky

  • Tři přístupy pro QnA na více dokumentech: inline, samostatné OCR, RAG
  • Inline přístup funguje pro 2–3 krátké dokumenty
  • Samostatné OCR + QnA nabízí větší kontrolu nad spotřebovanými tokeny
  • RAG je nezbytný pro velké korpusy (desítky dokumentů)
  • Kombinuj strukturované anotace s QnA pro přesné analýzy