Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Comhtháthú OCR + RAG

Ceacht 15 as 16 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Córas cliste doiciméad a thógáil
  2. An ailtireacht cúig chéim
  3. Céim 1: Asbhaint nach gcailleann aon rud
  4. Céim 2: Píosaíocht de réir mar a ligeann an doiciméad
  5. Céim 3: Veicteoireacht agus cuardach
  6. Céim 4: Freagra foinsithe a ghiniúint
  7. Ó fréamhshamhail go stóras veicteoireach
  8. Príomhphointí

Nuashonrú 2 Samhain 2026 — OCR. Cuireadh deireadh le OCR 4.0 (mistral-ocr-4-0) ar an 30 Meán Fómhair 2026. Bain úsáid as OCR 4.1 (mistral-ocr-4-1), atá ar fáil go ginearálta ón 31 Lúnasa ar an bpraghas céanna, nó an t-ailias mistral-ocr-latest, a dhíríonn air ón 16 Iúil. Cuirtear scóir muiníne ar leibhéal na mbloc leis an OCR 4.1. Forlíonadh 3 Samhain 2026: Seoltar PDF áitiúil i mbonn64 mar {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; níl an cineál document_base64 ó shamplaí níos sine le fáil sa doiciméadú ná san SDK mistralai, agus theipfeadh ar na samplaí sin. Foinse: OCR Processor · Document QnA. Forlíonadh 3 Samhain: Léitear nótaí íomhá ó image.image_annotation (SDK mistralai 3.7.0), ní ó image.annotation.

Córas cliste doiciméad a thógáil

Is é an Ghiniúint Fheabhsaithe le hAisghabháil (RAG) an teicníc a dhéanann corpais mhóra doiciméad inchuardaithe. Trí OCR Mistral, leabaithe, agus stóras veicteoireach a chomhcheangal, cruthaíonn tú córas atá in ann freagraí a thabhairt ar do chartlanna—deich mbliana tuarascálacha, stór conarthaí, nó leabharlann theicniúil dhigiteach.

Cén fáth OCR a úsáid in ionad comhaid a innéacsú mar atá siad? Toisc gurb é an dúshlán bunúsach i RAG doiciméad ná go gcaithfidh píosaí innéacsaithe a bheith ina dtéacs. Níl leabaithe ilmhóideacha fós chomh feidhmiúil sin chun ceisteanna téacs a chur i gcomparáid go díreach le híomhánna doiciméad. Feidhmíonn OCR mar dhroichead: tiontaíonn sé do dhoiciméid go téacs struchtúrtha ardchaighdeáin, a innéacsaíonn tú ansin i do stóras veicteoireach.

An ailtireacht cúig chéim

Tosaíonn sé go léir le hionghabháil, rud a chiallaíonn doiciméid a fháil, cibé an PDFanna, íomhánna nó comhaid DOCX atá i gceist. Ansin tagann OCR le nótaí, ag táirgeadh téacs agus meiteashonraí struchtúrtha araon. Gearrann an píosaíocht (chunking) an téacs seo ina dheighleoga comhleanúnacha, déanann an leabú veicteoireacht orthu agus stórálann sé iad sa stóras veicteoireach, agus dúnann an cheist an lúb: cuardach shéimeantach i measc na veicteoirí, agus ansin giniúint freagra. Coinníollíonn gach céim an chéad cheann eile, agus cinneann an t-asbhaint gach rud eile—má chailleann OCR é, ní aimsíonn aon chuardach é.

Déanann na rannáin seo a leanas cur síos ar an gcód do na ceithre chéim a scríobhfaidh tú féin; braitheann an ionghabháil ar do chóras ionchuir sonrach.

Céim 1: Asbhaint nach gcailleann aon rud

Tá an glaoch OCR seo cumraithe do RAG, rud atá le feiceáil i dtrí rogha. Coimeádann table_format="markdown" táblaí i bhformáid is féidir leis an LLM a léamh. Déanann nótaí an bhosca teorann cur síos ar íomhánna, agus cuireann an cód in ionad gach tagairt ![image](image) ina dhiaidh sin lena chur síos téacs: éiríonn cairt dáileachta ioncaim ina habairt inchuardaithe in ionad bearna sa téacs. Ar deireadh, seachnaíonn include_image_base64=False meigibheart picteilíní a fháil nach bhfuil aon úsáid ag an innéacs astu.

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

Céim 2: Píosaíocht de réir mar a ligeann an doiciméad

Má ghearrann tú gach míle carachtar, gearrfar tú i lár abairte agus scarfar ceanncheann óna chuid ábhair. Ós rud é go dtugann OCR Markdown duit, bain leas as a struchtúr: déanann an fheidhm deighilt ar cheanncheannte leibhéal-dó ar dtús, coimeádann sí an rannán iomlán ach amháin má oireann sé laistigh den mhéid uasta, agus téann sí ar ais go paragraif ach amháin nuair a líonann sé thar maoil. Coinníonn gach píosa a cheanncheann rannáin dá bhrí sin, rud a fheabhsaíonn ábharthacht an chuardaigh shéimintigh go mór.

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

Céim 3: Veicteoireacht agus cuardach

Déanann an t-innéacsú veicteoireacht ar gach píosa le mistral-embed agus stórálann sé, in éineacht leis an veicteoir, ainm an doiciméid agus ID an phíosa—gan an meiteashonra seo, is féidir leat freagra a thabhairt ach ní féidir leat foinsí a lua. Déanann an cuardach veicteoireacht ar an gceist ar an mbealach céanna, ansin ríomhann sé cosain-chosúlacht normalaithe de réir normanna an dá veicteoir, rud a choscann ar phíosa fada buachan simplí toisc go bhfuil sé fada.

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

Céim 4: Freagra foinsithe a ghiniúint

Cuirann an píosa deireanach na cúig phíosa is fearr le chéile i gcomhthéacs, gach ceann réamhaithe lena dhoiciméad agus a uimhir, agus forchuireann sé treoir dhocht ar an tsamhail: freagair bunaithe ar an gcomhthéacs soláthraithe amháin agus luaigh foinsí. Cuireann an chóras-leide seo cúntóir doiciméad ar leithligh ó shamhail a dhéanann impromptú, agus is é sin an fáth ar chaomhnaigh tú meiteashonraí le linn an innéacsaithe.

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

Ó fréamhshamhail go stóras veicteoireach

Oibríonn innéacs sa chuimhne fad is a fhanann tú faoi bhun cúpla míle píosa. Thairis sin, titann an cuardach líneach as a chéile agus ní mhaireann aon rud tar éis atosú: athraigh go stóras veicteoireach fíor (Pinecone, Weaviate, Qdrant, ChromaDB). Níl an t-athrú costasach, mar a léirítear sa leagan ChromaDB seo nuair nach n-athraíonn ach an stóráil agus an cuardach—fanann do fheidhmeanna asbhainte agus píosaíochta slán.

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

Príomhphointí

  • Tiontaíonn an píblíne OCR + RAG do dhoiciméid ina mbunachar eolais inchuardaithe
  • Coscann saibhriú trí nótaí (cur síos ar íomhánna) ar chailliúint faisnéise
  • Urramaíonn an phíosaíocht chliste rannáin agus paragraif an doiciméid
  • Úsáid stóras veicteoireach fíor sa táirgeadh (ChromaDB, Pinecone, Qdrant)
  • Cinneann cáilíocht asbhainte an OCR cáilíocht freagraí RAG