Spring til hovedindhold
Dansk— Vælg et sprog
Menu

QnA med flere dokumenter

Lektion 14 af 16 Opdateret 3. november 2026 Udvikler
På denne side
  1. Når svaret strækker sig over flere filer
  2. Send alt i ét enkelt kald
  3. Adskil udtrækning fra forespørgsel
  4. Gå over til Document RAG
  5. En end-to-end sammenligningsworkflows
  6. Vigtige pointer

Opdateret 2. november 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) blev udfaset den 30. september 2026. Brug OCR 4.1 (mistral-ocr-4-1), som har været generelt tilgængelig siden 31. august til samme pris, eller aliasset mistral-ocr-latest, som har peget på det siden 16. juli. OCR 4.1 tilføjer konfidensscorer på blokniveau. Tillæg 3. november 2026: En lokal PDF transmitteres i base64 som {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; typen document_base64 fra ældre eksempler findes hverken i dokumentationen eller i mistralai SDK’et, og disse eksempler ville have fejlet. Kilder: OCR Processor · Document QnA. Rettet 3. november 2026: Koden læste tidligere page.document_annotation side for side; i mistralai SDK 3.7.0 er dokumentannotationen et enkelt felt i svaret (response.document_annotation), og en billedes annotation læses fra image.image_annotation.

Når svaret strækker sig over flere filer

I mange professionelle scenarier findes svaret på et spørgsmål ikke i ét enkelt dokument. Du kan få brug for at sammenligne kontrakter, krydsreferere fakturaer med købsordrer eller analysere en række rapporter. Der findes tre strategier, og den bedste fremgangsmåde er at vælge ud fra volumen frem for straks at springe til den mest sofistikerede mulighed.

Send alt i ét enkelt kald

Den mest direkte metode er at stable flere document_url-blokke i den samme besked. Modellen ser begge kontrakter side om side og kan rent faktisk sammenligne dem, hvilket side-for-side-behandling ikke kan opnå. Vi skifter her til mistral-large-latest, fordi sammenligning indebærer ræsonnement, ikke blot læsning.

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)

Begrænsningen viser sig hurtigt: Summen af dokumenterne må ikke overstige modellens kontekstvindue. To brochurer på ti sider går uden problemer; to rammeaftaler på hundrede sider gør ikke.

Adskil udtrækning fra forespørgsel

Ved store volumener er den anbefalede strategi at afkoble disse to trin. Du sender hvert dokument gennem OCR, beholder det resulterende Markdown og konstruerer derefter manuelt den kontekst, der sendes til LLM’en. Fordelen er kontrol: Trunkeringen til 5.000 tegn, som ses i eksemplet, beholdelsen af hvert dokumentnavn som sektionsoverskrift og systembeskeden, der fastlægger rollen som juridisk assistent. Du beslutter præcis, hvad der kommer ind i kontekstvinduet, i stedet for at lade det ske automatisk.

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-udtrækning for hvert 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"),
}

# Byg prompten med kontekst
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # Begræns om nødvendigt
    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?"
            )
        }
    ]
)

Gå over til Document RAG

Ud over et par dusin dokumenter vil intet kontekstvindue være tilstrækkeligt. Du skal derefter kun sende de relevante passager, hvilket kræver, at du splitter teksterne, vektoriserer dem med mistral-embed og søger efter lighed ved forespørgselstidspunktet. Chunking med et overlap på 200 tegn forhindrer, at en sætning, der skæres over, mister sin betydning mellem chunks, og top_k bestemmer, hvor mange passager der i sidste ende vil ledsage spørgsmålet.

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


# Forenklet 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)

    # Beregning af cosinuslighed
    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]]

Lad os opsummere valgblogikken. At sende flere dokumenter i ét enkelt kald forbliver uovertruffen hvad angår enkelhed og fungerer godt til to eller tre korte dokumenter. Separat OCR efterfulgt af QnA giver fleksibilitet og giver dig kontrol over, hvad der sendes til LLM’en, på bekostning af lidt ekstra kode. Document RAG er tungere at sætte op, men bliver essentiel, efterhånden som korpussen vokser, fordi det er den eneste tilgang, der skalerer.

En end-to-end sammenligningsworkflows

De to teknikker kan kombineres: Intet hindrer dig i først at udtrække strukturerede data via annotation og derefter give disse data til LLM’en til analyse. På en batch af fakturaer reduceres hvert dokument til tre felter – leverandør, beløb, dato – før en enkelt anmodning beder modellen om at identificere tendenser og anomalier. Token-omkostningerne bliver ubetydelige, og analysen fokuserer på rent udtrukne tal frem for tekst, der fortolkes i øjeblikket.

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)

    # Sammenlignende analyse 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

Vigtige pointer

  • Tre tilgange til QnA med flere dokumenter: inline, separat OCR, RAG
  • Inline-tilgangen fungerer til 2–3 korte dokumenter
  • Separat OCR + QnA giver mere kontrol over forbrugte tokens
  • RAG er essentiel for store korpusser (snesevis af dokumenter)
  • Kombiner strukturerede annotationer med QnA for præcise analyser