Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Integrace OCR + RAG

Lekce 15 z 16 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Budování inteligentního systému pro práci s dokumenty
  2. Pětikroková architektura
  3. Krok 1: Extrakce bez ztráty informací
  4. Krok 2: Rozdělování respektující strukturu dokumentu
  5. Krok 3: Vektorizace a vyhledávání
  6. Krok 4: Generování odpovědi se zdroji
  7. Od prototypu k vektorové databázi
  8. Klíčové poznatky

Aktualizace 2. listopadu 2026 — OCR. Verze OCR 4.0 (mistral-ocr-4-0) byla 30. září 2026 vyřazena z provozu. Používej OCR 4.1 (mistral-ocr-4-1), které je obecně dostupné od 31. srpna za stejnou cenu, nebo alias mistral-ocr-latest, který na něj odkazuje od 16. července. OCR 4.1 přidává skóre spolehlivosti na úrovni bloků. Dodatek 3. listopadu 2026: Lokální PDF se přenáší v base64 jako {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; typ document_base64 ze starších příkladů neexistuje ani v dokumentaci, ani v SDK mistralai a tyto příklady by selhaly. Zdroje: OCR Processor · Document QnA. Dodatek 3. listopadu: Anotace obrázků se čtou z image.image_annotation (SDK mistralai 3.7.0), nikoliv z image.annotation.

Budování inteligentního systému pro práci s dokumenty

Retrieval-Augmented Generation (RAG) je technika, která umožňuje dotazovat se na rozsáhlé soubory dokumentů. Kombinací Mistral OCR, vektorových reprezentací (embeddings) a vektorové databáze vytvoříš systém schopný odpovídat na otázky týkající se tvých archivů – ať už jde o desetiletí reportů, úložiště smluv nebo digitalizovanou technickou knihovnu.

Proč použít OCR místo indexování souborů v původní podobě? Protože základní výzvou dokumentového RAG je fakt, že indexované části musí být textové. Multimodální vektorové reprezentace zatím nejsou dostatečně výkonné na přímé porovnávání textových otázek s obrázky dokumentů. OCR slouží jako most: převádí tvé dokumenty na vysoce kvalitní strukturovaný text, který následně indexuješ ve své vektorové databázi.

Pětikroková architektura

Vše začíná ingestí, tedy přijímáním dokumentů, ať už přicházejí jako PDF, obrázky nebo soubory DOCX. Následuje OCR s anotacemi, které produkují jak text, tak strukturovaná metadata. Rozdělování (chunking) krájí tento text na ucelené segmenty, vektorizace je převede na číselné vektory a uloží do vektorové databáze a dotazování uzavírá smyčku: sémantické vyhledávání mezi vektory, po němž následuje generování odpovědi. Každý krok podmínkuje ten další a kvalita extrakce určuje vše ostatní – pokud to OCR přehlédne, žádné vyhledávání to nenajde.

Následující sekce podrobně popisují kód pro čtyři kroky, které napíšeš sám; ingest závisí na tvém konkrétním systému pro příjem dat.

Krok 1: Extrakce bez ztráty informací

Volání OCR je zde nakonfigurováno speciálně pro RAG, což je patrné ze tří voleb. table_format="markdown" zachovává tabulky ve formátu čitelném pro LLM. Anotace ohraničujících rámečků (bounding box) popisuje obrázky a kód následně nahrazuje každý odkaz ![image](image) jeho textovým popisem: graf rozložení výnosů se tak stane indexovatelnou větou místo mezery v textu. Nakonec include_image_base64=False zabraňuje stahování megabajtů pixelů, které index k ničemu nepotřebuje.

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: Rozdělování respektující strukturu dokumentu

Rozdělování každých tisíc znaků řeší věty uprostřed a odděluje nadpis od jeho obsahu. Protože ti OCR poskytuje Markdown, využij jeho strukturu: funkce nejprve segmentuje text podle nadpisů druhé úrovně, celou sekci ponechá pouze pokud se vejde do maximální velikosti, a k rozdělení na odstavce přistoupí pouze v případě přetečení. Každý chunk si tak zachová nadpis své sekce, což významně zlepšuje relevanci sémantického vyhledávání.

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: Vektorizace a vyhledávání

Indexování převede každý chunk na vektor pomocí mistral-embed a uloží jej společně s názvem dokumentu a ID chunku – bez těchto metadat umíš sice odpovědět, ale nemůžeš citovat zdroje. Vyhledávání převede otázku stejným způsobem na vektor a následně vypočítá kosinovou podobnost normalizovanou normami obou vektorů, čímž se zabrání tomu, aby dlouhý chunk „vyhrál“ pouze kvůli své délce.

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: Generování odpovědi se zdroji

Poslední díl skládá pět nejrelevantnějších chunků do kontextu, každý s prefixem obsahujícím název dokumentu a číslo, a modelu ukládá přísný instrukci: odpovídej pouze na základě poskytnutého kontextu a cituj zdroje. Tento systémový prompt odlišuje asistenta pro práci s dokumenty od modelu, který si vymýšlí, a je důvodem, proč jsi během indexování zachovával metadata.

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é databázi

Index v paměti funguje, dokud se pohybuješ pod hranicí několika tisíc chunků. Nad touto hranicí lineární vyhledávání zkolabuje a po restartu nic nepřežije: přejdi na skutečnou vektorovou databázi (Pinecone, Weaviate, Qdrant, ChromaDB). Přechod je nenákladný, jak ukazuje tato varianta s ChromaDB, kde se mění pouze ukládání a dotazování – tvé funkce pro extrakci a rozdělování zůstávají nedotčeny.

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

Klíčové poznatky

  • Pipeline OCR + RAG převádí tvé dokumenty na dotazovatelnou znalostní bázi
  • Obohacení pomocí anotací (popisy obrázků) zabraňuje ztrátě informací
  • Inteligentní rozdělování respektuje sekce a odstavce dokumentu
  • V produkci používej skutečnou vektorovou databázi (ChromaDB, Pinecone, Qdrant)
  • Kvalita extrakce pomocí OCR určuje kvalitu odpovědí v RAG