Przejdź do głównej treści
Polski— Wybierz język
Menu

QnA wielodokumentowe

Lekcja 14 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Gdy odpowiedź obejmuje wiele plików
  2. Wyślij wszystko w jednym wywołaniu
  3. Rozdzielenie ekstrakcji od odpytywania
  4. Przejście do RAG dla dokumentów
  5. Kompleksowy przepływ pracy porównawczy
  6. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 r. — OCR. Wersja OCR 4.0 (mistral-ocr-4-0) została wycofana 30 września 2026 r. Używaj OCR 4.1 (mistral-ocr-4-1), który jest ogólnie dostępny od 31 sierpnia w tej samej cenie, lub aliasu mistral-ocr-latest, który wskazuje na tę wersję od 16 lipca. OCR 4.1 dodaje wyniki pewności na poziomie bloków. Dodatkowa uwaga z 3 listopada 2026 r.: Lokalny plik PDF jest przesyłany w formacie base64 jako {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; typ document_base64 ze starszych przykładów nie istnieje ani w dokumentacji, ani w SDK mistralai, a takie przykłady zakończyłyby się niepowodzeniem. Źródła: Procesor OCR · QnA dotyczące dokumentów. Poprawiono 3 listopada 2026 r.: Poprzedni kod odczytywał page.document_annotation strona po stronie; w SDK mistralai w wersji 3.7.0 adnotacja dokumentu jest pojedynczym polem w odpowiedzi (response.document_annotation), a adnotację obrazu odczytuje się z image.image_annotation.

Gdy odpowiedź obejmuje wiele plików

W wielu scenariuszach zawodowych odpowiedzi na pytanie nie znajdziesz w pojedynczym dokumencie. Możesz potrzebować porównać umowy, skrzyżować faktury z zamówieniami zakupu lub przeanalizować serię raportów. Istnieją trzy strategie, a najlepsze podejście polega na wyborze metody w oparciu o objętość danych, zamiast od razu sięgać po najbardziej zaawansowane opcje.

Wyślij wszystko w jednym wywołaniu

Najbardziej bezpośrednią metodą jest ułożenie wielu bloków document_url w tej samej wiadomości. Model widzi obie umowy obok siebie i może je rzeczywiście porównać, czego nie da się osiągnąć poprzez przetwarzanie strona po stronie. Przełączamy się tutaj na mistral-large-latest, ponieważ porównywanie wymaga wnioskowania, a nie tylko czytania.

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": (
                        "Porównaj warunki płatności "
                        "tych dwóch umów."
                    )
                },
                {
                    "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)

Ograniczenie pojawia się szybko: suma rozmiarów dokumentów nie może przekroczyć okna kontekstowego modelu. Dwie dziesięciostronicowe broszury przejdą bez problemu; dwie dwustustronicowe umowy ramowe – już nie.

Rozdzielenie ekstrakcji od odpytywania

W przypadku dużych wolumenów zalecaną strategią jest rozdzielenie tych dwóch kroków. Przepuszczasz każdy dokument przez OCR, zachowujesz wynikowy Markdown, a następnie ręcznie budujesz kontekst wysyłany do LLM. Korzyścią jest kontrola: przycinanie do 5000 znaków widoczne w przykładzie, zachowanie nazwy każdego dokumentu jako nagłówka sekcji oraz wiadomość systemowa ustalająca rolę asystenta prawnego. To Ty decydujesz, co dokładnie trafi do okna kontekstowego, zamiast pozwalać, by działo się to automatycznie.

import os
from mistralai.client import Mistral

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

def extract_text(url: str) -> str:
    """Ekstrahuje tekst z dokumentu poprzez 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)


# Ekstrakcja OCR dla każdego dokumentu
documents = {
    "Umowa A": extract_text("https://example.com/contract-A.pdf"),
    "Umowa B": extract_text("https://example.com/contract-B.pdf"),
    "Umowa C": extract_text("https://example.com/contract-C.pdf"),
}

# Budowanie promptu z kontekstem
context = "\n\n---\n\n".join(
    f"## {name}\n\n{text[:5000]}"  # Ogranicz w razie potrzeby
    for name, text in documents.items()
)

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": (
                "Jesteś asystentem prawnym. Przeanalizuj "
                "dostarczone dokumenty i odpowiedz na pytania."
            )
        },
        {
            "role": "user",
            "content": (
                f"Oto dokumenty:\n\n{context}\n\n"
                f"Pytanie: Która umowa oferuje najlepsze "
                f"warunki wcześniejszego rozwiązania?"
            )
        }
    ]
)

Przejście do RAG dla dokumentów

Po przekroczeniu kilkudziesięciu dokumentów żadne okno kontekstowe nie będzie wystarczające. Musisz wtedy wysyłać tylko odpowiednie fragmenty, co wymaga podziału tekstów, wektoryzacji za pomocą mistral-embed i wyszukiwania przez podobieństwo w momencie zadawania pytania. Dzielenie na fragmenty (chunking) z 200-znakowym nakładem zapobiega utracie znaczenia zdania przeciętego na pół między fragmentami, a parametr top_k określa, ile fragmentów ostatecznie towarzyszyć będzie pytaniu.

import os
from mistralai.client import Mistral

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

def create_embeddings(text: str) -> list[float]:
    """Tworzy embeddingi dla tekstu."""
    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]:
    """Dzieli tekst na fragmenty z nakładem."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap
    return chunks


# Uproszczony potok RAG
def index_document(name: str, text: str) -> list[dict]:
    """Indeksuje dokument do wyszukiwania."""
    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]:
    """Wyszukuje najbardziej odpowiednie fragmenty."""
    q_embedding = create_embeddings(query)

    # Obliczanie podobieństwa kosinusowego
    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]]

Podsumujmy logikę wyboru. Wysyłanie wielu dokumentów w jednym wywołaniu pozostaje niezrównane pod względem prostoty i sprawdza się dobrze w przypadku dwóch lub trzech krótkich dokumentów. Oddzielne OCR, a następnie QnA, zapewnia elastyczność i daje Ci kontrolę nad tym, co jest wysyłane do LLM, kosztem nieco większej ilości kodu. RAG dla dokumentów jest trudniejszy w konfiguracji, ale staje się niezbędny wraz ze wzrostem korpusu, ponieważ jest to jedyne podejście, które skaluje się poprawnie.

Kompleksowy przepływ pracy porównawczy

Obie techniki można łączyć: nic nie stoi na przeszkodzie, aby najpierw wydobyć ustrukturyzowane dane poprzez adnotację, a następnie przekazać te dane do LLM w celu analizy. W partii faktur każdy dokument jest redukowany do trzech pól – dostawca, kwota, data – zanim pojedyncze żądanie poprosi model o zidentyfikowanie trendów i anomalii. Koszt tokenów staje się znikomy, a analiza skupia się na czysto wydobytych liczbach, a nie na tekście interpretowanym na bieżąco.

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="Nazwa dostawcy")
    amount_inc_tax: float = Field(..., description="Kwota brutto")
    date: str = Field(..., description="Data (RRRR-MM-DD)")

def compare_invoices(paths: list[str]) -> str:
    """Porównuje wiele faktur i zwraca 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)

    # Analiza porównawcza przez 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"Oto {len(invoices)} faktur:\n{summary}\n\n"
                    f"Przeanalizuj trendy i anomalie."
                )
            }
        ]
    )

    return response.choices[0].message.content

Kluczowe wnioski

  • Trzy podejścia do QnA wielodokumentowego: wbudowane, oddzielne OCR, RAG
  • Podejście wbudowane sprawdza się dla 2–3 krótkich dokumentów
  • Oddzielne OCR + QnA oferuje większą kontrolę nad zużytymi tokenami
  • RAG jest niezbędny dla dużych korpusów (dziesiątki dokumentów)
  • Łącz ustrukturyzowane adnotacje z QnA, aby uzyskać precyzyjne analizy