Salt la conținutul principal
Română— Alege o limbă
Meniu

Integrare OCR + RAG

Lecția 15 din 16 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Construirea unui sistem inteligent de documente
  2. Arhitectura în cinci pași
  3. Pasul 1: Extracție fără pierderi
  4. Pasul 2: Fragmentare adaptată structurii documentului
  5. Pasul 3: Vectorizare și căutare
  6. Pasul 4: Generarea unui răspuns sourstat
  7. De la prototip la stoc vectorial
  8. Puncte cheie

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 aliasul mistral-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,…"}; tipul document_base64 din exemplele mai vechi nu există nici în documentație, nici în SDK-ul mistralai, 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 din image.image_annotation (SDK mistralai 3.7.0), nu din image.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ță ![image](image) 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"![{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

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