Mistral OCR 3: Een volledige gids met Mistral AI Studio en Python

Mistrals nieuwste OCR-model, Mistral OCR 3, kan tekst en ingesloten afbeeldingen met uitzonderlijke nauwkeurigheid extraheren uit een breed scala aan documenten.

In dit artikel laat ik je zien hoe je alles uit Mistral OCR 3 haalt, zowel met hun AI Studio als via de API met Python. We bouwen een kleine applicatie die een foto van een menu omzet in een interactieve website.

Als je meer wilt leren over werken met API’s om AI-tools te bouwen, raad ik de cursus Working with the OpenAI API aan. 

Wat is Mistral OCR?

OCR staat voor Optical Character Recognition en is bedoeld om documenten om te zetten in tekst. Zo kan het bijvoorbeeld een foto van een handgeschreven notitie in tekst omzetten, of een tabel in een PDF in een echte teksttabel die doorzoekbaar en bewerkbaar is.

Mistral OCR 3 is Mistral AI’s nieuwste model voor documentbegrip en levert state-of-the-art nauwkeurigheid en efficiëntie voor realistische documenten. Het extraheert tekst en ingesloten afbeeldingen met hoge getrouwheid en behoudt de structuur via markdown-uitvoer met HTML-gebaseerde tabelreconstructie, met optioneel gestructureerde JSON.

Mistral OCR 3 presteert beter dan alle concurrenten op een breed scala aan benchmarks:

Vergeleken met Mistral OCR 2 behaalt het een algehele winst van 74% op formulieren, gescande documenten, complexe tabellen en handschrift, met grote winst op scans van lage kwaliteit en dichte lay-outs.

Wil je meer leren over OCR en Mistrals vorige model? Lees dan dit artikel: Mistral OCR: A Guide With Practical Examples.

Mistral OCR 3 gebruiken in Mistral AI Studio

Laten we bekijken hoe je Mistral OCR 3 instelt in AI Studio. 

Accountinstelling

Mistral OCR 3 is beschikbaar op hun AI-studio. Dit is de makkelijkste manier om het te proberen, omdat het een gebruiksvriendelijke interface biedt.

Na het aanmelden worden we eerst gevraagd een organisatie aan te maken:

In eerste instantie is Mistral OCR 3 vergrendeld en moeten we een plan kiezen om het te ontgrendelen:

Je kunt een gratis plan selecteren, waarmee je Mistral OCR 3 mag gebruiken in ruil voor het toestaan van dataverzameling om hun diensten te verbeteren. Of je kunt je creditcardgegevens opgeven en per gebruik betalen.

Er is geen abonnement, maar we betalen $2 of $1 per 1.000 pagina’s, afhankelijk van of we batchverzoeken gebruiken.

Ons eerste document parsen

Zodra het account is ingesteld, kunnen we met Mistral OCR 3 experimenteren via het tabblad "Document AI" in de AI Studio.

Om te beginnen uploaden we het document of de afbeelding waarop we OCR willen uitvoeren. In mijn geval schreef ik wat tekst en een tabel op een vel papier en uploadde die. Mijn handschrift is nogal slecht, dus ik was benieuwd of Mistral OCR 3 het kon ontcijferen.

Wanneer het bestand is geselecteerd, krijgen we opties te zien voor de verwerking. In dit eerste voorbeeld liet ik de standaardopties staan en klikte ik gewoon op de knop "Run" rechtsboven.

Hier is het resultaat:

Het resultaat is best goed, maar niet perfect:

• De eerste zin heeft twee fouten: "homd" in plaats van "hand" en "tarnible" in plaats van "terrible".
• De tabel is over het algemeen goed, maar de kolomnamen zijn niet juist herkend. De tabelnaam "OCR Benchmark Multilingual Chinese" en de kolom "Result" zijn samengevoegd.
• Ik was onder de indruk van hoe het omging met fouten die ik handmatig had doorgestreept. Als ik het echter zou gebruiken om mijn aantekeningen te parsen, zou ik liever hebben dat die worden herkend en weggelaten.
• Tot slot schreef ik een zin in traditioneel Chinees, en het herkende het grootste deel. Het karakter "好" werd echter als twee losse tekens geparset, "女" en "子", de komma’s werden herkend als de letter "g", en er zit ook een fout op het einde.

Parseopties verkennen

Een van de fijne features van Mistral OCR 3 is de mogelijkheid om een JSON-structuur te specificeren voor het parsen van data. Dit is vooral handig voor tabellen, omdat we kolomnamen en datatypes kunnen opgeven zodat we de rijen als een JSON-dictionary krijgen.

Laten we proberen de tabel uit het vorige voorbeeld opnieuw te parsen door een JSON-schema op te geven.

Om een JSON-schema te gebruiken, moeten we vóór het uitvoeren van de OCR JSON schema selecteren in plaats van tekstmodus.

Vervolgens leveren we een schema aan, ofwel met code of via de gebruikersinterface "Visual Builder". Ik raad de tweede optie aan; dat is eenvoudiger als we het model toch al handmatig gebruiken.

Bij het toevoegen van een veld specificeren we:

• De naam
• De beschrijving
• Het datatype
• Of het veld verplicht is of niet

In dit geval specificeerde ik twee velden: één voor de naam van het model en één voor het benchmarkresultaat:

Nu kunnen we op "Run" klikken en de resultaten bekijken. Helaas werkte dit voorbeeld niet. In de resultaten stond alleen het door mij opgegeven schema, niet de daadwerkelijke data.

Ik dacht dat ik het misschien verkeerd had gebruikt, dus om het zeker te weten, maakte ik een screenshot van een voorbeeldtabel van Wikipedia) en probeerde het opnieuw.

Ik specificeerde vier kolommen, waarbij ik de laatste optioneel liet:

Deze keer werkte het goed. Het lijkt erop dat wanneer het parsen faalt, het JSON-resultaat simpelweg het aangeleverde schema is. Dat betekent ook dat Mistral OCR 3 mijn handgeschreven tabel niet als JSON kon parsen, ondanks dat het hem wel als tekst kon weergeven.

Mistral OCR 3 gebruiken met Python

In deze sectie bekijken we hoe je Python gebruikt om met de Mistral OCR 3 API te werken. Dit biedt veel meer flexibiliteit: je kunt de output bijvoorbeeld combineren met andere AI-modellen om de geëxtraheerde data te verwerken.

Wanneer we een bestand uploaden naar de AI Studio, staat er een knop "Code" naast de knop "Run". Als je daarop klikt, zie je welke code nodig is om dezelfde bewerking via de API uit te voeren.

Hier is een voorbeeld:

De meegeleverde Python-code is echter niet helemaal correct. Zo wordt een functie encode_file gedefinieerd, maar vervolgens een functie encode aangeroepen. Dit zijn kleine inconsistenties, maar ze zorgen ervoor dat de code niet direct werkt.

Geen zorgen: we leggen in detail uit hoe je de API gebruikt. Voor meer informatie over de API kun je terecht in de officiële documentatie.

API-instelling

Het eerste wat we doen is een API-sleutel aanmaken in het tabblad "API Keys" en die sleutel kopiëren naar een nieuw bestand met de naam .env in dezelfde map als het Python-script.

Installeer vervolgens de benodigde dependencies:

pip install mistralai python-dotenvMogelijk gemaakt door

OCR uitvoeren op een afbeelding

Hier is een Python-script dat een lokale JPEG-afbeelding laadt, er OCR op uitvoert en het resultaat opslaat in een markdown-bestand:

import sys
import base64
import os
from mistralai import Mistral
from dotenv import load_dotenv

# Load the API key from the .env file
load_dotenv()

# Initialize the Mistral client
api_key = os.environ["MISTRAL_API_KEY"]
client = Mistral(api_key=api_key)

# Load a file as base 64
def encode_file(file_path):
    with open(file_path, "rb") as pdf_file:
        return base64.b64encode(pdf_file.read()).decode('utf-8')

# Perform OCR on and image
def process_image_ocr(file_path):
    base64_file = encode_file(file_path)
    ocr_response = client.ocr.process(
        model="mistral-ocr-latest",
        document={
            "type": "image_url",
            "image_url": f"data:image/jpeg;base64,{base64_file}" 
        },
        include_image_base64=True
    )
    for index, page in enumerate(ocr_response.pages):
        with open(f"page{index}.md", "wt") as f:
            f.write(page.markdown)

if __name__ == "__main__":
    # Load the input file from the arguments
    file_path = sys.argv[1]
    process_image_ocr(file_path)Mogelijk gemaakt door

OCR uitvoeren op een PDF

Als de input een PDF is in plaats van een afbeelding, verandert alleen de waarde in het veld document. Voor een JPEG-afbeelding gebruikten we:

document={
  "type": "image_url",
   "image_url": f"data:image/jpeg;base64,{base64_file}" 
},Mogelijk gemaakt door

Voor een PDF gebruiken we in plaats daarvan:

document={
  "type": "document_url",
  "document_url": f"data:application/pdf;base64,{base64_file}" 
},Mogelijk gemaakt door

Hier is een volledige functie die we kunnen gebruiken om een PDF te verwerken:

def process_pdf_ocr(file_path):
    base64_file = encode_file(file_path)
    ocr_response = client.ocr.process(
        model="mistral-ocr-latest",
        document={
            "type": "document_url",
            "document_url": f"data:application/pdf;base64,{base64_file}" 
        },
        include_image_base64=True
    )
    process_pages(ocr_response)Mogelijk gemaakt door

Een generieke versie maken

Twee aparte functies hebben voor PDF- en JPEG-bestanden is wat onhandig en ook niet ideaal, want er is veel gedeelde code.

Om dit te vermijden, schreven we een nieuwe, verbeterde functie die het pakket mimetypes gebruikt om het bestandstype te bepalen en het API-verzoek daarop af te stemmen. We hebben de code ook aangepast om afbeeldingen op te slaan die in het document zijn herkend.

Hier is de uiteindelijke versie:

import sys
import os
import base64
import mimetypes
import datauri
from mistralai import Mistral
from dotenv import load_dotenv
# Load the API key from the .env file
load_dotenv()
# Initialize the Mistral client
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
# List the supported image types
SUPPORTED_IMAGE_TYPES = {
    "image/jpeg",
    "image/png",
    "image/webp",
    "image/tiff",
}
PDF_MIME = "application/pdf"
# Load a file as base 64
def encode_file(file_path: str) -> str:
    with open(file_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")
# Build the document payload depending on the type of data contained in the file
def build_document_payload(file_path: str) -> dict:
    mime_type, _ = mimetypes.guess_type(file_path)
    if not mime_type:
        raise ValueError(f"Could not determine MIME type for {file_path}")
base64_file = encode_file(file_path)
if mime_type == PDF_MIME:
        return {
            "type": "document_url",
            "document_url": f"data:{mime_type};base64,{base64_file}",
        }
if mime_type in SUPPORTED_IMAGE_TYPES:
        return {
            "type": "image_url",
            "image_url": f"data:{mime_type};base64,{base64_file}",
        }
raise ValueError(f"Unsupported file type: {mime_type}")
# Generic function to process OCR on a file
def process_ocr(file_path: str, output_filename: str = "output.md"):
    document = build_document_payload(file_path)
    ocr_response = client.ocr.process(
        model="mistral-ocr-latest",
        document=document,
        include_image_base64=True,
    )
    process_pages(ocr_response, output_filename)
# Save an image to a local file
def save_image(image):
    parsed = datauri.parse(image.image_base64)
    with open(image.id, "wb") as f:
        f.write(parsed.data)
# Process all pages from the OCR response
def process_pages(ocr_response, output_filename: str):
    with open(output_filename, "wt") as f:
        for page in ocr_response.pages:
            f.write(page.markdown)
            for image in page.images:
                save_image(image)
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python ocr.py <file>")
        sys.exit(1)
process_ocr(sys.argv[1])Mogelijk gemaakt door

Voor deze versie is het pakket datauri nodig om de door Mistral OCR 3 herkende afbeelding op te slaan. Dat installeer je met:

pip install datauriMogelijk gemaakt door

Een JSON-schema aanleveren

We hebben hierboven gezien dat Mistral OCR 3 ons toelaat een JSON-schema aan te leveren om data te parsen. Deze functionaliteit is ook beschikbaar via de API.

Daarvoor geven we het JSON-schema mee in de parameter document_annotation_format bij het verzoek. Hieronder staat een voorbeeld van een JSON-schema voor de twee kolommen model en result, passend bij de handgeschreven voorbeeldtabel.

document_annotation_format={
    "name": "response_schema",
    "schemaDefinition": {
        "properties": {
            "model": {
                "type": "string",
	         "description": "The name of the model"
             },
             "result": {
	         "type": "number",
	         "description": "The benchmark result"
	     }
         },
         "required": [
             "model"
         ]
    }
}Mogelijk gemaakt door

De structuur is altijd hetzelfde. We voegen voor elke kolom een entry toe onder properties, met informatie over het datatype en een beschrijving om het model te helpen de data te herkennen.

Vervolgens sommen we alle verplichte velden op onder het veld required.

Om het samen met de code te gebruiken, is het het eenvoudigst om het schema in een JSON-bestand op te slaan en te laden met het pakket json.

Projectideeën met Mistral OCR 3

Een van de grootste voordelen van Mistral OCR 3 via de API is dat je erop kunt voortbouwen. In deze sectie geven we een paar projectideeën om op verder te bouwen.

Uitgaven-tracker app

We hebben geleerd hoe je OCR uitvoert op een afbeelding. Daarmee kun je een app bouwen die een foto van een kassabon maakt, vervolgens Mistral OCR 3 gebruikt om de gegevens in de afbeelding te verwerken en een JSON-dictionary te extraheren met de artikelen op de bon en hun prijzen.

Deze uitgaven kunnen dan automatisch worden gecategoriseerd en aan een database toegevoegd, zodat de gebruiker zijn uitgaven kan bijhouden.

Documenten-voorlezer

We kunnen Mistral OCR 3 combineren met een tekst-naar-spraak-AI om een documenten-voorlezer te maken. De gebruiker kan een tekst-PDF selecteren en naar Mistral OCR 3 sturen voor verwerking. De resulterende tekst wordt dan naar een tekst-naar-spraakmodel gestuurd, zoals OpenAI Audio API of Eleven Labs.

Omdat Mistral OCR 3 ook met afbeeldingen werkt, kun je het gebruiken met foto’s, zodat gebruikers een foto van een document kunnen maken en die onderweg kunnen beluisteren.

Wil je meer leren over tekst-naar-spraak? Bekijk dan een van de volgende artikelen:

• OpenAI's Audio API: A Guide With Demo Project
• A Beginner’s Guide to the ElevenLabs API: Transform Text and Voice into Dynamic Audio Experiences

Conclusie

Mistral OCR 3 is een capabele, praktische tool om echte documenten om te zetten in bruikbare tekst en gestructureerde data, of je nu experimenteert in de AI Studio of integreert via Python.

Het blinkt uit op gescande pagina’s, formulieren en tabellen, behoudt de lay-out met markdown en afbeeldingen, en ondersteunt JSON-schema’s wanneer je structuur nodig hebt. Zoals we zagen, kunnen rommelig handschrift en dubbelzinnige kopteksten het nog in de war brengen, en mislukte schema-parses geven simpelweg het schema terug.

De API is rechttoe rechtaan zodra je kleine inconsistenties oplost, en een generieke bestandsverwerker plus het opslaan van afbeeldingen maakt integratie in kleine apps of pipelines eenvoudig. Wil je het gewoon proberen, dan is de Studio het snelst. Voor productiegebruik: houd rekening met de kosten, batch waar mogelijk en voeg validatie toe voor randgevallen.

Van daaruit kun je itereren: schema’s verfijnen, outputs combineren met andere modellen en gerichte tools bouwen zoals bonparsers of voorlezers, waarbij het model het zware werk doet en jij betrouwbaarheid en UX borgt.