Mistral OCR: een gids met praktische voorbeelden

Vorige week bracht Mistral Mistral OCR uit, een innovatieve API voor optische tekenherkenning (OCR). Hun API zet een nieuwe standaard voor AI-capaciteiten om documenten en afbeeldingen te begrijpen. De API kan documenten met afbeeldingen, wiskunde, tabellen en meer met hoge nauwkeurigheid verwerken en ontleden.

In dit artikel leg ik stap voor stap uit hoe je Mistral OCR gebruikt met Python. Ik laat je zien hoe je het met documenten en afbeeldingen kunt gebruiken, en hoe je het met chat combineert om prompts met documenten te combineren.

Wat is Mistral OCR?

Optische tekenherkenning, of OCR, is een technologie die verschillende soorten documenten—zoals gescande papieren documenten, PDF-bestanden of afbeeldingen die met een digitale camera zijn gemaakt—omzet in bewerkbare en doorzoekbare gegevens.

OCR werkt door teksttekens in afbeeldingen te identificeren, hun patronen te analyseren en deze visuele elementen te vertalen naar machinaal gecodeerde tekst. Deze technologie heeft veranderd hoe we met gedrukte materialen omgaan, van het digitaliseren van historische archieven tot het automatiseren van gegevensinvoer uit zakelijke formulieren.

De OCR-API van Mistral betekent een belangrijke stap vooruit in dit vakgebied en biedt ontwikkelaars een krachtig hulpmiddel om tekst uit afbeeldingen en documenten met opmerkelijke nauwkeurigheid te extraheren.

Bron: Mistral

In tegenstelling tot traditionele OCR-oplossingen die alleen tekst identificeren, gebruikt de API van Mistral geavanceerde AI-modellen om de context en structuur van documenten te begrijpen, terwijl de opmaak behouden blijft bij het extraheren van content. Dit betekent dat de API complexe lay-outs kan herkennen, onderscheid kan maken tussen koppen en hoofdtekst, en tabellen en opmaak met meerdere kolommen correct kan interpreteren.

Wat de OCR-API van Mistral bijzonder maakt, is de integratie met Mistrals taalbegripsmogelijkheden. Het systeem extraheert niet alleen tekst—het begrijpt die ook.

Dit maakt geavanceerdere documentverwerkingsworkflows mogelijk, waarbij de API niet alleen tekst kan herkennen, maar ook vragen over de inhoud van documenten kan beantwoorden, informatie kan samenvatten of specifieke datapunten kan extraheren.

Daarnaast is de OCR-API van Mistral ontworpen om met meerdere talen en tekensets te werken, waardoor deze veelzijdig is voor wereldwijde toepassingen. Deze combinatie van precieze tekstherkenning met diep taalbegrip positioneert Mistrals aanbod als een documentintelligentie-oplossing van de volgende generatie, in plaats van slechts een eenvoudige OCR-tool.

Mistral OCR-prijzen en limieten

De Mistral OCR-API is niet gratis, maar kost slechts $1 per 1.000 pagina's (of $0,001 per pagina). Dit is naar mijn mening een zeer concurrerende en betaalbare prijs.

Documentbestanden mogen niet groter zijn dan 50 MB en niet langer dan 1.000 pagina's.

Meer informatie vind je op hun prijspagina.

Mistral OCR API instellen

Ga naar de Mistral API-sleutelpagina en klik op de knop "Create new key".

Op het formulier voor het aanmaken van de sleutel kunnen we een naam en een verloopdatum opgeven.

• De naam is handig voor organisatorische doeleinden als we meerdere projecten hebben die elk een andere sleutel gebruiken. Voor deze tutorial kunnen we dit leeg laten.
• De verloopdatum is handig om ervoor te zorgen dat als we de sleutel per ongeluk delen, mensen niet voor altijd toegang hebben tot onze sleutel.

Kopieer na het aanmaken de sleutel en maak een bestand met de naam .env in dezelfde map waar we het script gaan schrijven. 

Plak de sleutel in het bestand met het volgende formaat:

MISTRAL_API_KEY=<paste_api_key_here>Mogelijk gemaakt door

Als je GitHub gebruikt, zorg er dan voor dat je dit bestand toevoegt aan de .gitignore om te voorkomen dat de API-sleutel naar GitHub wordt geüpload.

Python-omgeving instellen

Om de OCR-API van Mistral met Python te gebruiken, installeer je de volgende pakketten:

• mistralai: Dit is het pakket dat Mistral levert om met hun API te communiceren.
• python-dotenv: Een pakket dat het makkelijk maakt om de API-sleutel uit het .env-bestand te laden.
• datauri: Dit pakket wordt gebruikt om de afbeeldingsgegevens te verwerken en ze in bestanden op te slaan.

We kunnen deze installeren met het commando:

pip install mistralai python-dotenv datauriMogelijk gemaakt door

Ik raad aan om een omgeving te maken zodat je installatie niet in conflict komt met je standaard Python-installatie. Een manier om dat te doen is met Anaconda:

conda create -n mistral -y python=3.9
conda activate mistral
pip install mistralai python-dotenv datauriMogelijk gemaakt door

Het eerste commando maakt een omgeving met de naam mistral die Python 3.9 gebruikt. Vervolgens activeren we die omgeving en installeren we de hierboven genoemde pakketten.

Het Python-script maken om met Mistral OCR te werken

Laten we kijken hoe we ons eerste verzoek naar de OCR-API van Mistral kunnen sturen.

Importeer de benodigde dependencies

Maak in dezelfde map als het .env-bestand een nieuw Python-script met de naam ocr.py en importeer de benodigde pakketten:

from mistralai import Mistral
from dotenv import load_dotenv
import datauri
import osMogelijk gemaakt door

Let op dat we ook os importeren, dat we gebruiken om de API-sleutel uit de omgeving in een variabele te laden. We hoeven dit niet te installeren omdat het een ingebouwd pakket is.

Laad de API-sleutel en initialiseer de Mistral-client

Vervolgens voegen we de volgende regels toe om de API-sleutel te laden en de Mistral-client te initialiseren:

load_dotenv()
api_key = os.environ["MISTRAL_API_KEY"]
client = Mistral(api_key=api_key)Mogelijk gemaakt door

Een verzoek doen aan de Mistral OCR-API

De eenvoudigste manier om de OCR-API te gebruiken is met de URL van een online gehoste PDF. Voor dit voorbeeld gebruiken we dit Mistral 7B-paper dat op arXiv staat (een platform dat pre-submissieversies van onderzoeksartikelen host):

ocr_response = client.ocr.process(
  model="mistral-ocr-latest",
  document={
    "type": "document_url",
    "document_url": "https://arxiv.org/pdf/2501.00663",
  },
)
print(ocr_response)Mogelijk gemaakt door

We kunnen het script vervolgens uitvoeren met het commando python ocr.py. Dit levert de volgende response op:

pages=[OCRPageObject(index=0, markdown='# Mistral 7B \n\nAlbert Q. Jiang,
...Mogelijk gemaakt door

Structuur van de response

De response bevat verschillende velden. Volledige details zijn te vinden in de API-documentatie van Mistral. We zijn met name geïnteresseerd in het veld pages, dat voor elke pagina de markdown-tekst van de pagina bevat.

We kunnen het aantal pagina's afdrukken om te zien dat dit overeenkomt met het PDF-bestand:

print(len(ocr_response.pages))Mogelijk gemaakt door

Resultaat:

9Mogelijk gemaakt door

Elke pagina heeft verschillende velden. De belangrijkste zijn:

• markdown: De markdown-inhoud van de pagina.
• images: De afbeeldingen op de pagina.

We kunnen bijvoorbeeld de markdown-inhoud voor de eerste pagina afdrukken met:

print(ocr_response.pages[0].markdown)Mogelijk gemaakt door

# Mistral 7B 

Albert Q. Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lucile Saulnier, Lélio Renard Lavaud, Marie-Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, Thomas Wang, Timothée Lacroix, William El Sayed

![img-0.jpeg](img-0.jpeg)

#### Abstract

We introduce Mistral 7B, a 7-billion-parameter language
...Mogelijk gemaakt door

Een PDF-bestand omzetten naar Markdown

Om een PDF naar Markdown te converteren, lopen we alle pagina's langs en schrijven we de markdown-inhoud van elke pagina naar een bestand. Hier is een functie om dat te doen.

def create_markdown_file(ocr_response, output_filename = "output.md"):
  with open(output_filename, "wt") as f:
    for page in ocr_response.pages:
      f.write(page.markdown)Mogelijk gemaakt door

Hier is een vergelijking naast elkaar van het originele PDF-bestand en het Markdown-bestand dat we hebben gegenereerd:

Afbeeldingen verwerken

In het vorige voorbeeld zagen we dat het Markdown-bestand de afbeeldingen uit de PDF niet had. Dat komt omdat we alleen de Markdown-tekst hebben gemaakt, niet de afbeeldingsbestanden.

Als we naar de markdown-uitvoer kijken, zien we dat er wel een afbeeldingsverwijzing in staat:

...
![img-0.jpeg](img-0.jpeg)
...Mogelijk gemaakt door

Die afbeelding wordt echter niet weergegeven. De afbeeldingen op elke pagina zijn opgeslagen in het attribuut images.

for page in ocr_response.pages:
  print(page.images)Mogelijk gemaakt door

Uitvoer:

[OCRImageObject(id='img-0.jpeg', top_left_x=425, top_left_y=600, bottom_right_x=1283, bottom_right_y=893, image_base64=None)]
[OCRImageObject(id='img-1.jpeg', top_left_x=294, top_left_y=638, bottom_right_x=1405, bottom_right_y=1064, image_base64=None)]
[OCRImageObject(id='img-2.jpeg', top_left_x=294, top_left_y=191, bottom_right_x=1405, bottom_right_y=380, image_base64=None)]
[OCRImageObject(id='img-3.jpeg', top_left_x=292, top_left_y=204, bottom_right_x=1390, bottom_right_y=552, image_base64=None)]
[OCRImageObject(id='img-4.jpeg', top_left_x=464, top_left_y=202, bottom_right_x=1232, bottom_right_y=734, image_base64=None)]
[]
[OCRImageObject(id='img-5.jpeg', top_left_x=727, top_left_y=794, bottom_right_x=975, bottom_right_y=1047, image_base64=None)]
[]
[]Mogelijk gemaakt door

In de bovenstaande uitvoer zien we inderdaad een verwijzing naar img-0.jpeg. De data is echter niet aanwezig: image_base64=None.

Om de afbeeldingsdata op te halen, moeten we het OCR-verzoek aanpassen zodat de afbeeldingsdata wordt opgenomen door de parameter include_image_base64=True toe te voegen.

ocr_response = client.ocr.process(
  model="mistral-ocr-latest",
  document={
    "type": "document_url",
    "document_url": "https://arxiv.org/pdf/2310.06825",
  },
  include_image_base64=True,
)Mogelijk gemaakt door

Als we de afbeeldingen opnieuw afdrukken, zien we dat de velden image_base_64 nu gevuld zijn. Zoals de naam van het veld aangeeft, zijn de afbeeldingsgegevens opgeslagen in base 64. We gaan niet in op de details van hoe base-64 afbeeldingsrepresentatie werkt. In plaats daarvan geven we een functie die het eerder geïnstalleerde pakket datauri gebruikt om een afbeelding naar een bestand te schrijven:

def save_image(image):
    parsed = datauri.parse(image.image_base64)
    with open(image.id, "wb") as file:
      file.write(parsed.data)Mogelijk gemaakt door

Nu kunnen we de functie create_markdown_file() updaten zodat ook alle afbeeldingen naar bestanden worden geschreven:

def create_markdown_file(ocr_response, output_filename = "output.md"):
  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)Mogelijk gemaakt door

Als we de bijgewerkte code uitvoeren en de Markdown-preview opnieuw renderen, zien we de afbeeldingen.

Een lokaal bestand gebruiken

In het bovenstaande voorbeeld gebruikten we een bestand dat al gehost was. Om met een PDF-bestand van onze computer te werken, laat de Mistral-API ons een bestand uploaden met de functie client.files.upload(). Als we aannemen dat het PDF-bestand myfile.pdf in dezelfde map staat als het script, doe je dit als volgt:

filename = "myfile.pdf"
uploaded_pdf = client.files.upload(
  file={
    "file_name": filename,
    "content": open(filename, "rb"),
  },
  purpose="ocr"
)Mogelijk gemaakt door

Elk bestand dat op deze manier wordt geüpload, krijgt een unieke ID, die nodig is om naar dat bestand te verwijzen. We kunnen deze opvragen via het attribuut id van het resultaat, zoals dit:

print(uploaded_pdf.id)Mogelijk gemaakt door

Om OCR op dat bestand uit te voeren, moeten we de URL ervan opgeven. Die krijgen we met de functie client.files.get_signed_url() door de bestands-ID door te geven:

signed_url = client.files.get_signed_url(file_id=uploaded_pdf.id)Mogelijk gemaakt door

Samengevoegd kunnen we een functie implementeren die een bestand uploadt met de Mistral-API en de URL ervan ophaalt:

def upload_pdf(filename):
  uploaded_pdf = client.files.upload(
    file={
      "file_name": filename,
      "content": open(filename, "rb"),
    },
    purpose="ocr"
  )
  signed_url = client.files.get_signed_url(file_id=uploaded_pdf.id)
  return signed_url.urlMogelijk gemaakt door

Hier is een voorbeeld van een OCR-verzoek met een lokaal bestand:

ocr_response = client.ocr.process(
  model="mistral-ocr-latest",
  document={
    "type": "document_url",
    "document_url": upload_pdf("myfile.pdf"),
  },
  include_image_base64=True,
)Mogelijk gemaakt door

Om een ander bestand te gebruiken, vervangen we myfile.pdf door de naam van het bestand dat we willen gebruiken.

OCR op een afbeelding

De OCR-API werkt ook met afbeeldingsinvoer. Om een afbeelding te gebruiken, gebruiken we het type image_url in plaats van document_url:

ocr_response = client.ocr.process(
  model="mistral-ocr-latest",
  document={
    "type": "image_url",
    "image_url": <url of the image>,
  },
)Mogelijk gemaakt door

In het bovenstaande voorbeeld moeten we <url of the image> vervangen door de URL van de afbeelding. 

Om een lokale afbeelding te gebruiken, kunnen we de volgende functie gebruiken om deze te laden:

def load_image(image_path):
  import base64
  mime_type, _ = mimetypes.guess_type(image_path)
  with open(image_path, "rb") as image_file:
    image_data = image_file.read()
  base64_encoded = base64.b64encode(image_data).decode('utf-8')
  base64_url = f"data:{mime_type};base64,{base64_encoded}"
  return base64_urlMogelijk gemaakt door

Deze functie gebruikt het pakket base64, wat een ingebouwd pakket is, dus we hoeven het niet te installeren.

Laten we proberen OCR uit te voeren op deze bon die we hebben opgeslagen in een bestand met de naam receipt.jpeg:

We kunnen het OCR-verzoek doen door de functie load_image() te gebruiken om de afbeelding van onze computer te laden:

ocr_response = client.ocr.process(
  model="mistral-ocr-latest",
  document={
    "type": "image_url",
    "image_url": load_image("receipt.jpeg"),
  },
)Mogelijk gemaakt door

Hier is het resultaat:

Het is verre van perfect, maar het resultaat zit er niet ver naast.

Mistral OCR combineren met Chat

OCR biedt een efficiënte manier om data om te zetten naar een tekstformaat dat klaar is voor gebruik door LLM's. De Mistral-API laat gebruikers documenten en prompts combineren in LLM-verzoeken. Achter de schermen wordt de OCR-API gebruikt om de documenten te verwerken voor LLM-consumptie.

Laten we dit gebruiken om het artikel dat we in deze tutorial gebruiken samen te vatten.

Als dit je eerste keer is met de Mistral chat-API, wil je misschien deze uitgebreide Mistral-gids lezen, omdat we niet in detail ingaan op hoe het werkt.

Hier is een volledig Python-voorbeeld om te vragen om een begrijpelijke uitleg van het artikel:

from mistralai import Mistral
import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.environ["MISTRAL_API_KEY"]
client = Mistral(api_key=api_key)
messages = [
  {
    "role": "user",
    "content": [
      {
        "type": "text",
        "text": "Explain this article in detail to someone who doesn't have a technical background",
      },
      {
        "type": "document_url",
        "document_url": "https://arxiv.org/pdf/2310.06825",
      },
    ],
  }
]
chat_response = client.chat.complete(
  model="mistral-small-latest",
  messages=messages,
)
print(chat_response.choices[0].message.content)Mogelijk gemaakt door

Let op dat het bestand wordt opgegeven met hetzelfde formaat dat we hierboven hebben geleerd:

{
  "type": "document_url",
  "document_url": "https://arxiv.org/pdf/2310.06825",
}Mogelijk gemaakt door

Toepassingen in de echte wereld voor Mistral OCR

Nu je hebt geleerd hoe je Mistral OCR in je Python-projecten implementeert, laten we enkele praktische toepassingen verkennen waar je kunt toepassen wat we hebben geleerd.

Analyse van onderzoeksartikelen

Je kunt tekst, vergelijkingen, tabellen en figuren uit wetenschappelijke artikelen extraheren om een persoonlijke onderzoeksassistent te bouwen. Je zou een systeem kunnen maken dat kernbevindingen samenvat, details over methodologie extraheert of een doorzoekbare database met artikelen in jouw vakgebied opbouwt.

Digitaliseringsprojecten voor documenten

Je kunt fysieke archieven of gescande documenten omzetten in doorzoekbare digitale collecties. Dit is vooral waardevol voor historische documenten, familierecords of organisatie-archieven die bewaard en gemakkelijk toegankelijk moeten blijven.

Meertalige documentverwerking

Je kunt de meertalige mogelijkheden van Mistral OCR gebruiken om documenten in verschillende talen te verwerken. Dit kan nuttig zijn voor internationale bedrijven, vertaaldiensten of wereldwijde onderzoeksprojecten die informatie uit documenten in verschillende schriften moeten halen.

Onderwijscontent beheren

Je kunt studieboeken, slides en handgeschreven notities omzetten naar digitale formaten. Maak een systeem dat kernconcepten, formules en diagrammen extraheert om gepersonaliseerd studiemateriaal of vragensets op te bouwen.

Financiële documentverwerking

Je kunt de extractie van gegevens uit facturen, bonnetjes, financiële overzichten of belastingdocumenten automatiseren. Dit kan boekhoudprocessen stroomlijnen of helpen bij onkostenbeheer en financiële analyse.

Conclusie

De OCR-API van Mistral biedt een krachtig hulpmiddel voor het extraheren en begrijpen van tekst uit documenten en afbeeldingen. In deze tutorial hebben we onderzocht hoe je deze mogelijkheid instelt en gebruikt voor diverse documentverwerkingstaken.

Door de stappen in deze tutorial te volgen, kun je Mistral's OCR in je applicaties integreren, of je nu archieven digitaliseert, gegevensinvoer automatiseert of intelligente documentbeheersystemen bouwt. Naarmate de technologie zich blijft ontwikkelen, kunnen we nog nauwkeurigere en contextbewuste documentvermogens verwachten die de kloof tussen fysieke documenten en digitale workflows verder dichten.