Conheça os recursos de processamento de documentos com a API Gemini

A API Gemini oferece suporte à entrada de PDF, incluindo documentos longos (até 3.600 páginas). Os modelos Gemini processam PDFs com visão nativa e, portanto, são capazes de entender o conteúdo de texto e imagem nos documentos. Com suporte nativo à visão de PDF, os modelos do Gemini podem:

  • Analise diagramas, gráficos e tabelas nos documentos.
  • Extraia informações em formatos de saída estruturados.
  • Responda a perguntas sobre conteúdo visual e de texto em documentos.
  • Resumir documentos.
  • Transcrever o conteúdo do documento (por exemplo, para HTML) preservando layouts e formatação para uso em aplicativos downstream (como em pipelines de RAG).

Este tutorial demonstra algumas maneiras de usar a API Gemini com documentos PDF. Toda a saída é somente texto.

Antes de começar: configure o projeto e a chave de API

Antes de chamar a API Gemini, você precisa configurar seu projeto e sua chave de API.

Como fazer perguntas com PDFs

Este guia demonstra como fazer upload e processar PDFs usando a API File ou incluindo-os como dados inline.

Detalhes técnicos

O Gemini 1.5 Pro e o 1.5 Flash oferecem suporte a um máximo de 3.600 páginas de documento. As páginas do documento precisam estar em um dos seguintes tipos MIME de dados de texto:

  • 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

Cada página de documento equivale a 258 tokens.

Embora não haja limites específicos para o número de pixels em um documento além da janela de contexto do modelo, páginas maiores são reduzidas para uma resolução máxima de 3072 x 3072, preservando a proporção original, enquanto páginas menores são aumentadas para 768 x 768 pixels. Não há redução de custo para páginas de tamanhos menores, exceto a largura de banda, ou melhoria de desempenho para páginas de resolução maior.

Para os melhores resultados:

  • Gire as páginas para a orientação correta antes de fazer o upload.
  • Evite páginas desfocadas.
  • Se você estiver usando uma única página, coloque o comando de texto depois dela.

Entrada de PDF

Para payloads de PDF com menos de 20 MB, você pode fazer upload de documentos codificados em base64 ou fazer upload direto de arquivos armazenados localmente.

Documentos codificados em Base64

É possível processar documentos PDF diretamente de URLs. Confira um snippet de código que mostra como fazer isso:

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)

PDFs armazenados localmente

Para PDFs armazenados localmente, use a seguinte abordagem:

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)

PDFs grandes

Você pode usar a API File para fazer upload de um documento de qualquer tamanho. Sempre use a API File quando o tamanho total da solicitação (incluindo arquivos, comando de texto, instruções do sistema etc.) for maior que 20 MB.

Chame media.upload para fazer upload de um arquivo usando a API File. O código a seguir faz o upload de um arquivo de documento e o usa em uma chamada para models.generateContent.

PDFs grandes de URLs (:#large-pdfs-urls)

Use a API File para arquivos PDF grandes disponíveis em URLs, simplificando o processo de upload e processamento desses documentos diretamente pelos URLs:

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)

PDFs grandes armazenados localmente (:#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

É possível verificar se a API armazenou o arquivo enviado e acessar os metadados dele chamando files.get. Somente o name (e, por extensão, o uri) são exclusivos.

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

Vários PDFs

A API Gemini é capaz de processar vários documentos PDF em uma única solicitação, desde que o tamanho combinado dos documentos e do comando de texto fique dentro da janela de contexto do modelo.

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)

Listar arquivos

É possível listar todos os arquivos enviados usando a API File e os URIs deles usando files.list.

import google.generativeai as genai

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

Excluir arquivos

Os arquivos enviados usando a API File são excluídos automaticamente após dois dias. Também é possível excluí-las manualmente usando 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

Armazenamento em cache de contexto com PDFs

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)

Listar caches

Não é possível extrair ou visualizar o conteúdo armazenado em cache, mas é possível extrair metadados de cache (name, model, display_name, usage_metadata, create_time, update_time e expire_time).

Para listar os metadados de todos os caches enviados, use CachedContent.list():

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

Atualizar um cache

É possível definir um novo ttl ou expire_time para um cache. Não é possível mudar qualquer outra coisa no cache.

O exemplo a seguir mostra como atualizar o ttl de um cache usando CachedContent.update().

import datetime

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

Excluir um cache

O serviço de cache oferece uma operação de exclusão para remover manualmente o conteúdo do cache. O exemplo a seguir mostra como excluir um cache usando CachedContent.delete().

cache.delete()

A seguir

Este guia mostra como usar generateContent e gerar saídas de texto de documentos processados. Para saber mais, confira estes recursos:

  • Estratégias de solicitação de arquivo: a API Gemini oferece suporte a solicitações com dados de texto, imagem, áudio e vídeo, também conhecidas como solicitações multimodais.
  • Instruções do sistema: as instruções do sistema permitem orientar o comportamento do modelo com base nas suas necessidades e casos de uso específicos.
  • Orientações de segurança: às vezes, os modelos de IA generativa produzem resultados inesperados, como respostas imprecisas, parciais ou ofensivas. O pós-processamento e a avaliação humana são essenciais para limitar o risco de danos causados por essas saídas.