Integracja OCR + RAG
Na tej stronie
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 aliasumistral-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,…"}; typdocument_base64ze starszych przykładów nie istnieje ani w dokumentacji, ani w SDKmistralai, 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 zimage.image_annotation(SDKmistralai3.7.0), a nie zimage.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  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""
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