Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Integracija OCR + RAG

Lekcija 15 od 16 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Izgradnja inteligentnega dokumentnega sistema
  2. Arhitektura v petih korakih
  3. 1. korak: Ekstrakcija brez izgub
  4. 2. korak: Razčlenjevanje, ki spoštuje strukturo dokumenta
  5. 3. korak: Vektorizacija in iskanje
  6. 4. korak: Generiranje odgovora z viri
  7. Od prototipa do vektorskega skladišča
  8. Ključne ugotovitve

Posodobitev 2. novembra 2026 — OCR. Različica OCR 4.0 (mistral-ocr-4-0) je bila umaknjena 30. septembra 2026. Uporabljaj OCR 4.1 (mistral-ocr-4-1), ki je splošno dostopen od 31. avgusta po isti ceni, ali alias mistral-ocr-latest, ki kaže nanj od 16. julija. OCR 4.1 dodaja ocene zanesljivosti na ravni blokov. Dodatek 3. novembra 2026: Lokalni PDF se prenese v formatu base64 kot {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; tip document_base64 iz starejših primerov ne obstaja niti v dokumentaciji niti v SDK-ju mistralai, zato bi ti primeri odpovedali. Viri: OCR Processor · Document QnA. Dodatek 3. novembra: Opombe k slikam se berejo iz image.image_annotation (SDK mistralai 3.7.0), ne iz image.annotation.

Izgradnja inteligentnega dokumentnega sistema

Generiranje s pomočjo pridobivanja (RAG) je tehnika, ki omogoča poizvedovanje po obsežnih zbirkah dokumentov. S kombinacijo Mistralovega OCR, vgradenj (embeddings) in vektorskega skladišča ustvariš sistem, ki zna odgovarjati na vprašanja o tvojih arhivih – naj gre za desetletje poročil, zbirko pogodb ali digitalizirano tehnično knjižnico.

Zakaj uporabiti OCR namesto indeksiranja datotek takšnih, kot so? Ker je temeljni izziv dokumentnega RAG ta, da morajo biti indeksirani deli besedilo. Večmodalna vgradnja še ni dovolj zmogljiva za neposredno primerjavo besedilnih vprašanj s slikami dokumentov. OCR služi kot most: tvoje dokumente pretvori v kakovostno strukturirano besedilo, ki ga nato indeksiraš v svojem vektorskem skladišču.

Arhitektura v petih korakih

Vse se začne z vnosom, kar pomeni prejemanje dokumentov, ne glede na to, ali prispejo kot PDF, slike ali datoteke DOCX. Sledi OCR z opombami, ki proizvede tako besedilo kot strukturirane metapodatke. Razčlenjevanje (chunking) razreže to besedilo na smiselne segmente, vgradnja jih vektorizira in shrani v vektorsko skladišče, poizvedba pa zaključi krog: semantično iskanje med vektorji, ki mu sledi generiranje odgovora. Vsak korak pogojuje naslednjega in ekstrakcija določa vse ostalo – če OCR kaj spregleda, tega nobeno iskanje ne bo našlo.

Naslednji razdelki podrobneje opisujejo kodo za štiri korake, ki jih boš napisal sam; vnos je odvisen od tvojega specifičnega sistema za zajem podatkov.

1. korak: Ekstrakcija brez izgub

Klic OCR je tukaj konfiguriran za RAG, kar je razvidno iz treh izbir. table_format="markdown" ohranja tabele v formatu, ki ga LLM lahko prebere. Opomba z mejnim poljem (bounding box) opisuje slike, koda pa nato vsako referenco ![image](image) nadomesti z njenim besedilnim opisom: grafikon porazdelitve prihodkov tako postane stavek, ki ga je mogoče indeksirati, namesto vrzeli v besedilu. Končno include_image_base64=False prepreči pridobivanje megabajtov pikslov, ki jih indeks ne potrebuje.

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

2. korak: Razčlenjevanje, ki spoštuje strukturo dokumenta

Rezanje na vsakih tisoč znakov prereže stavke sredi besede in loči naslov od njegove vsebine. Ker ti OCR ponuja Markdown, izkoristi njegovo strukturo: funkcija najprej razdeli besedilo na podlagi naslovov druge ravni, celoten razdelek obdrži le, če se prilega največji dovoljeni velikosti, in se zateče k odstavkom šele, ko je presežena. Vsak del tako ohrani naslov svojega razdelka, kar bistveno izboljša ustreznost semantičnega iskanja.

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

3. korak: Vektorizacija in iskanje

Indeksiranje vektorizira vsak del z uporabo mistral-embed in shrani poleg vektorja še ime dokumenta ter ID dela – brez teh metapodatkov lahko odgovoriš, a ne moreš navesti virov. Iskanje vektorizira vprašanje na enak način, nato pa izračuna kosinusno podobnost, normalizirano z normami obeh vektorjev, s čimer preprečiš, da bi dolg del „zmagal” zgolj zato, ker je dolg.

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

4. korak: Generiranje odgovora z viri

Zadnji del združi pet najboljših delov v kontekst, pri čemer je vsakemu dodana predpona z imenom dokumenta in številko, modelu pa se naloži strogo navodilo: odgovarjaj izključno na podlagi priloženega konteksta in navajaj vire. Ta sistemski poziv loči dokumentnega asistenta od modela, ki improvizira, in prav zato si med indeksiranjem ohranil metapodatke.

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 prototipa do vektorskega skladišča

Indeks v pomnilniku deluje, dokler ostaneš pod nekaj tisoč deli. Poleg tega linearno iskanje odpove in ob ponovnem zagonu ne ostane nič: preklopi na pravo vektorsko skladišče (Pinecone, Weaviate, Qdrant, ChromaDB). Preklop je poceni, kot kaže ta različica s ChromaDB, kjer se spremeni le shranjevanje in poizvedovanje – tvoji funkciji za ekstrakcijo in razčlenjevanje ostaneta nespremenjeni.

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

Ključne ugotovitve

  • Cevovod OCR + RAG tvoje dokumente pretvori v poizvedljivo zbirko znanja
  • Obogatitev z opombami (opisi slik) preprečuje izgubo informacij
  • Inteligentno razčlenjevanje spoštuje razdelke in odstavke dokumenta
  • V proizvodnem okolju uporabi pravo vektorsko skladišče (ChromaDB, Pinecone, Qdrant)
  • Kakovost ekstrakcije z OCR določa kakovost odgovorov RAG