Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Meerdere afbeeldingen in één bericht verzenden

Les 6 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Meerdere afbeeldingen tegelijk analyseren
  2. Structuur van een bericht met meerdere afbeeldingen
  3. Voorbeeld: twee afbeeldingen vergelijken
  4. Tekst en afbeeldingen afwisselen
  5. Batchverwerking met Base64
  6. Grenzen van calls met meerdere afbeeldingen
  7. Strategie voor grote volumes
  8. Belangrijkste punten

Meerdere afbeeldingen tegelijk analyseren

De Vision API van Mistral is niet beperkt tot één afbeelding per bericht. U kunt meerdere afbeeldingen in één enkele call verzenden om het model te vragen ze te vergelijken, samen te vatten of gezamenlijk te analyseren. Het verschil tussen deze aanpak en twee aparte calls is cruciaal: bij één enkele call ziet het model beide afbeeldingen simultaan en kan het redeneren over hun onderlinge relaties—iets wat geen aggregatie van individuele responsen kan bereiken.

Deze mogelijkheid ontsluit use cases waarbij de vraag zich richt op het verschil in plaats van op de inhoud: vergelijkingen van voor/na, analyse van documentreeksen of visuele compliance-checks.

Structuur van een bericht met meerdere afbeeldingen

Het principe is eenvoudig: voeg meerdere image_url-items toe aan de content-array:

message = {
    "role": "user",
    "content": [
        {"type": "text", "text": "Vergelijk deze twee afbeeldingen en beschrijf de verschillen."},
        {"type": "image_url", "image_url": "https://example.com/image1.jpg"},
        {"type": "image_url", "image_url": "https://example.com/image2.jpg"}
    ]
}

Homogeniteit is niet vereist: u kunt in hetzelfde bericht afbeeldingen via URL en Base64 mixen. Dit komt vaak voor wanneer u een gehoste referentieafbeelding moet vergelijken met een lokaal gegenereerd bestand.

Voorbeeld: twee afbeeldingen vergelijken

Stel u een inspectie bij ontvangst in een magazijn voor. U vergelijkt een referentiefoto van het conforme product met een foto van het ontvangen monster, gebruikmakend van een systeemprompt die de rol van inspecteur vastlegt:

from mistralai.client import Mistral
import os

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

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "U bent een kwaliteitscontrole-expert. Vergelijk de verstrekte afbeeldingen met precisie."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Hier zijn twee foto's van hetzelfde product. De eerste is de referentie, de tweede is het ontvangen monster. Identificeer alle verschillen."
                },
                {"type": "image_url", "image_url": "https://example.com/reference.jpg"},
                {"type": "image_url", "image_url": "https://example.com/sample.jpg"}
            ]
        }
    ]
)

print(response.choices[0].message.content)

De tekst vermeldt expliciet de volgorde—“de eerste is de referentie”—omdat het model deze niet kan raden.

Tekst en afbeeldingen afwisselen

Deze benadering van ordening stoot snel op zijn grenzen bij meer dan twee afbeeldingen. Een robuustere methode is om elke afbeelding te labelen vlak voordat u deze verstrekt, door text- en image_url-elementen af te wisselen:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Hier is het oorspronkelijke architectonische plan:"},
                {"type": "image_url", "image_url": "https://example.com/plan-original.png"},
                {"type": "text", "text": "En hier is de foto van het gebouwde pand:"},
                {"type": "image_url", "image_url": "https://example.com/photo-batiment.jpg"},
                {"type": "text", "text": "Komt het gebouw overeen met het plan? Som de afwijkingen op."}
            ]
        }
    ]
)

Elke afbeelding heeft nu zijn eigen label en de laatste vraag komt pas nadat al het materiaal is gepresenteerd. Dit formaat verbetert het begrip van het model aanzienlijk: het weet dat het plan de standaard is en de foto het object dat geëvalueerd moet worden. Het omdraaien ervan zou een omgekeerd afwijkingsrapport opleveren.

Batchverwerking met Base64

Voor een map met lokale afbeeldingen wordt het bouwen van de content programmatisch. U stelt de lijst samen in een lus en codeert elk bestand ter plekke:

import base64
import os
from pathlib import Path
from mistralai.client import Mistral

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

def encode_image(path):
    with open(path, "rb") as f:
        b64 = base64.standard_b64encode(f.read()).decode("utf-8")
    ext = Path(path).suffix.lower()
    mime = {"jpg": "jpeg", "jpeg": "jpeg", "png": "png", "webp": "webp"}.get(ext.lstrip("."), "jpeg")
    return f"data:image/{mime};base64,{b64}"

# Laad alle afbeeldingen uit een map
folder = Path("captures/")
images = sorted(folder.glob("*.png"))

# Bouw de inhoud van het bericht
content = [{"type": "text", "text": f"Analyseer deze {len(images)} screenshots en vat gemeenschappelijke elementen samen."}]
for img in images[:5]:  # Beperk tot maximaal 5 afbeeldingen
    content.append({"type": "image_url", "image_url": encode_image(img)})

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[{"role": "user", "content": content}]
)

print(response.choices[0].message.content)

De slice images[:5] is de veiligheidsrem van het script. Zonder dit zou een map met tweehonderd screenshots volledig in één enkele call terechtkomen—met de gevolgen die hieronder worden beschreven.

Grenzen van calls met meerdere afbeeldingen

Er is geen strikt gedocumenteerde limiet voor het aantal afbeeldingen, maar twee effecten treden op bij meer dan vijf tot tien: de analysekwaliteit neemt af naarmate de aandacht van het model over de afbeeldingen verspreidt, en de tokenkosten stijgen scherp. Denk terug aan de orde van grootte uit Les 2: elke afbeelding verbruikt 800 tot 1.500 tokens, dus vijf afbeeldingen vertegenwoordigen al 5.000 tot 7.500 prompt-tokens voordat uw vraag überhaupt begint. Het totaal—afbeeldingen, tekst en respons—moet ook binnen het contextvenster van het model passen, een plafond dat een batch afbeeldingen veel sneller bereikt dan een tekstdocument.

Deze functie berekent de kosten vóór de call in plaats van erna:

def estimate_multi_image_cost(num_images, tokens_per_image=1000, text_tokens=100, response_tokens=500):
    """Schat het totale aantal tokens voor een call met meerdere afbeeldingen."""
    total_input = (num_images * tokens_per_image) + text_tokens
    total = total_input + response_tokens

    print(f"Afbeeldingen: {num_images} x {tokens_per_image} = {num_images * tokens_per_image} tokens")
    print(f"Prompt-tekst: {text_tokens} tokens")
    print(f"Geschatte respons: {response_tokens} tokens")
    print(f"Geschat totaal: {total} tokens")
    return total

estimate_multi_image_cost(3)
# Afbeeldingen: 3 x 1000 = 3000 tokens
# Prompt-tekst: 100 tokens
# Geschatte respons: 500 tokens
# Geschat totaal: 3600 tokens

Strategie voor grote volumes

Bij meer dan vijf afbeeldingen wijzigt u uw aanpak in plaats van door te zetten. Er bestaan drie paden, vaak gecombineerd. Sequentiële analyse verwerkt afbeeldingen één voor één en aggregeert vervolgens de resultaten—de kosten blijven lineair en de precisie per afbeelding is maximaal. Batchgroepering verzendt pakketten van drie tot vijf afbeeldingen, waardoor enige vergelijking binnen de batch behouden blijft. Pre-filtering ten slotte gebruikt een lichter model zoals Small om irrelevante afbeeldingen te verwijderen voordat belangrijke gevallen aan Large worden doorgegeven.

Het eerste pad ziet er als volgt uit, met een finale synthese die alleen tekst verwerkt:

# Sequentiële analyse met aggregatie
results = []
for img_path in images:
    response = client.chat.complete(
        model="mistral-small-latest",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Beschrijf kort de inhoud van deze afbeelding."},
                {"type": "image_url", "image_url": encode_image(img_path)}
            ]
        }]
    )
    results.append(response.choices[0].message.content)

# Finale synthese (alleen tekst)
synthesis = client.chat.complete(
    model="mistral-small-latest",
    messages=[{
        "role": "user",
        "content": f"Hier zijn beschrijvingen van {len(results)} afbeeldingen:\n\n" +
                   "\n---\n".join(results) +
                   "\n\nVerstrek een globale synthese."
    }]
)

De truc zit in de tweede call: deze bevat geen afbeeldingen, dus geen visuele tokens. U synthetiseert vijftig afbeeldingen voor de prijs van een paar honderd tekst-tokens.

Belangrijkste punten

  • U kunt meerdere afbeeldingen in één bericht verzenden door meerdere image_url-elementen toe te voegen
  • Wissel tekst af tussen afbeeldingen om context aan het model te bieden
  • Elke afbeelding voegt 800-1500 tokens toe—schat uw kosten voordat u de call doet
  • Bij meer dan 5 afbeeldingen geeft u de voorkeur aan een sequentiële of gebatchte strategie
  • URL’s en Base64 kunnen in hetzelfde bericht worden gemixt