Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Vprašanja in odgovori za več dokumentov

Lekcija 14 od 16 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Ko odgovor zajema več datotek
  2. Pošlji vse v enem klicu
  3. Ločena ekstrakcija od poizvedovanja
  4. Prehod na dokumentni RAG
  5. Celovito delovno okolje za primerjavo
  6. Ključne ugotovitve

Posodobljeno 2. novembra 2026 — OCR. Različica OCR 4.0 (mistral-ocr-4-0) je bila umaknjena 30. septembra 2026. Uporabi OCR 4.1 (mistral-ocr-4-1), ki je splošno dostopen od 31. avgusta po enaki ceni, ali alias mistral-ocr-latest, ki kaže nanj od 16. julija. OCR 4.1 dodaja ocene zanesljivosti na ravni blokov. Dodatek 3. novembra 2026: Lokalni PDF se prenese v formatu base64 kot {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; tip document_base64 iz starejših primerov ne obstaja niti v dokumentaciji niti v SDK-ju mistralai, ti primeri pa bi spodleteli. Viri: OCR Processor · Document QnA. Popravljeno 3. novembra 2026: Koda je prej brala page.document_annotation stran za stranjo; v SDK-ju mistralai različice 3.7.0 je anotacija dokumenta eno samo polje v odgovoru (response.document_annotation), anotacijo slike pa beremo iz image.image_annotation.

Ko odgovor zajema več datotek

V mnogih poklicnih scenarijih odgovora na vprašanje ne najdeš v enem samem dokumentu. Morda moraš primerjati pogodbe, navzkrižno preveriti račune z naročilnicami ali analizirati niz poročil. Obstajajo tri strategije, najboljši pristop pa je izbrati glede na obseg podatkov, namesto da bi takoj skočil k najbolj sofisticirani možnosti.

Pošlji vse v enem klicu

Najbolj neposredna metoda je seštevanje več blokov document_url v istem sporočilu. Model vidi obe pogodbi drugo ob drugi in ju lahko resnično primerja, česar obdelava stran za stranjo ne more doseči. Tu preklopimo na mistral-large-latest, ker primerjava vključuje sklepanje, ne le branja.

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)

Omejitev se hitro pokaže: vsota dokumentov ne sme preseči kontekstnega okna modela. Dve desetstranski brošuri gresta brez težav, dve stostranski okvirni pogodbi pa ne.

Ločena ekstrakcija od poizvedovanja

Za velike količine je priporočljiva strategija, ki loči ta dva koraka. Vsak dokument preneseš skozi OCR, obdržiš nastali Markdown in nato ročno sestaviš kontekst, poslan LLM-u. Prednost je nadzor: obrezovanje na 5.000 znakov, vidno v primeru, ohranjanje imena vsakega dokumenta kot naslova razdelka in sistemsko sporočilo, ki določa vlogo pravnega pomočnika. Sam se odločiš, kaj točno vstopi v kontekstno okno, namesto da bi se to zgodilo samodejno.

import os
from mistralai.client import Mistral

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

def extract_text(url: str) -> str:
    """Extracts text from a document via 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)


# OCR extraction for each document
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"),
}

# Build the prompt with context
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # Limit if necessary
    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?"
            )
        }
    ]
)

Prehod na dokumentni RAG

Čez nekaj deset dokumentov nobeno kontekstno okno ne bo zadostovalo. Poslati moraš le ustrezne odlomke, kar zahteva razdelitev besedil, njihovo vektorsko predstavitev z mistral-embed in iskanje po podobnosti ob času poizvedbe. Razdeljevanje s prekrivanjem 200 znakov prepreči, da bi stavek, prerezan na pol, med delčki izgubil pomen, top_k pa določa, koliko odlomkov bo sčasoma spremljalo vprašanje.

import os
from mistralai.client import Mistral

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

def create_embeddings(text: str) -> list[float]:
    """Creates embeddings for a 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]:
    """Splits text into chunks with overlap."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap
    return chunks


# Simplified RAG pipeline
def index_document(name: str, text: str) -> list[dict]:
    """Indexes a document for search."""
    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]:
    """Searches for the most relevant chunks."""
    q_embedding = create_embeddings(query)

    # Cosine similarity calculation
    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]]

Povzemimo logiko izbire. Pošiljanje več dokumentov v enem klicu ostaja nepremagljivo zaradi preprostosti in dobro deluje za dva ali tri kratke dokumente. Ločen OCR, ki mu sledi QnA, zagotavlja prilagodljivost in ti daje nadzor nad tem, kaj je poslano LLM-u, ob ceni nekaj dodatne kode. Dokumentni RAG je težje postaviti, a postane bistven, ko korpus raste, ker je to edini pristop, ki se skalira.

Celovito delovno okolje za primerjavo

Obe tehniki lahko združiš: nič ti ne preprečuje, da najprej ekstrahiraš strukturirane podatke prek anotacije, nato pa te podatke predložiš LLM-u za analizo. Pri seriji računov se vsak dokument zreducira na tri polja – dobavitelj, znesek, datum – preden en sam zahtevek od modela zahteva prepoznavanje trendov in anomalij. Strošek žetonov postane zanemarljiv, analiza pa se osredotoči na čisto ekstrahirane številke namesto na besedilo, interpretirano sproti.

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:
    """Compares multiple invoices and returns an analysis."""
    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)

    # Comparative analysis via 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

Ključne ugotovitve

  • Trije pristopi za vprašanja in odgovore za več dokumentov: v vrstici, ločen OCR, RAG
  • Pristop v vrstici deluje za 2–3 kratke dokumente
  • Ločen OCR + QnA ponuja večji nadzor nad porabljenimi žetoni
  • RAG je bistven za velike korpuse (desetke dokumentov)
  • Združi strukturirane anotacije z QnA za natančne analize