Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Kysymykset ja vastaukset useille dokumenteille

Oppitunti 14 / 16 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Kun vastaus löytyy useista tiedostoista
  2. Lähetä kaikki yhdellä pyynnöllä
  3. Erosa tekstierottelu ja kysely
  4. Siirry dokumentti-RAG:iin
  5. End-to-end-vertailutyönkulku
  6. Keskeiset asiat

Päivitetty 2. marraskuuta 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) poistettiin käytöstä 30. syyskuuta 2026. Käytä OCR 4.1:tä (mistral-ocr-4-1), joka on ollut yleisesti saatavilla 31. elokuuta lähtien samaan hintaan, tai aliasta mistral-ocr-latest, joka on viitannut siihen 16. heinäkuuta lähtien. OCR 4.1 lisää luottamusluvut lohko tasolla. Lisäys 3. marraskuuta 2026: Paikallinen PDF lähetetään base64-muodossa rakenteella {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; vanhemmissa esimerkeissä esiintyvää document_base64-tyyppiä ei ole olemassa eikä dokumentaatiossa että mistralai-SDK:ssa, ja nämä esimerkit olisivat epäonnistuneet. Lähteet: OCR Processor · Document QnA. Korjattu 3. marraskuuta 2026: Aiempi koodi luki page.document_annotation sivu kerrallaan; mistralai-SDK:n versiossa 3.7.0 dokumentin annotaatio on yksi kenttä vastauksessa (response.document_annotation), ja kuvan annotaatio luetaan kohdasta image.image_annotation.

Kun vastaus löytyy useista tiedostoista

Monissa ammattimaisissa tilanteissa vastaus kysymykseen ei löydy yhdestä ainoasta dokumentista. Sinun saatat joutua vertailemaan sopimuksia, ristiviittaamaan laskuja tilauksiin tai analysoimaan raporttikokonaisuuksia. Käytössä on kolme strategiaa, ja paras lähestymistapa valitaan datamäärän perusteella sen sijaan, että hyppäisit suoraan monimutkaisimpaan vaihtoehtoon.

Lähetä kaikki yhdellä pyynnöllä

Suoraviivaisin menetelmä on pinota useita document_url-lohkoja samaan viestiin. Malli näkee molemmat sopimukset rinnakkain ja pystyy aidosti vertailemaan niitä, mitä sivu kerrallaan -käsittely ei mahdollista. Vaihdamme tässä malliin mistral-large-latest, koska vertailu vaatii päättelykykyä, ei pelkkää lukemista.

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)

Rajoitus tulee vastaan nopeasti: dokumenttien yhteismäärä ei saa ylittää mallin konteksti-ikkunaa. Kaksi kymmensivuista esitettä menevät läpi vaivatta; kaksi sadansivuista puitesopimusta eivät.

Erosa tekstierottelu ja kysely

Suurille datamäärille suositeltu strategia erottaa nämä kaksi vaihetta toisistaan. Syötät jokaisen dokumentin OCR:n läpi, säilytät tuloksena syntyvän Markdownin ja rakennat sitten manuaalisesti LLM:lle lähetettävän kontekstin. Hyötynä on kontrolli: esimerkissä näkyvä typistys 5 000 merkkiin, jokaisen dokumentin nimen pitäminen otsikkona ja järjestelmäviesti, joka määrittelee roolin lakiasiantuntijana. Päätät tarkasti, mitä konteksti-ikkunaan päätyy, sen sijaan että antaisit sen tapahtua automaattisesti.

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-extraktio jokaiselle dokumentille
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"),
}

# Rakenna kehote kontekstin kanssa
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # Rajoita tarvittaessa
    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?"
            )
        }
    ]
)

Siirry dokumentti-RAG:iin

Muutaman kymmenen dokumentin jälkeen mikään konteksti-ikkuna ei enää riitä. Sinun on lähetettävä vain oleelliset kohdat, mikä edellyttää tekstien pilkkomista, niiden vektorointia mistral-embed:llä ja hakua samankaltaisuuden perusteella kyselyhetkellä. Pilkkominen 200 merkin päällekkäisyydellä estää lauseen merkityksen katoamisen, jos se katkeaa palasten väliin, ja top_k määrittää, kuinka monta kohtaa lopulta liitetään kysymykseen.

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


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

    # Kosinisuuruuden laskenta
    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]]

Tehdään yhteenveto valintalogiikasta. Useiden dokumenttien lähettäminen yhdellä pyynnöllä on lyömätön yksinkertaisuudessaan ja toimii hyvin kahdelle tai kolmelle lyhyelle dokumentille. Erillinen OCR followed by QnA tarjoaa joustavuutta ja antaa sinulle kontrollin siitä, mitä LLM:lle lähetetään, mutta vaatii hieman enemmän koodia. Dokumentti-RAG on raskaampi ottaa käyttöön, mutta siitä tulee välttämätön aineiston kasvaessa, koska se on ainoa skaalautuva lähestymistapa.

End-to-end-vertailutyönkulku

Näitä kahta tekniikkaa voi yhdistää: mikään ei estä sinua ensin erottamasta strukturoitua dataa annotaation kautta ja antamasta sitä sitten LLM:lle analysoitavaksi. Laskuerässä jokainen dokumentti pelkistetään kolmeen kenttään – toimittaja, summa, päivämäärä – ennen kuin yksi pyyntö kehottaa mallia tunnistamaan trendejä ja poikkeavuuksia. Token-kustannukset jäävät mitättömiksi, ja analyysi keskittyy siististi erotettuihin lukuihin eikä lennossa tulkittuun tekstiin.

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)

    # Vertaileva analyysi LLM:n avulla
    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

Keskeiset asiat

  • Kolme lähestymistapaa usean dokumentin kysymyksiin ja vastauksiin: suoraviivainen, erillinen OCR, RAG
  • Suoraviivainen menetelmä toimii 2–3 lyhyelle dokumentille
  • Erillinen OCR + QnA tarjoaa enemmän kontrollia kulutettuihin tokeneihin
  • RAG on välttämätön suurille aineistoille (kymmenet dokumentit)
  • Yhdistä strukturoidut annotaatiot QnA:han tarkkoja analyysejä varten