Salt la conținutul principal
Română— Alege o limbă
Meniu

QnA pe mai multe documente

Lecția 14 din 16 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Când răspunsul se întinde pe mai multe fișiere
  2. Trimiteți totul într-o singură apel
  3. Separarea extracției de interogare
  4. Trecerea la RAG pe documente
  5. Un flux de lucru de comparație cap-la-cap
  6. Puncte cheie

Actualizat la 2 noiembrie 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) a fost retras la 30 septembrie 2026. Utilizați OCR 4.1 (mistral-ocr-4-1), disponibil public din 31 august la același preț, sau aliasul mistral-ocr-latest, care indică spre acesta din 16 iulie. OCR 4.1 adaugă scoruri de încredere la nivel de bloc. Addendum 3 noiembrie 2026: Un fișier PDF local este transmis în base64 sub forma {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; tipul document_base64 din exemplele mai vechi nu există nici în documentație, nici în SDK-ul mistralai, iar acele exemple ar fi eșuat. Surse: Procesor OCR · QnA pe documente. Corectat la 3 noiembrie 2026: Codul anterior citea page.document_annotation pagină cu pagină; în SDK-ul mistralai versiunea 3.7.0, adnotarea documentului este un singur câmp în răspuns (response.document_annotation), iar adnotarea unei imagini se citește din image.image_annotation.

Când răspunsul se întinde pe mai multe fișiere

În multe scenarii profesionale, răspunsul la o întrebare nu se găsește într-un singur document. Este posibil să trebuiască să comparați contracte, să corelați facturi cu comenzi de achiziție sau să analizați o serie de rapoarte. Există trei strategii, iar cea mai bună abordare este să alegeți în funcție de volum, fără a recurge imediat la opțiunea cea mai sofisticată.

Trimiteți totul într-o singură apel

Metoda cea mai directă constă în stivuirea mai multor blocuri document_url în același mesaj. Modelul vede ambele contracte unul lângă altul și le poate compara efectiv, lucru pe care procesarea pagină cu pagină nu îl poate realiza. Trecem aici la mistral-large-latest deoarece compararea implică raționament, nu doar citire.

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)

Limitarea apare rapid: suma documentelor nu trebuie să depășească fereastra de context a modelului. Două broșuri de zece pagini trec fără dificultate; două acorduri-cadru de o sută de pagini, nu.

Separarea extracției de interogare

Pentru volume mari, strategia recomandată decuplează acești doi pași. Treceți fiecare document prin OCR, păstrați Markdown-ul rezultat și construiți manual contextul trimis către LLM. Avantajul este controlul: trunchierea la 5.000 de caractere vizibilă în exemplu, menținerea numelui fiecărui document ca antet de secțiune și mesajul de sistem care stabilește rolul de asistent juridic. Decideți exact ce intră în fereastra de context, în loc să lăsați acest lucru să se întâmple automat.

import os
from mistralai.client import Mistral

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

def extract_text(url: str) -> str:
    """Extrage textul dintr-un document prin 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)


# Extracție OCR pentru fiecare 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"),
}

# Construirea promptului cu context
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # Limitare dacă este necesar
    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?"
            )
        }
    ]
)

Trecerea la RAG pe documente

Dincolo de câteva zeci de documente, nicio fereastră de context nu va fi suficientă. Trebuie atunci să trimiteți doar pasajele relevante, ceea ce necesită divizarea textelor, vectorizarea lor cu mistral-embed și căutarea prin similaritate la momentul interogării. Divizarea (chunking) cu o suprapunere de 200 de caractere împiedică pierderea sensului unei propoziții tăiate în jumătate între două fragmente, iar top_k determină câte pasaje vor însoți în cele din urmă întrebarea.

import os
from mistralai.client import Mistral

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

def create_embeddings(text: str) -> list[float]:
    """Creează embedding-uri pentru un 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]:
    """Divizează textul în fragmente cu suprapunere."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap
    return chunks


# Pipeline RAG simplificat
def index_document(name: str, text: str) -> list[dict]:
    """Indexează un document pentru căutare."""
    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]:
    """Caută fragmentele cele mai relevante."""
    q_embedding = create_embeddings(query)

    # Calculul similarității cosinus
    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]]

Să rezumăm logica de selecție. Trimiterea mai multor documente într-un singur apel rămâne imbatabilă prin simplitate și funcționează bine pentru două sau trei documente scurte. OCR-ul separat urmat de QnA oferă flexibilitate și vă permite să controlați ce este trimis către LLM, cu costul unor linii de cod suplimentare. RAG pe documente este mai greu de configurat, dar devine esențial pe măsură ce corpusul crește, deoarece este singura abordare care scalează.

Un flux de lucru de comparație cap-la-cap

Cele două tehnici pot fi combinate: nimic nu vă împiedică să extrageți mai întâi date structurate prin adnotare, apoi să predați aceste date LLM-ului pentru analiză. Pe un lot de facturi, fiecare document este redus la trei câmpuri—furnizor, sumă, dată—înainte ca o singură cerere să solicite modelului să identifice tendințe și anomalii. Costul în tokeni devine neglijabil, iar analiza se concentrează pe cifre extrase curat, nu pe text interpretat în timp real.

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:
    """Compară mai multe facturi și returnează o analiză."""
    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)

    # Analiză comparativă prin 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

Puncte cheie

  • Trei abordări pentru QnA pe mai multe documente: inline, OCR separat, RAG
  • Abordarea inline funcționează pentru 2–3 documente scurte
  • OCR separat + QnA oferă mai mult control asupra tokenilor consumați
  • RAG este esențial pentru corpusuri mari (zeci de documente)
  • Combinați adnotările structurate cu QnA pentru analize precise