Integrare OCR + RAG
Pe această pagină
Actualizare 2 noiembrie 2026 — OCR. OCR 4.0 (
mistral-ocr-4-0) a fost retras la 30 septembrie 2026. Utilizați OCR 4.1 (mistral-ocr-4-1), disponibil din 31 august la același preț, sau aliasulmistral-ocr-latest, care indică spre acesta din 16 iulie. OCR 4.1 adaugă scoruri de încredere la nivel de bloc. Addendum 3 noiembrie 2026: Un fișier PDF local este transmis în base64 sub forma{"type": "document_url", "document_url": "data:application/pdf;base64,…"}; tipuldocument_base64din exemplele mai vechi nu există nici în documentație, nici în SDK-ulmistralai, iar acele exemple ar fi eșuat. Surse: Procesor OCR · Întrebări și răspunsuri despre documente. Addendum 3 noiembrie: Anotațiile imaginilor sunt citite dinimage.image_annotation(SDKmistralai3.7.0), nu dinimage.annotation.
Construirea unui sistem inteligent de documente
Generarea Augmentată prin Recuperare (RAG) este tehnica care face interogabile corpusurile mari de documente. Prin combinarea OCR-ului Mistral, a embedding-urilor și a unui stoc vectorial, creați un sistem capabil să răspundă la întrebări despre arhivele dumneavoastră—zece ani de rapoarte, un depozit de contracte sau o bibliotecă tehnică digitalizată.
De ce să folosiți OCR în loc să indexați fișierele așa cum sunt? Pentru că provocarea fundamentală a RAG pentru documente este faptul că fragmentele indexate trebuie să fie text. Embedding-urile multimodale nu sunt încă suficient de performante pentru a compara direct întrebările text cu imaginile documentelor. OCR servește drept punte: convertește documentele dumneavoastră în text structurat de înaltă calitate, pe care îl indexați apoi în stocul vectorial.
Arhitectura în cinci pași
Totul începe cu ingestia, adică recepționarea documentelor, fie că acestea sosesc sub formă de PDF-uri, imagini sau fișiere DOCX. Urmează OCR-ul cu adnotări, care produce atât text, cât și metadate structurate. Fragmentarea (chunking) taie acest text în segmente coerente, embedding-ul le vectorizează și le stochează în baza de date vectorială, iar interogarea închide bucla: căutare semantică printre vectori, urmată de generarea răspunsului. Fiecare pas îl condiționează pe următorul, iar extracția determină totul—dacă OCR-ul ratează ceva, nicio căutare nu va găsi acel element.
Secțiunile următoare detaliază codul pentru cei patru pași pe care îi veți scrie dumneavoastră; ingestia depinde de sistemul dumneavoastră specific de preluare.
Pasul 1: Extracție fără pierderi
Apelul OCR de aici este configurat pentru RAG, lucru evident în trei alegeri. table_format="markdown" păstrează tabelele într-un format pe care LLM îl poate citi. Adnotarea cu casete de delimitare (bounding box) descrie imaginile, iar codul înlocuiește ulterior fiecare referință  cu descrierea sa textuală: un grafic de distribuție a veniturilor devine o propoziție indexabilă în loc de o lacună în text. În final, include_image_base64=False evită descărcarea a megabytes de pixeli de care indexul nu are nevoie.
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
Pasul 2: Fragmentare adaptată structurii documentului
Divizarea la fiecare o mie de caractere taie propozițiile la jumătate și separă un titlu de conținutul său. Deoarece OCR vă oferă Markdown, valorificați structura acestuia: funcția segmentează mai întâi pe baza titlurilor de nivel doi, păstrează întreaga secțiune doar dacă se încadrează în dimensiunea maximă și recurge la paragrafe doar când există un depășire. Astfel, fiecare fragment își păstrează titlul de secțiune, ceea ce îmbunătățește semnificativ relevanța căutării semantice.
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
Pasul 3: Vectorizare și căutare
Indexarea vectorizează fiecare fragment cu mistral-embed și stochează, alături de vector, numele documentului și ID-ul fragmentului—fără aceste metadate, puteți răspunde, dar nu puteți cita sursele. Căutarea vectorizează întrebarea în același mod, apoi calculează similaritatea cosinus normalizată prin normele ambilor vectori, prevenind ca un fragment lung să câștige doar pentru că este lung.
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]]
Pasul 4: Generarea unui răspuns sourstat
Piesa finală asamblează cele mai bune cinci fragmente într-un context, fiecare fiind prefixat cu documentul și numărul său, și impune modelului o instrucțiune strictă: răspundeți doar pe baza contextului furnizat și citați sursele. Acest prompt de sistem distinge un asistent de documente de un model care improvizează, și acesta este motivul pentru care ați păstrat metadatele în timpul indexării.
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
De la prototip la stoc vectorial
Un index în memorie funcționează atâta timp cât rămâneți sub câteva mii de fragmente. Dincolo de acest prag, căutarea liniară se prăbușește și nimic nu supraviețuiește unei reporniri: treceți la un stoc vectorial real (Pinecone, Weaviate, Qdrant, ChromaDB). Trecerea este peu coûteuse, așa cum se arată în această variantă ChromaDB unde doar stocarea și interogarea se schimbă—funcțiile dumneavoastră de extracție și fragmentare rămân intacte.
# 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
)
Puncte cheie
- Fluxul OCR + RAG convertește documentele dumneavoastră într-o bază de cunoștințe interogabilă
- Îmbogățirea prin adnotări (descrieri de imagini) previne pierderea informațiilor
- Fragmentarea inteligentă respectă secțiunile și paragrafele documentului
- Utilizați un stoc vectorial real în producție (ChromaDB, Pinecone, Qdrant)
- Calitatea extracției OCR determină calitatea răspunsurilor RAG