Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

QnA sur plusieurs documents

Paskaita 14 iš 16 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Quand la réponse s’étend sur plusieurs fichiers
  2. Tout envoyer en un seul appel
  3. Séparer l’extraction de l’interrogation
  4. Passer au RAG documentaire
  5. Un flux de travail de comparaison de bout en bout
  6. Svarbiausi punktai

Mis à jour le 2 novembre 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) a été retiré le 30 septembre 2026. Utilise OCR 4.1 (mistral-ocr-4-1), disponible généralement depuis le 31 août au même tarif, ou l’alias mistral-ocr-latest qui le cible depuis le 16 juillet. OCR 4.1 ajoute des scores de confiance au niveau des blocs. Addendum du 3 novembre 2026 : un PDF local est transmis en base64 sous la forme {"type": "document_url", "document_url": "data:application/pdf;base64,…"} ; le type document_base64 présent dans d’anciens exemples n’existe ni dans la documentation ni dans le SDK mistralai, et ces exemples auraient échoué. Sources : Processeur OCR · QnA sur documents. Corrigé le 3 novembre 2026 : le code lisait précédemment page.document_annotation page par page ; dans le SDK mistralai 3.7.0, l’annotation du document est un champ unique dans la réponse (response.document_annotation), et l’annotation d’une image se lit depuis image.image_annotation.

Quand la réponse s’étend sur plusieurs fichiers

Dans de nombreux scénarios professionnels, la réponse à une question ne se trouve pas dans un seul document. Tu peux avoir besoin de comparer des contrats, de recouper des factures avec des bons de commande ou d’analyser une série de rapports. Trois stratégies existent, et la meilleure approche consiste à choisir en fonction du volume plutôt que de sauter immédiatement vers l’option la plus sophistiquée.

Tout envoyer en un seul appel

La méthode la plus directe consiste à empiler plusieurs blocs document_url dans le même message. Le modèle voit les deux contrats côte à côte et peut véritablement les comparer, ce que le traitement page par page ne permet pas. Nous passons ici à mistral-large-latest car la comparaison implique du raisonnement, pas seulement de la lecture.

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)

La limitation apparaît rapidement : la somme des documents ne doit pas dépasser la fenêtre de contexte du modèle. Deux brochures de dix pages passent sans difficulté ; deux accords-cadres de deux cents pages, non.

Séparer l’extraction de l’interrogation

Pour de gros volumes, la stratégie recommandée découple ces deux étapes. Tu fais passer chaque document par l’OCR, conserves le Markdown résultant, puis construis manuellement le contexte envoyé au LLM. L’avantage est le contrôle : la troncature à 5 000 caractères visible dans l’exemple, le maintien du nom de chaque document comme en-tête de section, et le message système qui établit le rôle d’assistant juridique. Tu décides exactement de ce qui entre dans la fenêtre de contexte au lieu de laisser cela se faire automatiquement.

import os
from mistralai.client import Mistral

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

def extract_text(url: str) -> str:
    """Extrait le texte d'un 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)


# Extraction OCR pour chaque 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"),
}

# Construction du prompt avec le contexte
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # Limiter si nécessaire
    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?"
            )
        }
    ]
)

Passer au RAG documentaire

Au-delà de quelques dizaines de documents, aucune fenêtre de contexte ne suffira. Tu dois alors envoyer uniquement les passages pertinents, ce qui nécessite de découper les textes, de les vectoriser avec mistral-embed et de rechercher par similarité au moment de la requête. Le découpage avec un chevauchement de 200 caractères empêche une phrase coupée en deux de perdre son sens entre les chunks, et top_k détermine combien de passages accompagneront finalement la question.

import os
from mistralai.client import Mistral

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

def create_embeddings(text: str) -> list[float]:
    """Crée des embeddings pour un texte."""
    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]:
    """Découpe le texte en chunks avec chevauchement."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap
    return chunks


# Pipeline RAG simplifié
def index_document(name: str, text: str) -> list[dict]:
    """Indexe un document pour la recherche."""
    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]:
    """Recherche les chunks les plus pertinents."""
    q_embedding = create_embeddings(query)

    # Calcul de la similarité 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]]

Résumons la logique de sélection. L’envoi de plusieurs documents en un seul appel reste imbattable pour sa simplicité et fonctionne bien pour deux ou trois documents courts. L’OCR séparé suivi d’un QnA offre de la flexibilité et te donne le contrôle sur ce qui est envoyé au LLM, au prix de quelques lignes de code supplémentaires. Le RAG documentaire est plus lourd à mettre en place mais devient essentiel à mesure que le corpus grossit, car c’est la seule approche qui passe à l’échelle.

Un flux de travail de comparaison de bout en bout

Les deux techniques peuvent être combinées : rien ne t’empêche d’abord d’extraire des données structurées via l’annotation, puis de confier ces données au LLM pour analyse. Sur un lot de factures, chaque document est réduit à trois champs — fournisseur, montant, date — avant qu’une seule requête ne demande au modèle d’identifier les tendances et les anomalies. Le coût en tokens devient négligeable, et l’analyse se concentre sur des chiffres proprement extraits plutôt que sur du texte interprété à la volée.

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:
    """Compare plusieurs factures et renvoie une analyse."""
    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)

    # Analyse comparative 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

Svarbiausi punktai

  • Trois approches pour le QnA multi-documents : en ligne, OCR séparé, RAG
  • L’approche en ligne fonctionne pour 2 à 3 documents courts
  • OCR séparé + QnA offre plus de contrôle sur les tokens consommés
  • Le RAG est essentiel pour les gros corpus (des dizaines de documents)
  • Combine les annotations structurées avec le QnA pour des analyses précises