Integrácia OCR + RAG
Na tejto strane
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 aliasmistral-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,…"}; typdocument_base64zo starších príkladov neexistuje ani v dokumentácii, ani v SDKmistralaia tieto príklady by zlyhali. Zdroje: OCR Processor · Document QnA. Dodatok 3. novembra: Anotácie obrázkov sa čítajú zimage.image_annotation(SDKmistralai3.7.0), nie zimage.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  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""
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