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

Integracja OCR + RAG

Lekcja 15 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Budowanie inteligentnego systemu dokumentowego
  2. Architektura pięcioetapowa
  3. Krok 1: Ekstrakcja bez utraty danych
  4. Krok 2: Chunking zgodny ze strukturą dokumentu
  5. Krok 3: Wektoryzacja i wyszukiwanie
  6. Krok 4: Generowanie odpowiedzi ze źródłami
  7. Od prototypu do bazy wektorowej
  8. Kluczowe wnioski

Aktualizacja z 2 listopada 2026 r. — OCR. Model OCR 4.0 (mistral-ocr-4-0) został wycofany 30 września 2026 r. Używaj OCR 4.1 (mistral-ocr-4-1), dostępnego ogólnie od 31 sierpnia w tej samej cenie, lub aliasu mistral-ocr-latest, który wskazuje na niego od 16 lipca. OCR 4.1 dodaje wyniki pewności na poziomie bloków. Dodatek 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 · Pytania i odpowiedzi dotyczące dokumentów. Dodatek z 3 listopada: Adnotacje obrazów są odczytywane z image.image_annotation (SDK mistralai 3.7.0), a nie z image.annotation.

Budowanie inteligentnego systemu dokumentowego

Retrieval-Augmented Generation (RAG) to technika, która umożliwia przeszukiwanie dużych zbiorów dokumentów. Łącząc OCR od Mistral, embeddingi i wektorową bazę danych, tworzysz system zdolny do odpowiadania na pytania dotyczące Twoich archiwów – czy to dziesięcioletnich raportów, repozytorium umów, czy zdigitalizowanej biblioteki technicznej.

Dlaczego używać OCR zamiast indeksować pliki „tak jak są“? Ponieważ fundamentalnym wyzwaniem w RAG dla dokumentów jest fakt, że indeksowane fragmenty muszą być tekstem. Embeddingi multimodalne nie są jeszcze wystarczająco wydajne, aby bezpośrednio porównywać pytania tekstowe z obrazami dokumentów. OCR pełni rolę mostu: konwertuje Twoje dokumenty w wysokiej jakości tekst strukturalny, który następnie indeksujesz w swojej bazie wektorowej.

Architektura pięcioetapowa

Wszystko zaczyna się od ingestii, czyli przyjmowania dokumentów, niezależnie od tego, czy przychodzą jako pliki PDF, obrazy, czy DOCX. Następnie następuje OCR z adnotacjami, generujący zarówno tekst, jak i strukturalne metadane. Chunking (podział na fragmenty) dzieli ten tekst na spójne segmenty, embedding wektoryzuje je i zapisuje w bazie wektorowej, a zapytanie zamyka pętlę: wyszukiwanie semantyczne wśród wektorów, a następnie generowanie odpowiedzi. Każdy etap warunkuje kolejny, a ekstrakcja decyduje o wszystkim – jeśli OCR coś pominie, żadne wyszukiwanie tego nie znajdzie.

Poniższe sekcje szczegółowo opisują kod dla czterech etapów, które napiszesz samodzielnie; ingestia zależy od Twojego konkretnego systemu przyjmowania danych.

Krok 1: Ekstrakcja bez utraty danych

Wywołanie OCR jest tutaj skonfigurowane pod kątem RAG, co widać w trzech wyborach. table_format="markdown" zachowuje tabele w formacie czytelnym dla LLM. Adnotacja bounding box opisuje obrazy, a kod następnie zastępuje każde odwołanie ![image](image) jego opisem tekstowym: wykres rozkładu przychodów staje się zdaniem podlegającym indeksacji, zamiast być luką w tekście. Na koniec, include_image_base64=False pozwala uniknąć pobierania megabajtów pikseli, które są bezużyteczne dla indeksu.

import os
import base64
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model
from pydantic import BaseModel, Field
from typing import Optional

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

class DescriptionImage(BaseModel):
    type_image: str = Field(..., description="Type: graph, table, photo, logo")
    description: str = Field(..., description="Content description")

def extraire_document_enrichi(chemin: str) -> list[dict]:
    """Extracts enriched content from a document for RAG."""
    with open(chemin, "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}"
        },
        table_format="markdown",
        bbox_annotation_format=response_format_from_pydantic_model(
            DescriptionImage
        ),
        include_image_base64=False  # Images not needed for RAG
    )

    pages = []
    for page in response.pages:
        contenu = page.markdown

        # Replace image references with their descriptions
        for image in page.images:
            if image.image_annotation:
                desc = DescriptionImage.model_validate_json(
                    image.image_annotation
                )
                placeholder = f"![{image.id}]({image.id})"
                remplacement = (
                    f"[{desc.type_image}: {desc.description}]"
                )
                contenu = contenu.replace(placeholder, remplacement)

        pages.append({
            "page": page.index + 1,
            "contenu": contenu,
            "header": page.header or "",
            "footer": page.footer or "",
        })

    return pages

Krok 2: Chunking zgodny ze strukturą dokumentu

Dzielenie co tysiąc znaków przecina zdania w połowie i oddziela nagłówki od ich treści. Skoro OCR dostarcza Ci Markdown, wykorzystaj jego strukturę: funkcja najpierw segmentuje tekst na podstawie nagłówków drugiego poziomu, zachowuje całą sekcję tylko wtedy, gdy mieści się w maksymalnym rozmiarze, a do akapitów ucieka się tylko w przypadku przekroczenia limitu. Każdy fragment zachowuje dzięki temu nagłówek swojej sekcji, co znacząco poprawia trafność wyszukiwania semantycznego.

def chunker_par_sections(
    texte: str,
    taille_max: int = 1000,
    chevauchement: int = 200
) -> list[str]:
    """Splits text respecting Markdown sections."""
    sections = texte.split("\n## ")
    chunks = []

    for section in sections:
        if not section.strip():
            continue

        # Reconstruct section heading
        if not section.startswith("## "):
            section = "## " + section

        if len(section) <= taille_max:
            chunks.append(section)
        else:
            # Sub-split by paragraphs
            paragraphes = section.split("\n\n")
            chunk_courant = ""

            for para in paragraphes:
                if len(chunk_courant) + len(para) > taille_max:
                    if chunk_courant:
                        chunks.append(chunk_courant.strip())
                    chunk_courant = para
                else:
                    chunk_courant += "\n\n" + para

            if chunk_courant:
                chunks.append(chunk_courant.strip())

    return chunks

Krok 3: Wektoryzacja i wyszukiwanie

Indeksowanie polega na wektoryzacji każdego fragmentu za pomocą mistral-embed i zapisaniu wraz z wektorem nazwy dokumentu oraz ID fragmentu – bez tych metadanych możesz odpowiedzieć, ale nie podasz źródeł. Wyszukiwanie wektoryzuje pytanie w ten sam sposób, a następnie oblicza podobieństwo cosinusowe znormalizowane przez normy obu wektorów, co zapobiega sytuacji, w której długi fragment „wygrywa“ tylko ze względu na swoją długość.

import numpy as np

def creer_index(documents: dict[str, list[dict]]) -> list[dict]:
    """Creates a vector index from extracted documents."""
    index = []

    for nom_doc, pages in documents.items():
        # Concatenate all pages
        texte_complet = "\n\n".join(p["contenu"] for p in pages)

        # Chunking
        chunks = chunker_par_sections(texte_complet)

        for i, chunk in enumerate(chunks):
            # Embedding
            response = client.embeddings.create(
                model="mistral-embed",
                inputs=[chunk]
            )

            index.append({
                "document": nom_doc,
                "chunk_id": i,
                "texte": chunk,
                "embedding": np.array(response.data[0].embedding),
                "page": pages[0]["page"] if pages else 0,
            })

    return index


def rechercher_chunks(
    question: str,
    index: list[dict],
    top_k: int = 5
) -> list[dict]:
    """Searches for the most relevant chunks."""
    response = client.embeddings.create(
        model="mistral-embed",
        inputs=[question]
    )
    q_emb = np.array(response.data[0].embedding)

    scores = []
    for item in index:
        similarite = np.dot(q_emb, item["embedding"]) / (
            np.linalg.norm(q_emb) * np.linalg.norm(item["embedding"])
        )
        scores.append((similarite, item))

    scores.sort(key=lambda x: x[0], reverse=True)
    return [item for _, item in scores[:top_k]]

Krok 4: Generowanie odpowiedzi ze źródłami

Ostatni element składa pięć najlepszych fragmentów w kontekst, każdy z prefiksem zawierającym dokument i numer, oraz narzuca modelowi ścisłą instrukcję: odpowiadaj wyłącznie na podstawie dostarczonego kontekstu i cytuj źródła. Ten prompt systemowy odróżnia asystenta dokumentowego od modelu, który improwizuje, i to właśnie dlatego zachowałeś metadane podczas indeksowania.

def repondre_question(question: str, index: list[dict]) -> str:
    """Answers a question using RAG."""
    # Search for relevant chunks
    resultats = rechercher_chunks(question, index, top_k=5)

    # Build context
    contexte = "\n\n---\n\n".join(
        f"[Source: {r['document']}, Chunk {r['chunk_id']}]\n{r['texte']}"
        for r in resultats
    )

    # Generate answer
    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a document assistant. Answer "
                    "questions based solely on the provided "
                    "context. Cite sources."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Context:\n{contexte}\n\n"
                    f"Question: {question}"
                )
            }
        ]
    )

    return response.choices[0].message.content

Od prototypu do bazy wektorowej

Indeks w pamięci działa dopóki masz do czynienia z kilkoma tysiącami fragmentów. Powyżej tej liczby wyszukiwanie liniowe załamuje się, a nic nie przetrwa restartu: przełącz się na prawdziwą bazę wektorową (Pinecone, Weaviate, Qdrant, ChromaDB). Zmiana ta jest niedroga, co pokazano w tej wersji z ChromaDB, gdzie zmienia się tylko magazynowanie i odpytywanie – Twoje funkcje ekstrakcji i chunkingu pozostają nienaruszone.

# Example with ChromaDB
import chromadb

chroma_client = chromadb.Client()
collection = chroma_client.create_collection(name="documents")

# Indexing
for item in index:
    collection.add(
        ids=[f"{item['document']}_{item['chunk_id']}"],
        embeddings=[item["embedding"].tolist()],
        documents=[item["texte"]],
        metadatas=[{"document": item["document"]}]
    )

# Search
resultats = collection.query(
    query_embeddings=[q_emb.tolist()],
    n_results=5
)

Kluczowe wnioski

  • Potok OCR + RAG przekształca Twoje dokumenty w bazę wiedzy gotową do odpytywania
  • Wzbogacenie poprzez adnotacje (opisy obrazów) zapobiega utracie informacji
  • Inteligentny chunking szanuje sekcje i akapity dokumentu
  • W środowisku produkcyjnym używaj prawdziwej bazy wektorowej (ChromaDB, Pinecone, Qdrant)
  • Jakość ekstrakcji OCR determinuje jakość odpowiedzi w systemie RAG