Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Integrácia OCR + RAG

Lekcia 15 z 16 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Budovanie inteligentného systému pre dokumenty
  2. Päťkroková architektúra
  3. Krok 1: Extrakcia bez straty informácií
  4. Krok 2: Rozdeľovanie rešpektujúce štruktúru dokumentu
  5. Krok 3: Vektorizácia a vyhľadávanie
  6. Krok 4: Generovanie odpovede so zdrojmi
  7. Od prototypu k vektorovému úložisku
  8. Kľúčové poznatky

Aktualizácia 2. novembra 2026 — OCR. Verzia OCR 4.0 (mistral-ocr-4-0) bola vyradená 30. septembra 2026. Používaj OCR 4.1 (mistral-ocr-4-1), ktorá je všeobecne dostupná od 31. augusta za rovnakú cenu, alebo alias mistral-ocr-latest, ktorý na ňu odkazuje od 16. júla. OCR 4.1 pridáva skóre spoľahlivosti na úrovni blokov. Dodatok 3. novembra 2026: Lokálny súbor PDF sa odosiela v kódovaní base64 ako {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; typ document_base64 zo starších príkladov neexistuje ani v dokumentácii, ani v SDK mistralai a tieto príklady by zlyhali. Zdroje: OCR Processor · Document QnA. Dodatok 3. novembra: Anotácie obrázkov sa čítajú z image.image_annotation (SDK mistralai 3.7.0), nie z image.annotation.

Budovanie inteligentného systému pre dokumenty

Retrieval-Augmented Generation (RAG) je technika, ktorá umožňuje vyhľadávanie vo veľkých súboroch dokumentov. Kombináciou OCR od Mistralu, vektorových reprezentácií (embeddings) a vektorového úložiska vytvoríš systém schopný odpovedať na otázky týkajúce sa tvojich archívov – či už ide o desať rokov správ, repository zmlúv alebo digitalizovanú technickú knižnicu.

Prečo použiť OCR namiesto indexovania súborov tak, ako sú? Pretože základnou výzvou dokumentového RAG je, že indexované časti musia byť textové. Multimodálne vektorové reprezentácie zatiaľ nie sú dostatočne výkonné na priame porovnávanie textových otázok s obrázkami dokumentov. OCR slúži ako most: prevádza tvoje dokumenty na vysoko kvalitný štruktúrovaný text, ktorý následne indexuješ vo svojom vektorovom úložisku.

Päťkroková architektúra

Všetko začína ingestiou, teda prijímaním dokumentov, či už prichádzajú ako PDF, obrázky alebo súbory DOCX. Nasleduje OCR s anotáciami, ktoré produkuje text aj štruktúrované metadáta. Rozdeľovanie (chunking) krája tento text na súvislé segmenty, vektorizácia ich mení na číselné vektory a ukladá do vektorového úložiska a dopyt uzatvára cyklus: sémantické vyhľadávanie medzi vektormi, po ktorom nasleduje generovanie odpovede. Každý krok podmieňuje ten ďalší a extrakcia určuje všetko ostatné – ak ju OCR prehliadne, žiadne vyhľadávanie ju nenájde.

Nasledujúce časti podrobne opisujú kód pre štyri kroky, ktoré napíšeš sám; ingestia závisí od tvojho konkrétneho systému prijímania dát.

Krok 1: Extrakcia bez straty informácií

Volanie OCR je tu nakonfigurované špeciálne pre RAG, čo je zrejmé z troch volieb. table_format="markdown" zachováva tabuľky vo formáte, ktorý LLM dokáže čítať. Anotácia ohraničovacích boxov (bounding box) opisuje obrázky a kód následne nahradí každý odkaz ![image](image) jeho textovým popisom: graf rozdelenia výnosov sa tak stane indexovateľnou vetou namiesto diery v texte. Nakoniec, include_image_base64=False zabraňuje sťahovaniu megabajtov pixelov, ktoré index nepotrebuje.

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: Rozdeľovanie rešpektujúce štruktúru dokumentu

Rozdeľovanie každých tisíc znakov orezáva vety v polovici a oddeľuje nadpis od jeho obsahu. Keďže OCR ti poskytuje Markdown, využi jeho štruktúru: funkcia najprv rozdelí text podľa nadpisov druhej úrovne, celú sekciu ponechá len vtedy, ak sa zmestí do maximálnej veľkosti, a k odsekom sa uchýli až v prípade pretečenia. Každý chunk si tak zachováva nadpis svojej sekcie, čo výrazne zlepšuje relevantnosť sémantického vyhľadávania.

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: Vektorizácia a vyhľadávanie

Indexovanie prevedie každý chunk na vektor pomocou mistral-embed a uloží ho spolu s názvom dokumentu a ID chunku – bez týchto metadát by si síce vedel odpovedať, ale nie citovať zdroje. Vyhľadávanie prevedie otázku rovnakým spôsobom na vektor a následne vypočíta kosínusovú podobnosť normalizovanú normami oboch vektorov, čím sa zabráni tomu, aby dlhší chunk vyhral len preto, že je dlhý.

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: Generovanie odpovede so zdrojmi

Posledný krok zostaví päť najrelevantnejších chunkov do kontextu, pričom každý je prefixed názvom dokumentu a číslom, a modelu uloží prísny príkaz: odpovedaj výlučne na základe poskytnutého kontextu a cituj zdroje. Tento systémový prompt odlišuje asistenta pre dokumenty od modelu, ktorý si vymýšľa, a je dôvodom, prečo si počas indexovania zachoval metadáta.

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 k vektorovému úložisku

Index v pamäti funguje, pokiaľ zostaneš pod niekoľkými tisíckami chunkov. Nad touto hranicou lineárne vyhľadávanie kolabuje a po reštarte nič neprežije: prepnite sa na skutočné vektorové úložisko (Pinecone, Weaviate, Qdrant, ChromaDB). Tento prechod nie je nákladný, ako ukazuje táto varianta s ChromaDB, kde sa mení len ukladanie a dopytovanie – tvoje funkcie pre extrakciu a rozdeľovanie zostávajú nedotknuté.

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

Kľúčové poznatky

  • Pipeline OCR + RAG prevádza tvoje dokumenty na vyhľadávateľnú znalostnú bázu
  • Obohatenie pomocou anotácií (popisy obrázkov) zabraňuje strate informácií
  • Inteligentné rozdeľovanie rešpektuje sekcie a odseky dokumentu
  • V produkcii používaj skutočné vektorové úložisko (ChromaDB, Pinecone, Qdrant)
  • Kvalita extrakcie OCR určuje kvalitu odpovedí RAG