Analyser images et PDF avec Gemini en Python (multimodal)

📍 Guide principal : Développer avec l’API Google Gemini — le multimodal est l’une de ses capacités les plus distinctives.

Un modèle qui ne lit que du texte vous oblige à tout transcrire avant de l’interroger. Gemini, lui, accepte directement une image, un PDF ou un audio dans la même requête que votre question. Vous lui montrez une photo de facture et demandez le montant total ; vous lui passez un PDF de cent pages et demandez un résumé. Pas de pipeline d’OCR à monter, pas d’outil tiers : le modèle « voit » le document. Ce tutoriel met en place les deux façons d’envoyer un fichier et les exploite sur des cas concrets d’extraction et de résumé.

Ce que vous allez apprendre

• Distinguer les deux méthodes d’envoi : données en ligne et File API.
• Envoyer une image au modèle et lui poser des questions précises dessus.
• Extraire des informations ciblées d’un document visuel (montant, date, éléments).
• Téléverser et analyser un PDF de plusieurs pages.
• Choisir la bonne méthode selon la taille et la réutilisation du fichier.

Ce que vous allez construire

Un petit lecteur de documents : donnez-lui la photo d’un reçu, il en sort le commerçant, la date et le total ; donnez-lui un rapport en PDF, il en produit une synthèse. La même mécanique servira plus tard à alimenter une base de données ou à pré-remplir un formulaire à partir d’un document scanné.

Prérequis

• L’environnement du premier tutoriel : google-genai et clé configurés.
• Un fichier image sous la main (photo ou capture d’écran, en JPEG ou PNG) et un fichier PDF.
• ⏱️ Temps estimé : environ 30 minutes.

Étape 1 — Deux méthodes, deux usages

Avant de coder, choisissez votre voie. Il existe deux façons de transmettre un fichier au modèle, et chacune a son terrain.

Les données en ligne consistent à lire le fichier en mémoire et à l’envoyer directement dans la requête. C’est simple et immédiat, idéal pour un fichier de taille modeste qu’on n’utilise qu’une fois. La contrainte : la requête entière reste soumise à une limite de taille — de l’ordre de 100 Mo au total, et 50 Mo pour un PDF — au-delà de laquelle la File API devient obligatoire. En pratique, on réserve donc les données en ligne aux fichiers légers, une photo par exemple, et l’on bascule sur la File API dès qu’un document devient volumineux.

La File API téléverse d’abord le fichier sur les serveurs de Google, qui vous renvoient une référence. Vous passez ensuite cette référence au modèle. On l’utilise pour les fichiers volumineux, et dès qu’on veut réutiliser le même document dans plusieurs requêtes sans le ré-envoyer à chaque fois. Les fichiers téléversés y sont conservés temporairement, environ deux jours, puis supprimés automatiquement.

Règle simple : petite image unique, données en ligne ; gros fichier ou usage répété, File API.

Comprendre le coût d’une image

Comme tout le reste de l’API, le multimodal se facture en jetons — y compris les images, qui sont converties en jetons avant d’être traitées. Une petite image coûte un nombre fixe et modeste de jetons ; une grande image est découpée en tuiles, chacune consommant son quota, si bien qu’une photo en haute résolution pèse davantage qu’une vignette. La conséquence pratique est simple : il est souvent inutile d’envoyer une photo de plusieurs dizaines de mégapixels quand une version redimensionnée suffit à lire le texte ou la scène. Redimensionner côté client avant l’envoi réduit à la fois le coût et la latence, sans perte de qualité perceptible pour le modèle. Prenez le réflexe de regarder le usage_metadata de la réponse, vu dans le premier tutoriel, pour mesurer ce que coûte réellement chaque image et calibrer vos envois en conséquence.

Une question revient souvent : pourquoi passer par un modèle plutôt que par un outil d’OCR classique comme Tesseract ? La différence est de nature. Un OCR traditionnel restitue le texte brut, ligne par ligne, sans en comprendre le sens : à vous de deviner ensuite quel nombre est le total et lequel est la TVA. Gemini, lui, lit et interprète : il sait distinguer le total du sous-total, relier une date à son étiquette, ignorer le bruit visuel. Vous ne demandez pas « tout le texte » mais « le montant total », et vous l’obtenez directement. En contrepartie, un OCR local tourne hors ligne et gratuitement, là où le modèle appelle une API payante. Le bon choix dépend du besoin : extraction sémantique fine et tolérance aux mises en page variées pour le modèle ; volume massif de texte simple et contrainte de coût pour l’OCR classique.

Étape 2 — Envoyer une image en ligne

Commençons par le cas le plus courant : une image envoyée directement. On lit le fichier en binaire, on l’emballe dans une part en précisant son type, et on l’accompagne d’une instruction texte. Préparez une image nommée recu.jpg dans votre dossier de projet.

from dotenv import load_dotenv
from google import genai
from google.genai import types

load_dotenv()
client = genai.Client()

with open("recu.jpg", "rb") as f:
    donnees_image = f.read()

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(data=donnees_image, mime_type="image/jpeg"),
        "Decris en deux phrases ce que montre cette image.",
    ],
)
print(response.text)

Le point clé est types.Part.from_bytes : il transforme les octets bruts de l’image en une part que le modèle sait interpréter, à condition de lui donner le bon mime_type — image/jpeg pour un JPEG, image/png pour un PNG. La liste contents mélange librement la part image et l’instruction texte : c’est cette juxtaposition qui rend le multimodal naturel. À l’exécution, le modèle décrit fidèlement le contenu de votre image.

✅ Point d’étape — Le modèle décrit correctement l’image. Une erreur sur le mime_type (par exemple image/jpeg pour un PNG) provoque un refus : ajustez-le au format réel du fichier.

Étape 3 — Extraire des informations précises

Décrire une image est une chose ; en extraire des données exploitables en est une autre, bien plus utile. Le secret tient dans l’instruction : plus elle est précise sur ce qu’on veut, plus la sortie est nette. Reprenons le reçu et demandons des champs ciblés.

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(data=donnees_image, mime_type="image/jpeg"),
        (
            "Lis ce recu et donne uniquement : "
            "le nom du commercant, la date, et le montant total. "
            "Si une information est absente, ecris 'non lisible'."
        ),
    ],
)
print(response.text)

L’instruction fait tout le travail : elle borne la sortie aux trois champs voulus et prévoit le cas où une donnée manque. C’est une habitude à prendre — anticiper l’information absente évite que le modèle invente. La capacité de lecture de texte dans une image, souvent appelée OCR, est ici intégrée : aucun outil séparé n’a été nécessaire. Pour transformer cette sortie en données vraiment structurées (un objet JSON garanti), le tutoriel sur les sorties structurées est la suite directe.

✅ Point d’étape — Vous obtenez les trois champs demandés. Si le modèle ajoute du bavardage autour, durcissez l’instruction avec « réponds sans phrase d’introduction ».

Étape 4 — La File API pour les gros fichiers

Pour un PDF de plusieurs pages ou une image lourde, on téléverse d’abord le fichier. La méthode client.files.upload renvoie une référence qu’on glisse ensuite dans contents, exactement comme une part.

fichier = client.files.upload(file="rapport.pdf")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        fichier,
        "Resume ce document en cinq points cles, en francais.",
    ],
)
print(response.text)

La différence avec les données en ligne est minime côté code, mais déterminante côté capacité : on peut désormais passer des fichiers que la limite de la requête directe interdirait. La référence renvoyée par upload peut être réutilisée dans plusieurs appels successifs — pour résumer, puis questionner, puis extraire — sans re-téléverser le document à chaque fois, ce qui économise du temps et de la bande passante.

✅ Point d’étape — Le résumé reflète le contenu réel du PDF. Si le téléversement échoue, vérifiez le chemin du fichier et que le format est supporté (application/pdf pour un PDF).

Étape 5 — Interroger un PDF en profondeur

Un atout majeur de Gemini est qu’il lit un PDF en gardant la mise en page : tableaux, colonnes, titres. On peut donc poser des questions pointues, pas seulement demander un résumé. Réutilisons la référence du fichier téléversé.

question = (
    "Dans ce rapport, quels sont les trois chiffres les plus importants ? "
    "Pour chacun, precise la page ou il apparait et ce qu'il represente."
)

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[fichier, question],
)
print(response.text)

Le modèle parcourt l’ensemble du document et relie les chiffres à leur contexte. Cette capacité à raisonner sur un document long, sans qu’on l’ait découpé au préalable, découle de la très large fenêtre de contexte des modèles Gemini : plusieurs centaines de pages tiennent dans une seule requête. Pour des bases documentaires bien plus grandes que ce qu’une requête peut contenir, on bascule vers le RAG, abordé dans le tutoriel sur les embeddings.

✅ Point d’étape — Les chiffres cités existent bien dans le document, avec leur page. Vérifiez par sondage : le modèle peut se tromper de page sur un PDF mal structuré.

Étape 6 — Plusieurs images dans une même requête

Rien n’empêche d’envoyer plusieurs fichiers d’un coup, par exemple pour comparer deux documents. On empile simplement les parts dans contents.

with open("facture_a.jpg", "rb") as f:
    img_a = f.read()
with open("facture_b.jpg", "rb") as f:
    img_b = f.read()

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(data=img_a, mime_type="image/jpeg"),
        types.Part.from_bytes(data=img_b, mime_type="image/jpeg"),
        "Compare ces deux factures et indique laquelle a le montant le plus eleve.",
    ],
)
print(response.text)

Le modèle traite les deux images dans le même raisonnement et formule la comparaison. C’est la même logique de juxtaposition de parts, étendue à plusieurs fichiers — pratique pour du rapprochement de documents ou du contrôle de cohérence.

Étape 7 — Transcrire un audio

La même mécanique s’étend au son. Téléversez un fichier audio avec la File API, puis demandez une transcription ou un résumé. C’est précieux pour traiter des notes vocales, des comptes rendus de réunion ou des messages.

audio = client.files.upload(file="note_vocale.mp3")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        audio,
        "Transcris cet audio en francais, puis resume-le en une phrase.",
    ],
)
print(response.text)

On retrouve exactement le schéma des PDF : un fichier téléversé, une instruction, une réponse. Le modèle restitue le texte parlé puis en donne la substance. Pour des besoins de transcription à grand volume ou en temps réel, des modèles spécialisés existent, mais pour traiter ponctuellement un enregistrement, cette approche directe suffit et évite tout outil supplémentaire.

✅ Point d’étape — La transcription correspond à l’audio. Une mauvaise qualité d’enregistrement (bruit de fond fort) dégrade le résultat : enregistrez au calme quand c’est possible.

🐞 Pièges fréquents

✅ Récapitulatif

Vous savez désormais donner des yeux à votre code. Vous envoyez une image en ligne pour les petits fichiers, vous passez par la File API pour les gros documents et les PDF, et surtout vous formulez des instructions précises qui transforment une simple description en extraction de données exploitables. L’OCR, la lecture de PDF mis en page et la comparaison de documents ne demandent plus d’outils spécialisés : ils tiennent dans quelques lignes autour de generate_content.

🧾 Aide-mémoire

💪 À vous de jouer

Écrivez un script qui prend en argument le chemin d’une image de carte de visite et en extrait le nom, la société, le téléphone et l’e-mail, en signalant les champs absents.

import sys
from dotenv import load_dotenv
from google import genai
from google.genai import types

load_dotenv()
client = genai.Client()

chemin = sys.argv[1]
with open(chemin, "rb") as f:
    donnees = f.read()

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[
        types.Part.from_bytes(data=donnees, mime_type="image/jpeg"),
        (
            "Extrais de cette carte de visite : nom, societe, telephone, e-mail. "
            "Presente une ligne par champ. Ecris 'absent' si un champ manque."
        ),
    ],
)
print(response.text)

Tutoriels suivants

• Sorties structurées JSON — transformer ces extractions en données validées.
• Function calling — enregistrer automatiquement les données extraites via vos fonctions.

Pour aller plus loin

🔝 Retour au guide principal de l’API Gemini. La documentation officielle précise les formats supportés et les limites de taille pour chaque type de fichier.

Questions fréquentes

Gemini fait-il de l’OCR ? Oui, nativement : il lit le texte présent dans une image sans outil séparé. La qualité dépend de la netteté de l’image.

Quelle taille maximale pour une image en ligne ? La bascule vers la File API devient obligatoire dès que la requête entière dépasse environ 100 Mo (50 Mo pour un PDF) ; en pratique, on y passe bien avant, dès qu’un fichier devient lourd, par souci de fiabilité.

Peut-on envoyer de l’audio ou de la vidéo ? Oui, la même logique de parts et de File API s’applique aux fichiers audio et vidéo, avec les types MIME correspondants.

Combien de temps un fichier téléversé reste-t-il disponible ? Environ deux jours, après quoi il est supprimé automatiquement ; il faut alors le re-téléverser.

Peut-on extraire un tableau d’un PDF vers un format exploitable ? Oui : demandez explicitement « restitue ce tableau au format CSV, une ligne par enregistrement ». Le modèle conserve l’alignement des colonnes et produit une sortie que vous pouvez écrire directement dans un fichier. Pour une garantie de structure encore plus forte, on combine cette demande avec les sorties structurées JSON.