L'API Gemini accepte l'entrée au format PDF, y compris les documents volumineux (jusqu'à 3 600 pages). Les modèles Gemini traitent les PDF avec une vision native et sont donc capables de comprendre à la fois le contenu textuel et les images dans les documents. Grâce à la prise en charge native de la vision PDF, les modèles Gemini peuvent:
- Analyser des diagrammes, des graphiques et des tableaux dans des documents
- Extraire des informations dans des formats de sortie structurés
- Répondre à des questions sur le contenu visuel et textuel de documents
- Résumer des documents
- Transcrire le contenu d'un document (par exemple, au format HTML) en conservant les mises en page et la mise en forme, pour l'utiliser dans des applications en aval
Ce tutoriel présente quelques façons d'utiliser l'API Gemini pour traiter des documents PDF.
Saisie au format PDF
Pour les charges utiles PDF de moins de 20 Mo, vous pouvez choisir d'importer des documents encodés en base64 ou d'importer directement des fichiers stockés localement.
En tant que données intégrées
Vous pouvez traiter des documents PDF directement à partir d'URL. Voici un extrait de code qui montre comment procéder:
from google import genai
from google.genai import types
import httpx
client = genai.Client()
doc_url = "https://discovery.ucl.ac.uk/id/eprint/10089234/1/343019_3_art_0_py4t4l_convrt.pdf"
# Retrieve and encode the PDF byte
doc_data = httpx.get(doc_url).content
prompt = "Summarize this document"
response = client.models.generate_content(
model="gemini-2.0-flash",
contents=[
types.Part.from_bytes(
data=doc_data,
mime_type='application/pdf',
),
prompt])
print(response.text)
Détails techniques
Gemini 1.5 Pro et Gemini 1.5 Flash sont compatibles avec un maximum de 3 600 pages de document. Les pages de document doivent correspondre à l'un des types MIME de données textuelles suivants:
- PDF -
application/pdf - JavaScript :
application/x-javascript,text/javascript - Python :
application/x-python,text/x-python - TXT :
text/plain - HTML :
text/html - CSS :
text/css - Markdown :
text/md - CSV :
text/csv - XML :
text/xml - RTF -
text/rtf
Chaque page de document équivaut à 258 jetons.
Bien qu'il n'existe aucune limite spécifique au nombre de pixels dans un document en dehors de la fenêtre contextuelle du modèle, les pages plus grandes sont réduites à une résolution maximale de 3 072 x 3 072, tout en préservant leur format d'origine, tandis que les pages plus petites sont agrandies à 768 x 768 pixels. Il n'y a pas de réduction des coûts pour les pages de taille inférieure, à l'exception de la bande passante, ni d'amélioration des performances pour les pages de résolution supérieure.
Pour des résultats optimaux, procédez comme suit :
- Faites pivoter les pages dans l'orientation appropriée avant de les importer.
- Évitez les pages floues.
- Si vous utilisez une seule page, placez la requête textuelle après la page.
PDF stockés localement
Pour les PDF stockés localement, vous pouvez utiliser l'approche suivante:
from google import genai
from google.genai import types
import pathlib
import httpx
client = genai.Client()
doc_url = "https://discovery.ucl.ac.uk/id/eprint/10089234/1/343019_3_art_0_py4t4l_convrt.pdf"
# Retrieve and encode the PDF byte
filepath = pathlib.Path('file.pdf')
filepath.write_bytes(httpx.get(doc_url).content)
prompt = "Summarize this document"
response = client.models.generate_content(
model="gemini-2.0-flash",
contents=[
types.Part.from_bytes(
data=filepath.read_bytes(),
mime_type='application/pdf',
),
prompt])
print(response.text)
PDF volumineux
Vous pouvez utiliser l'API File pour importer un document de n'importe quelle taille. Utilisez toujours l'API File lorsque la taille totale de la requête (y compris les fichiers, l'invite de texte, les instructions système, etc.) est supérieure à 20 Mo.
Appelez media.upload pour importer un fichier à l'aide de l'API File. Le code suivant importe un fichier de document, puis l'utilise dans un appel à models.generateContent.
PDF volumineux à partir d'URL
Utilisez l'API File pour les fichiers PDF volumineux disponibles via des URL, ce qui simplifie le processus d'importation et de traitement de ces documents directement via leurs URL:
from google import genai
from google.genai import types
import io
import httpx
client = genai.Client()
long_context_pdf_path = "https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf"
# Retrieve and upload the PDF using the File API
doc_io = io.BytesIO(httpx.get(long_context_pdf_path).content)
sample_doc = client.files.upload(
# You can pass a path or a file-like object here
file=doc_io,
config=dict(
mime_type='application/pdf')
)
prompt = "Summarize this document"
response = client.models.generate_content(
model="gemini-2.0-flash",
contents=[sample_doc, prompt])
print(response.text)
Fichiers PDF volumineux stockés localement
from google import genai
from google.genai import types
import pathlib
import httpx
client = genai.Client()
long_context_pdf_path = "https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf"
# Retrieve the PDF
file_path = pathlib.Path('A17.pdf')
file_path.write_bytes(httpx.get(long_context_pdf_path).content)
# Upload the PDF using the File API
sample_file = client.files.upload(
file=file_path,
)
prompt="Summarize this document"
response = client.models.generate_content(
model="gemini-2.0-flash",
contents=[sample_file, "Summarize this document"])
print(response.text)
Vous pouvez vérifier que l'API a bien stocké le fichier importé et obtenir ses métadonnées en appelant files.get. Seuls les name (et par extension, les uri) sont uniques.
from google import genai
import pathlib
client = genai.Client()
fpath = pathlib.Path('example.txt')
fpath.write_text('hello')
file = client.files.upload('example.txt')
file_info = client.files.get(file.name)
print(file_info.model_dump_json(indent=4))
Plusieurs PDF
L'API Gemini peut traiter plusieurs documents PDF dans une seule requête, à condition que la taille combinée des documents et de l'invite textuelle reste dans la fenêtre de contexte du modèle.
from google import genai
import io
import httpx
client = genai.Client()
doc_url_1 = "https://arxiv.org/pdf/2312.11805"
doc_url_2 = "https://arxiv.org/pdf/2403.05530"
# Retrieve and upload both PDFs using the File API
doc_data_1 = io.BytesIO(httpx.get(doc_url_1).content)
doc_data_2 = io.BytesIO(httpx.get(doc_url_2).content)
sample_pdf_1 = client.files.upload(
file=doc_data_1,
config=dict(mime_type='application/pdf')
)
sample_pdf_2 = client.files.upload(
file=doc_data_2,
config=dict(mime_type='application/pdf')
)
prompt = "What is the difference between each of the main benchmarks between these two papers? Output these in a table."
response = client.models.generate_content(
model="gemini-2.0-flash",
contents=[sample_pdf_1, sample_pdf_2, prompt])
print(response.text)
Étape suivante
Pour en savoir plus, consultez les ressources suivantes :
- Stratégies d'invite de fichier: l'API Gemini prend en charge les invites avec des données textuelles, des images, des données audio et des données vidéo, également appelées invites multimodales.
- Instructions système: les instructions système vous permettent d'orienter le comportement du modèle en fonction de vos besoins et de vos cas d'utilisation spécifiques.