Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Integrazzjoni OCR + RAG

Lezzjoni 15 / 16 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Bini ta’ sistema intelliġenti tad-dokumenti
  2. L-arkitettura f’ħames passi
  3. Pass 1: Estrazzjoni li ma titlef xejn
  4. Pass 2: Qtugħ fejn id-dokument jippermetti
  5. Pass 3: Ivvettorizza u fittex
  6. Pass 4: Iġġenera tweġiba b’sorsi
  7. Mill-prototip għall-maħżen vettorjali
  8. Punti Ewlenin

Aġġornament tat-2 ta’ Novembru, 2026 — OCR. L-OCR 4.0 (mistral-ocr-4-0) ġie rtirat fit-30 ta’ Settembru, 2026. Uża OCR 4.1 (mistral-ocr-4-1), disponibbli ġeneralment mill-31 ta’ Awwissu bl-istess prezz, jew l-alias mistral-ocr-latest, li jipponta lejh mis-16 ta’ Lulju. L-OCR 4.1 iżid punteġġi ta’ kunfidenza fil-livell tal-blokki. Addendum tat-3 ta’ Novembru, 2026: PDF lokali jiġi trażmess f’base64 bħala {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; it-tip document_base64 minn eżempji aktar antiki ma jeżistix fid-dokumentazzjoni u lanqas fl-SDK mistralai, u dawk l-eżempji kienu jfallu. Sorsi: OCR Processor · Document QnA. Addendum tat-3 ta’ Novembru: L-annotazzjonijiet tal-immaġni jinqraw minn image.image_annotation (SDK mistralai 3.7.0), mhux image.annotation.

Bini ta’ sistema intelliġenti tad-dokumenti

Ir-Retrieval-Augmented Generation (RAG) hija t-teknika li tagħmel korpi kbar ta’ dokumenti suġġetti għal mistoqsijiet. Billi tgħaqqad l-OCR ta’ Mistral, l-embeddings u maħżen vettorjali, toħloq sistema kapaċi twieġeb mistoqsijiet dwar l-arkivji tiegħek—għaxar snin ta’ rapporti, repożitorju ta’ kuntratti, jew librerija teknika diġitalizzata.

Għaliex tuża OCR minflok tindiċja l-fajls kif inhuma? Għax l-isfida fundamentali tar-RAG tad-dokumenti hija li l-biċċiet indiċjati jridu jkunu test. L-embeddings multimodali għadhom mhux performanti biżżejjed biex iqabblu direttament mistoqsijiet tat-test ma’ immaġini ta’ dokumenti. L-OCR iservi bħala l-pont: jikkonverti d-dokumenti tiegħek f’test strutturat ta’ kwalità għolja, li mbagħad tindiċja fil-maħżen vettorjali tiegħek.

L-arkitettura f’ħames passi

Kollox jibda bl-ingestjoni, jiġifieri r-riċevuta ta’ dokumenti, kemm jekk jaslu bħala PDFs, immaġni jew fajls DOCX. Imbagħad jiġi l-OCR bl-annotazzjonijiet, li jipproduċi kemm test kif ukoll metadata strutturat. Il-qtugħ (chunking) jaqsam dan it-test f’segmenti koerenti, l-embedding jivvetturalihom u jaħżinhom fil-maħżen vettorjali, u l-mistoqsija tagħlaq iċ-ċirkolu: tiftix semantiku fost il-vetturi, segwit mill-ġenerazzjoni tat-tweġiba. Kull pass jikkundizzjona li jmiss, u l-estrazzjoni tiddetermina kollox ieħor—jekk l-OCR jitlifha, l-ebda tfittxija ma ssibha.

It-taqsimiet li ġejjin jiddettaljaw il-kodiċi għall-erba’ passi li se tikteb int stess; l-ingestjoni tiddependi mis-sistema ta’ dħul speċifika tiegħek.

Pass 1: Estrazzjoni li ma titlef xejn

Is-sejħa tal-OCR hawnhekk hija kkonfigurata għar-RAG, evidenti f’tliet għażliet. table_format="markdown" iżomm it-tabelli f’format li l-LLM jista’ jaqra. L-annotazzjoni tal-kaxxa tal-limitu (bounding box) tiddeskrivi l-immaġni, u l-kodiċi sussegwentement jissostitwixxi kull referenza ![image](image) bid-deskrizzjoni testwali tagħha: grafiku tad-distribuzzjoni tad-dħul isir sentenza indiċjabbli minflok vojt fit-test. Fl-aħħar nett, include_image_base64=False jevita l-ġbir ta’ megabytes ta’ pixels li l-indiċi m’għandux bżonnhom.

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

Pass 2: Qtugħ fejn id-dokument jippermetti

Li taqsam kull elf karattru jaqta’ f’nofs sentenza u jifred titlu mill-kontenut tiegħu. Peress li l-OCR jagħtijek Markdown, sfrutta l-istruttura tiegħu: il-funzjoni l-ewwel taqsam fuq it-titoli tal-livell tnejn, iżżomm is-sezzjoni sħiħa biss jekk tidħol fil-limitu massimu tad-daqs, u terġa’ lura għall-paragrafi biss meta tkun mimlija żżejjed. Kull biċċa (chunk) b’hekk iżżomm it-titlu tas-sezzjoni tagħha, li jtejjeb b’mod sinifikanti r-rilevanza tat-tiftix semantiku.

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

Pass 3: Ivvettorizza u fittex

L-indiċjar jivvettoralizza kull biċċa b’mistral-embed u jaħżen, flimkien mal-vettur, l-isem tad-dokument u l-ID tal-biċċa—mingħajr din il-metadata, tista’ twieġeb iżda ma tistax tiċċita s-sorsi. It-tiftix jivvettoralizza l-mistoqsija bl-istess mod, imbagħad jikkalkula s-similarità tal-kożinu normalizzata bin-normi taż-żewġ vetturi, u b’hekk jipprevjeni li biċċa twila tirbaħ sempliċiment għax hija twila.

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]]

Pass 4: Iġġenera tweġiba b’sorsi

Il-biċċa finali tgħaqqad l-aqwa ħames biċċiet f’kuntest, kull waħda mpreċeduta mid-dokument u n-numru tagħha, u timponi istruzzjoni stretta fuq il-mudell: wieġeb biss mill-kuntest ipprovdut u ċċita s-sorsi. Dan il-prompt tas-sistema jiddistingwi assistent tad-dokumenti minn mudell li jimprowviża, u għalhekk ippreservajt il-metadata waqt l-indiċjar.

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

Mill-prototip għall-maħżen vettorjali

Indiċi fil-memorja jaħdem sakemm tibqa’ taħt ftit eluf ta’ biċċiet. Lil hinn minn hekk, it-tiftix lineari jfalli u xejn ma jibqa’ ħaj wara riavvju: ibdel għal maħżen vettorjali reali (Pinecone, Weaviate, Qdrant, ChromaDB). Il-bidla hija irħisa, kif muri f’din il-varjanti ta’ ChromaDB fejn biss il-ħażna u t-tiftix jinbidlu—il-funzjonijiet ta’ estrazzjoni u qtugħ tiegħek jibqgħu intatti.

# 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
)

Punti Ewlenin

  • Il-pipeline OCR + RAG jikkonverti d-dokumenti tiegħek f’bażi ta’ għarfien suġġetta għal mistoqsijiet
  • L-arrikkiment permezz ta’ annotazzjonijiet (deskrizzjonijiet tal-immaġni) jipprevjeni t-telf ta’ informazzjoni
  • Il-qtugħ intelliġenti jirrispetta s-sezzjonijiet u l-paragrafi tad-dokument
  • Uża maħżen vettorjali reali fil-produzzjoni (ChromaDB, Pinecone, Qdrant)
  • Il-kwalità tal-estrazzjoni tal-OCR tiddetermina l-kwalità tat-tweġibiet tar-RAG