Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Integration af OCR + RAG

Lektion 15 af 16 Opdateret 3. november 2026 Udvikler
På denne side
  1. Opbygning af et intelligent dokumentsystem
  2. Arkitekturen i fem trin
  3. Trin 1: Udtrækning uden tab
  4. Trin 2: Chunking, hvor dokumentet tillader det
  5. Trin 3: Vektorisering og søgning
  6. Trin 4: Generer et svar med kildehenvisning
  7. Fra prototype til vektorlager
  8. Vigtige pointer

Opdatering 2. november 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) blev udfaset den 30. september 2026. Brug OCR 4.1 (mistral-ocr-4-1), som har været generelt tilgængelig siden 31. august til samme pris, eller aliasset mistral-ocr-latest, som har peget på det siden 16. juli. OCR 4.1 tilføjer konfidensscorer på blokniveau. Tillæg 3. november 2026: En lokal PDF transmitteres i base64 som {"type": "document_url", "document_url": "data:application/pdf;base64,…"}; typen document_base64 fra ældre eksempler findes hverken i dokumentationen eller i mistralai SDK’et, og disse eksempler ville have fejlet. Kilder: OCR Processor · Document QnA. Tillæg 3. november: Billedannotationer læses fra image.image_annotation (SDK mistralai 3.7.0), ikke image.annotation.

Opbygning af et intelligent dokumentsystem

Retrieval-Augmented Generation (RAG) er teknikken, der gør store dokumentsamlinger søgbare. Ved at kombinere Mistrals OCR, embeddings og et vektorlager skaber du et system, der kan besvare spørgsmål om dine arkiver – будь det ti års rapporter, en kontraktsdatabase eller et digitaliseret teknisk bibliotek.

Hvorfor bruge OCR i stedet for at indeksere filer, som de er? Fordi den grundlæggende udfordring ved dokument-RAG er, at indekserede bidder skal være tekst. Multimodale embeddings er endnu ikke ydedygtige nok til direkte at sammenligne tekstspørgsmål med dokumentbilleder. OCR fungerer som broen: Det konverterer dine dokumenter til struktureret tekst af høj kvalitet, som du derefter indekserer i dit vektorlager.

Arkitekturen i fem trin

Det hele starter med indtagelse, altså modtagelsen af dokumenter, uanset om de ankommer som PDF’er, billeder eller DOCX-filer. Dernæst kommer OCR med annotationer, hvilket producerer både tekst og strukturerede metadata. Chunking (opdeling) skærer denne tekst i sammenhængende segmenter, embedding vektoriserer dem og gemmer dem i vektorlageret, og forespørgslen lukker kredsløbet: semantisk søgning blandt vektorerne efterfulgt af svar-generering. Hvert trin betinger det næste, og udtrækningen afgører alt andet – hvis OCR’en overser det, finder ingen søgning det.

De følgende afsnit detaljerer koden til de fire trin, du selv skal skrive; indtagelsen afhænger af dit specifikke modtagelsessystem.

Trin 1: Udtrækning uden tab

OCR-kaldet her er konfigureret til RAG, hvilket ses i tre valg. table_format="markdown" bevarer tabeller i et format, som LLM’en kan læse. Bounding box-annotation beskriver billeder, og koden erstatter efterfølgende hver ![image](image)-reference med sin tekstbeskrivelse: et diagram over indtægtsfordeling bliver til en indekserbar sætning i stedet for et hul i teksten. Endelig undgår include_image_base64=False at hente megabytes af pixels, som indekset ikke har brug for.

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]:
    """Udtrækker beriget indhold fra et dokument til 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  # Billeder ikke nødvendige til RAG
    )

    pages = []
    for page in response.pages:
        contenu = page.markdown

        # Erstat billedreferencer med deres beskrivelser
        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

Trin 2: Chunking, hvor dokumentet tillader det

At opdele ved hvert tusinde tegn skærer midt i en sætning og adskiller en overskrift fra dens indhold. Da OCR giver dig Markdown, skal du udnytte strukturen: Funktionen segmenterer først på overskrifter på niveau to, beholder hele sektionen, kun hvis den passer inden for maksimalstørrelsen, og falder tilbage til afsnit, kun hvis den løber over. Hver bid beholder dermed sin sektionsoverskrift, hvilket forbedrer relevansen af den semantiske søgning markant.

def chunker_par_sections(
    texte: str,
    taille_max: int = 1000,
    chevauchement: int = 200
) -> list[str]:
    """Opdeler tekst under overholdelse af Markdown-sektioner."""
    sections = texte.split("\n## ")
    chunks = []

    for section in sections:
        if not section.strip():
            continue

        # Rekonstruer sektionsoverskrift
        if not section.startswith("## "):
            section = "## " + section

        if len(section) <= taille_max:
            chunks.append(section)
        else:
            # Underopdeling efter afsnit
            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

Trin 3: Vektorisering og søgning

Indeksering vektoriserer hver bid med mistral-embed og gemmer, sammen med vektoren, dokumentnavnet og bid-ID’en – uden disse metadata kan du svare, men ikke citere kilder. Søgningsvektorisering behandler spørgsmålet på samme måde og beregner derefter cosinus-likhed normaliseret efter normerne for begge vektorer, hvilket forhindrer, at en lang bid vinder blot fordi den er lang.

import numpy as np

def creer_index(documents: dict[str, list[dict]]) -> list[dict]:
    """Opretter et vektorindeks fra udtrukne dokumenter."""
    index = []

    for nom_doc, pages in documents.items():
        # Sammenkæd alle sider
        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]:
    """Søger efter de mest relevante bidder."""
    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]]

Trin 4: Generer et svar med kildehenvisning

Det sidste stykke samler de fem øverste bidder til en kontekst, hvor hver er præfikset med sit dokument og nummer, og pålægger modellen en streng instruktion: svar kun ud fra den leverede kontekst og citér kilder. Denne system-prompt adskiller en dokumentassistent fra en model, der improviserer, og det er grunden til, at du bevarede metadata under indekseringen.

def repondre_question(question: str, index: list[dict]) -> str:
    """Besvarer et spørgsmål ved hjælp af RAG."""
    # Søg efter relevante bidder
    resultats = rechercher_chunks(question, index, top_k=5)

    # Byg kontekst
    contexte = "\n\n---\n\n".join(
        f"[Source: {r['document']}, Chunk {r['chunk_id']}]\n{r['texte']}"
        for r in resultats
    )

    # Generer svar
    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

Fra prototype til vektorlager

Et indeks i hukommelsen fungerer, så længe du holder dig under nogle få tusinde bidder. Derudover kollapser lineær søgning, og intet overlever en genstart: skift til et rigtigt vektorlager (Pinecone, Weaviate, Qdrant, ChromaDB). Skiftet er billigt, som vist i denne ChromaDB-variant, hvor kun lagring og forespørgsel ændres – dine funktioner til udtrækning og chunking forbliver intakte.

# Eksempel med ChromaDB
import chromadb

chroma_client = chromadb.Client()
collection = chroma_client.create_collection(name="documents")

# Indeksering
for item in index:
    collection.add(
        ids=[f"{item['document']}_{item['chunk_id']}"],
        embeddings=[item["embedding"].tolist()],
        documents=[item["texte"]],
        metadatas=[{"document": item["document"]}]
    )

# Søgning
resultats = collection.query(
    query_embeddings=[q_emb.tolist()],
    n_results=5
)

Vigtige pointer

  • OCR + RAG-pipelinen konverterer dine dokumenter til en søgbar vidensbase
  • Berigelse via annotationer (billedbeskrivelser) forhindrer informationstab
  • Intelligent chunking respekterer dokumentsektioner og afsnit
  • Brug et rigtigt vektorlager i produktion (ChromaDB, Pinecone, Qdrant)
  • Kvaliteten af OCR-udtrækningen bestemmer kvaliteten af RAG-svar