Otázky a odpovede pre viacero dokumentov
Na tejto strane
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 aliasmistral-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,…"}; typdocument_base64zo starších príkladov neexistuje ani v dokumentácii, ani v SDKmistralaia tieto príklady by zlyhali. Zdroje: OCR Processor · Document QnA. Opravené 3. novembra 2026: Predchádzajúci kód čítalpage.document_annotationstránku po stránke; v SDKmistralaiverzie 3.7.0 je anotácia dokumentu jediným poľom v odpovedi (response.document_annotation) a anotácia obrázka sa číta zimage.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