Découvrez les capacités de traitement de documents avec l'API Gemini

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 compatibilité native avec la vision PDF, les modèles Gemini peuvent:

  • Analysez les diagrammes, les graphiques et les tableaux dans les documents.
  • Extrayez des informations dans des formats de sortie structurés.
  • Répondre à des questions sur le contenu visuel et textuel des documents
  • Résumer des documents
  • Transcrire le contenu d'un document (par exemple, au format HTML) en préservant les mises en page et la mise en forme, pour l'utiliser dans les applications en aval (par exemple, dans les pipelines RAG).

Ce tutoriel présente quelques façons d'utiliser l'API Gemini avec des documents PDF. Toutes les sorties sont textuelles uniquement.

Avant de commencer: configurez votre projet et votre clé API

Avant d'appeler l'API Gemini, vous devez configurer votre projet et votre clé API.

Requêtes avec des PDF

Ce guide explique comment importer et traiter des fichiers PDF à l'aide de l'API File ou en les incluant en tant que données intégrées.

Détails techniques

Gemini 1.5 Pro et Gemini 1.5 Flash sont compatibles avec un maximum de 3 600 pages de documents. 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.

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.

Documents encodés en base64

Vous pouvez traiter des documents PDF directement à partir d'URL. Voici un extrait de code qui vous montre comment procéder:

import httpx
import base64

model = genai.GenerativeModel("gemini-1.5-flash")
doc_url = "https://discovery.ucl.ac.uk/id/eprint/10089234/1/343019_3_art_0_py4t4l_convrt.pdf"  # Replace with the actual URL of your PDF

# Retrieve and encode the PDF
doc_data = base64.standard_b64encode(httpx.get(doc_url).content).decode("utf-8")

prompt = "Summarize this document"

response = model.generate_content([{'mime_type':'application/pdf', 'data': doc_data}, prompt])
print(response.text)

PDF stockés localement

Pour les PDF stockés localement, vous pouvez utiliser l'approche suivante:

import base64

model = genai.GenerativeModel("gemini-1.5-flash")
doc_path = "/path/to/file.pdf" # Replace with the actual path to your local PDF

# Read and encode the local file
with open(doc_path, "rb") as doc_file:
    doc_data = base64.standard_b64encode(doc_file.read()).decode("utf-8")

prompt = "Summarize this document"

response = model.generate_content([{'mime_type': 'application/pdf', 'data': doc_data}, 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 (:#large-pdfs-urls)

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:

import io
import httpx

model = genai.GenerativeModel("gemini-1.5-flash")
long_context_pdf_path = "https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf" # Replace with the actual URL of your large PDF

# Retrieve and upload the PDF using the File API
doc_data = io.BytesIO(httpx.get(long_context_pdf_path).content)
sample_doc = genai.upload_file(data=doc_data, mime_type='application/pdf')

prompt = "Summarize this document"

response = model.generate_content([sample_doc, prompt])
print(response.text)

PDF volumineux stockés en local (:#large-pdfs-local)

import google.generativeai as genai

model = genai.GenerativeModel("gemini-1.5-flash")
sample_pdf = genai.upload_file(media / "test.pdf")
response = model.generate_content(["Give me a summary of this pdf file.", sample_pdf])
print(response.text)
files.py

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.

import google.generativeai as genai

myfile = genai.upload_file(media / "poem.txt")
file_name = myfile.name
print(file_name)  # "files/*"

myfile = genai.get_file(file_name)
print(myfile)
files.py

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 de texte reste dans la fenêtre de contexte du modèle.

import io
import httpx

model = genai.GenerativeModel("gemini-1.5-flash")

doc_url_1 = "https://arxiv.org/pdf/2312.11805" # Replace with the URL to your first PDF
doc_url_2 = "https://arxiv.org/pdf/2403.05530" # Replace with the URL to your second PDF

# 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 = genai.upload_file(data=doc_data_1, mime_type='application/pdf')
sample_pdf_2 = genai.upload_file(data=doc_data_2, 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 = model.generate_content([sample_pdf_1, sample_pdf_2, prompt])
print(response.text)

Répertorier les fichiers

Vous pouvez lister tous les fichiers importés à l'aide de l'API File et leurs URI à l'aide de files.list.

import google.generativeai as genai

print("My files:")
for f in genai.list_files():
    print("  ", f.name)
files.py

Supprimer des fichiers

Les fichiers importés à l'aide de l'API File sont automatiquement supprimés au bout de deux jours. Vous pouvez également les supprimer manuellement à l'aide de files.delete.

import google.generativeai as genai

myfile = genai.upload_file(media / "poem.txt")

myfile.delete()

try:
    # Error.
    model = genai.GenerativeModel("gemini-1.5-flash")
    result = model.generate_content([myfile, "Describe this file."])
except google.api_core.exceptions.PermissionDenied:
    pass
files.py

Mise en cache du contexte avec les PDF

import os
from google.generativeai import caching
import io
import httpx

# Define the path to the PDF document (or use a URL)
long_context_pdf_path = "https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf" # Replace with the URL of your large PDF
doc_data = io.BytesIO(httpx.get(long_context_pdf_path).content)

# Upload the PDF document using the File API
document = genai.upload_file(data=doc_data, mime_type='application/pdf')

# Specify the model name and system instruction for caching
model_name = "gemini-1.5-flash-002" # Ensure this matches the model you intend to use
system_instruction = "You are an expert analyzing transcripts."

# Create a cached content object
cache = caching.CachedContent.create(
    model=model_name,
    system_instruction=system_instruction,
    contents=[document], # The document(s) and other content you wish to cache
)

# Display the cache details
print(cache)

# Initialize a generative model from the cached content
model = genai.GenerativeModel.from_cached_content(cache)

# Generate content using the cached prompt and document
response = model.generate_content("Please summarize this transcript")

# (Optional) Print usage metadata for insights into the API call
print(response.usage_metadata)

# Print the generated text
print(response.text)

Répertorier les caches

Il n'est pas possible de récupérer ni d'afficher le contenu mis en cache, mais vous pouvez récupérer les métadonnées de cache (name, model, display_name, usage_metadata, create_time, update_time et expire_time).

Pour lister les métadonnées de tous les caches importés, utilisez CachedContent.list():

for c in caching.CachedContent.list():
  print(c)

Mettre à jour un cache

Vous pouvez définir un nouveau ttl ou expire_time pour un cache. Il n'est pas possible de modifier tout autre élément du cache.

L'exemple suivant montre comment mettre à jour le ttl d'un cache à l'aide de CachedContent.update().

import datetime

cache.update(ttl=datetime.timedelta(hours=2))

Supprimer un cache

Le service de mise en cache fournit une opération de suppression permettant de supprimer manuellement du contenu du cache. L'exemple suivant montre comment supprimer un cache à l'aide de CachedContent.delete().

cache.delete()

Étape suivante

Ce guide explique comment utiliser generateContent et générer des sorties textuelles à partir de documents traités. 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.
  • Conseils de sécurité: Les modèles d'IA générative produisent parfois des résultats inattendus, comme des résultats inexacts, biaisés ou choquants. Le post-traitement et l'évaluation humaine sont essentiels pour limiter le risque de préjudices liés à ces sorties.