Integrace OCR + RAG
Na této stránce
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 aliasmistral-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,…"}; typdocument_base64ze starších příkladů neexistuje ani v dokumentaci, ani v SDKmistralaia tyto příklady by selhaly. Zdroje: OCR Processor · Document QnA. Dodatek 3. listopadu: Anotace obrázků se čtou zimage.image_annotation(SDKmistralai3.7.0), nikoliv zimage.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  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""
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