Document understanding

Puoi aggiungere documenti (file PDF e TXT) alle richieste di Gemini per eseguire attività che richiedono la comprensione dei contenuti dei documenti inclusi. Questa pagina mostra come aggiungere PDF alle tue richieste a Gemini in Gemini Enterprise Agent Platform utilizzando la console Google Cloud e l'API Agent Platform.

Modelli supportati

La tabella seguente elenca i modelli che supportano la comprensione dei documenti:

Modelli Info contenuti multimediali Tipi MIME
  • Dimensione massima per file per le importazioni tramite API o Cloud Storage: 50 MB
  • Dimensione massima per i caricamenti diretti tramite la console: 7 MB
  • text/plain
  • Numero massimo di file per prompt: come supportato dalla finestra contestuale di 128.000 token
  • Numero massimo di pagine per file: come supportato dalla finestra contestuale da 128.000 token
  • Dimensione massima della parte incorporata: 256 MB
  • Dimensioni massime per file da Cloud Storage: 2 GiB meno 500 KiB
  • Dimensione massima per file da URL HTTP o HTTPS pubblici: 15 MiB
  • Dimensione massima per file per i caricamenti locali diretti nella console: 7 MiB in linea (fino a 50 MiB con gestione temporanea in Cloud Storage)
  • Dimensioni massime per file per le importazioni da Google Drive nella console: 7 MB (10 MB in totale)
  • application/pdf
  • text/plain
  • Numero massimo di file per prompt: 3000 PDF (condivisi con immagini; fino a 6500 file totali se si include il testo normale)
  • Numero massimo di pagine per file: 3000
  • Dimensione massima della parte in linea (API GenerateContent): 256 MB
  • Dimensioni massime per file da Cloud Storage: 2 GiB meno 500 KiB
  • Dimensione massima per file da URL HTTP o HTTPS pubblici: 15 MiB
  • Dimensione massima per file per i caricamenti locali diretti nella console: 7 MiB in linea (fino a 50 MiB con gestione temporanea in Cloud Storage)
  • Dimensioni massime per file per le importazioni da Google Drive nella console: 7 MB (10 MB in totale)
  • Token di risoluzione predefiniti: 560
  • OCR per i PDF scansionati: non utilizzato per impostazione predefinita
  • application/pdf
  • text/plain
  • text/plain
  • Numero massimo di file per prompt: come supportato dalla finestra contestuale di 65.536 token
  • Numero massimo di pagine per file: come supportato dalla finestra di contesto di 65.536 token
  • Dimensione massima della parte incorporata: 256 MB
  • Dimensioni massime per file da Cloud Storage: 2 GiB meno 500 KiB
  • Dimensione massima per file da URL HTTP o HTTPS pubblici: 15 MiB
  • Dimensione massima per file per i caricamenti locali diretti nella console: 7 MiB in linea (fino a 50 MiB con gestione temporanea in Cloud Storage)
  • Dimensioni massime per file per le importazioni da Google Drive nella console: 7 MB (10 MB in totale)
  • application/pdf
  • text/plain
  • Numero massimo di file per prompt: 3000 PDF (condivisi con immagini; fino a 6500 file totali se si include il testo normale)
  • Numero massimo di pagine per file: 3000 (1000 su endpoint non migrati)
  • Dimensione massima della parte incorporata: 256 MB (50 MiB per PDF o 7 MiB per testo normale su endpoint non migrati)
  • Dimensioni massime per file da Cloud Storage: 2 GiB meno 500 KiB (50 MiB per PDF o 7 MiB per testo normale su endpoint non migrati)
  • Dimensione massima per file da URL HTTP o HTTPS pubblici: 15 MiB (7 MiB per il testo normale su endpoint non migrati)
  • Dimensione massima per file per i caricamenti locali diretti nella console: 7 MiB in linea (fino a 50 MiB con gestione temporanea in Cloud Storage)
  • Dimensioni massime per file per le importazioni da Google Drive nella console: 7 MB (10 MB in totale)
  • application/pdf
  • text/plain
  • Numero massimo di file per prompt: 3000 PDF (condivisi con immagini; fino a 6500 file totali se si include il testo normale)
  • Numero massimo di pagine per file: 1000
  • Dimensione massima della parte incorporata: 256 MB (50 MiB per PDF o 7 MiB per testo normale su endpoint non migrati)
  • Dimensioni massime per file da Cloud Storage: 2 GiB meno 500 KiB (50 MiB per PDF o 7 MiB per testo normale su endpoint non migrati)
  • Dimensione massima per file da URL HTTP o HTTPS pubblici: 15 MiB (7 MiB per il testo normale su endpoint non migrati)
  • Dimensione massima per file per i caricamenti locali diretti nella console: 7 MiB in linea (fino a 50 MiB con gestione temporanea in Cloud Storage)
  • Dimensioni massime per file per le importazioni da Google Drive nella console: 7 MB (10 MB in totale)
  • application/pdf
  • text/plain
  • Numero massimo di file per prompt: 3
  • Numero massimo di pagine per file: 3
  • Dimensione massima per file per le importazioni tramite API o Cloud Storage: 50 MB (application/pdf) o 7 MB (text/plain)
  • Dimensione massima per i caricamenti diretti tramite la console: 7 MB
  • application/pdf
  • text/plain

1 Questo è il TPM massimo degli input dei documenti in tutte le richieste di un progetto. Utilizza anche il TPM massimo per altre modalità.

La metrica della quota è generate_content_document_input_per_base_model_id_and_resolution.

Per un elenco delle lingue supportate dai modelli Gemini, consulta le informazioni sui modelli Google. Per scoprire di più su come progettare prompt multimodali, consulta Progetta prompt multimodali. Se stai cercando un modo per utilizzare Gemini direttamente dalle tue app web e mobile, consulta gli SDK client Firebase AI Logic per le app Swift, Android, web, Flutter e Unity.

Limiti degli endpoint API e della finestra contestuale

I modelli Gemini 3 e versioni successive standard accettano fino a 3000 immagini e PDF combinati, 1000 file audio o 10 video per richiesta sia in generateContent sia nell'API Interactions (fino a 6500 file multimodali combinati se sono inclusi file di testo normale). Gli endpoint Gemini 2.5 non migrati e gemini-3.1-pro-preview-customtools applicano i limiti legacy per le dimensioni dei file, le pagine PDF (1000) e il numero di URL HTTP o HTTPS. I limiti pratici delle richieste dipendono anche dall'endpoint API, dall'origine del file e dalla finestra di contesto:

  • Limite di URI dell'API Interactions per i file di Cloud Storage: le richieste API Interactions supportano fino a 100 URI Cloud Storage (gs://) distinti per richiesta di interazione del modello, inclusi gli URI riportati dai turni di conversazione precedenti tramite previous_interaction_id. Le richieste generateContent supportano gli URI gs:// fino al limite di elementi del modello.
  • Limiti per l'origine file, la parte inline e il payload della richiesta: i singoli file a cui viene fatto riferimento da Cloud Storage non possono superare i 2 GiB meno 500 KiB, mentre i file a cui viene fatto riferimento da URL HTTP o HTTPS pubblici non possono superare i 15 MiB. Su generateContent e streamGenerateContent, ogni allegato incorporato (inline_data) non può superare i 256 MB sui modelli Gemini 3 standard e successivi e il payload totale della richiesta HTTP o gRPC compressa non può superare i 500 MiB (la codifica base64 aggiunge circa il 33% di overhead delle dimensioni). Nell'API Interactions, il payload della richiesta HTTP compressa non può superare i 256 MiB per le richieste sincrone o in streaming; quando service_tier è impostato su deferred (che richiede che sia background sia store siano true), la richiesta non compressa non può superare i 9,75 MiB.
  • Finestra di contesto: il numero totale di token di tutti gli input multimodali e del testo in una richiesta non può superare il limite di token di input del modello (1.048.576 token su Gemini 3 standard e modelli successivi).

Aggiungi documenti a una richiesta

Il seguente esempio di codice mostra come includere un PDF in una richiesta di prompt. Questo esempio di PDF funziona con tutti i modelli multimodali di Gemini.

Python

Installa

pip install --upgrade google-genai

Per saperne di più, consulta la documentazione di riferimento dell'SDK.

Imposta le variabili di ambiente per utilizzare l'SDK Google Gen AI con Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True
 

from google import genai
from google.genai.types import HttpOptions, Part

client = genai.Client(http_options=HttpOptions(api_version="v1"))
model_id = "gemini-3.5-flash"

prompt = """
You are a highly skilled document summarization specialist.
Your task is to provide a concise executive summary of no more than 300 words.
Please summarize the given document for a general audience.
"""

pdf_file = Part.from_uri(
    file_uri="gs://cloud-samples-data/generative-ai/pdf/1706.03762v7.pdf",
    mime_type="application/pdf",
)

response = client.models.generate_content(
    model=model_id,
    contents=[pdf_file, prompt],
)

print(response.text)
# Example response:
# Here is a summary of the document in 300 words.
#
# The paper introduces the Transformer, a novel neural network architecture for
# sequence transduction tasks like machine translation. Unlike existing models that rely on recurrent or
# convolutional layers, the Transformer is based entirely on attention mechanisms.
# ...

Go

Scopri come installare o aggiornare l'Go.

Per saperne di più, consulta la documentazione di riferimento dell'SDK.

Imposta le variabili di ambiente per utilizzare l'SDK Google Gen AI con Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True
 

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/genai"
)

// generateTextWithPDF shows how to generate text using a PDF file input.
func generateTextWithPDF(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	modelName := "gemini-2.5-flash"
	contents := []*genai.Content{
		{Parts: []*genai.Part{
			{Text: `You are a highly skilled document summarization specialist.
	Your task is to provide a concise executive summary of no more than 300 words.
	Please summarize the given document for a general audience.`},
			{FileData: &genai.FileData{
				FileURI:  "gs://cloud-samples-data/generative-ai/pdf/1706.03762v7.pdf",
				MIMEType: "application/pdf",
			}},
		},
			Role: genai.RoleUser},
	}

	resp, err := client.Models.GenerateContent(ctx, modelName, contents, nil)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}

	respText := resp.Text()

	fmt.Fprintln(w, respText)

	// Example response:
	// "Attention Is All You Need" introduces the Transformer,
	// a groundbreaking neural network architecture designed for...
	// ...

	return nil
}

Java

Scopri come installare o aggiornare l'Java.

Per saperne di più, consulta la documentazione di riferimento dell'SDK.

Imposta le variabili di ambiente per utilizzare l'SDK Google Gen AI con Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True
 


import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.Part;

public class TextGenerationWithPdf {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash";
    generateContent(modelId);
  }

  // Generates text with PDF file input
  public static String generateContent(String modelId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      String prompt =
          "You are a highly skilled document summarization specialist.\n"
              + " Your task is to provide a concise executive summary of no more than 300 words.\n"
              + " Please summarize the given document for a general audience";

      GenerateContentResponse response =
          client.models.generateContent(
              modelId,
              Content.fromParts(
                  Part.fromUri(
                      "gs://cloud-samples-data/generative-ai/pdf/1706.03762v7.pdf",
                      "application/pdf"),
                  Part.fromText(prompt)),
              null);

      System.out.print(response.text());
      // Example response:
      // The document introduces the Transformer, a novel neural network architecture designed for
      // sequence transduction tasks, such as machine translation. Unlike previous dominant models
      // that rely on complex recurrent or convolutional neural networks, the Transformer proposes a
      // simpler, more parallelizable design based *solely* on attention mechanisms, entirely
      // dispensing with recurrence and convolutions...

      return response.text();
    }
  }
}

Node.js

Installa

npm install @google/genai

Per saperne di più, consulta la documentazione di riferimento dell'SDK.

Imposta le variabili di ambiente per utilizzare l'SDK Google Gen AI con Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True
 

const {GoogleGenAI} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';

async function generateText(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const prompt = `You are a highly skilled document summarization specialist.
    Your task is to provide a concise executive summary of no more than 300 words.
    Please summarize the given document for a general audience.`;

  const pdfFile = {
    fileData: {
      fileUri: 'gs://cloud-samples-data/generative-ai/pdf/1706.03762v7.pdf',
      mimeType: 'application/pdf',
    },
  };

  const response = await client.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: [pdfFile, prompt],
  });

  console.log(response.text);

  // Example response:
  //  Here is a summary of the document in 300 words.
  //  The paper introduces the Transformer, a novel neural network architecture for
  //  sequence transduction tasks like machine translation. Unlike existing models that rely on recurrent or
  //  convolutional layers, the Transformer is based entirely on attention mechanisms.
  //  ...

  return response.text;
}

C#

Scopri come installare o aggiornare l'C#.

Per saperne di più, consulta la documentazione di riferimento dell'SDK.

Imposta le variabili di ambiente per utilizzare l'SDK Google Gen AI con Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True
 


using Google.GenAI;
using Google.GenAI.Types;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class TextGenWithPdf
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "global",
        string model = "gemini-2.5-flash")
    {
        await using var client = new Client(
            project: projectId,
            location: location,
            vertexAI: true,
            httpOptions: new HttpOptions { ApiVersion = "v1" });

        string prompt = @"
            You are a highly skilled document summarization specialist.
            Your task is to provide a concise executive summary of no more than 300 words.
            Please summarize the given document for a general audience.";

        var contents = new List<Content>
        {
            new Content
            {
                Role = "user",
                Parts = new List<Part>
                {
                    new Part
                    {
                        FileData = new FileData
                        {
                            FileUri = "gs://cloud-samples-data/generative-ai/pdf/1706.03762v7.pdf",
                            MimeType = "application/pdf",
                        }
                    },
                    new Part { Text = prompt }
                }
            }
        };

        GenerateContentResponse response = await client.Models.GenerateContentAsync(model: model, contents: contents);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);
        // Example response:
        // This paper introduces the Transformer, a novel neural network architecture designed
        // for processing sequences, such as those found in language translation. Traditionally,
        // such tasks have relied on complex recurrent or convolutional neural networks...
        return responseText;
    }
}

REST

Dopo aver configurato l'ambiente, puoi utilizzare REST per testare un prompt testuale. L'esempio seguente invia una richiesta all'endpoint del modello del publisher.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • PROJECT_ID: il tuo ID progetto. .
  • FILE_URI: l'URI o l'URL del file da includere nel prompt. I valori accettati includono:
    • URI del bucket Cloud Storage: l'oggetto deve essere leggibile pubblicamente o risiedere nello stesso progetto Google Cloud che invia la richiesta.
    • URL HTTP: l'URL del file deve essere leggibile pubblicamente e non può superare i 15 MiB per file. I modelli Gemini 3 e versioni successive standard accettano fino a 3000 immagini e PDF combinati, 1000 file audio o 10 video per richiesta (fino a 6500 file totali se sono inclusi file di testo normale). Gli endpoint Gemini 2.5 non migrati e gemini-3.1-pro-preview-customtools limitano gli URL HTTP o HTTPS a 10 immagini, 1 file audio o 1 video per richiesta.
    • URL del video di YouTube: il video di YouTube deve essere di proprietà dell'account che hai utilizzato per accedere alla console Google Cloud o essere pubblico. È supportato un solo URL di video di YouTube per richiesta.

    Quando specifichi un fileURI, devi anche specificare il tipo di media (mimeType) del file. Se i Controlli di servizio VPC sono abilitati, non è supportata la specifica di un URL di un file multimediale per fileURI.

    Se non hai un file PDF in Cloud Storage, puoi utilizzare il seguente file disponibile pubblicamente: gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf con un tipo MIME application/pdf. Per visualizzare questo PDF, apri il file PDF di esempio.

  • MIME_TYPE: il tipo di media del file specificato nei campi data o fileUri. I valori accettabili includono:

    Fai clic per espandere i tipi MIME

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • image/webp
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
  • TEXT: le istruzioni di testo da includere nel prompt. Ad esempio: You are a very professional document summarization specialist. Please summarize the given document.

Per inviare la richiesta, scegli una di queste opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

cat > request.json << 'EOF'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
EOF

Quindi esegui questo comando per inviare la richiesta REST: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent"

PowerShell

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

@'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Quindi esegui questo comando per inviare la richiesta REST: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.5-flash:generateContent" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente.

Nell'URL di questo esempio, tieni presente quanto segue:
  • Utilizza il metodo generateContent per richiedere che la risposta venga restituita dopo che è stata generata completamente. Per ridurre la percezione della latenza per un pubblico umano, trasmetti la risposta in streaming mentre viene generata utilizzando il metodo streamGenerateContent.
  • L'ID del modello multimodale si trova alla fine dell'URL prima del metodo (ad esempio, gemini-3.5-flash). Questo esempio potrebbe supportare anche altri modelli.
  • Quando utilizzi un endpoint API regionale (ad esempio us-central1), la regione dell'URL dell'endpoint determina dove viene elaborata la richiesta. Qualsiasi località in conflitto nel percorso della risorsa viene ignorata.

Console

Per inviare un prompt multimodale utilizzando la console Google Cloud , segui questi passaggi:

  1. Nella sezione Agent Platform della console Google Cloud , vai alla pagina Agent Studio.

    Vai ad Agent Studio

  2. Fai clic su Crea prompt.

  3. (Facoltativo) Configura il modello e i parametri:

    • Modello: seleziona un modello.

  4. (Facoltativo) Per configurare i parametri avanzati, fai clic su Avanzate e configura quanto segue:

    Fai clic per espandere le configurazioni avanzate

    • Top-K: utilizza il cursore o la casella di testo per inserire un valore per top-K.

      Top-K cambia il modo in cui il modello seleziona i token per l'output. Un top-K pari a 1 indica che il token successivo selezionato è il più probabile tra tutti i token nel vocabolario del modello (chiamato anche decodifica greedy). Un top-K pari a 3 indica, invece, che il token successivo viene selezionato tra i tre token più probabili (utilizzando la temperatura).

      Per ogni fase di selezione dei token, vengono campionati i token Top-K con le probabilità più alte. Quindi i token vengono ulteriormente filtrati in base a top-P e il token finale viene selezionato utilizzando il campionamento con temperatura.

      Specifica un valore più basso per risposte meno casuali e un valore più alto per risposte più casuali.

    • Top-P: utilizza il cursore o la casella di testo per inserire un valore per top-P. I token vengono selezionati dal più probabile al meno probabile, finché la somma delle probabilità non corrisponde al valore di top-P. Per ridurre al minimo la variabilità dei risultati, imposta Top-P su 0.
    • Numero massimo di risposte: utilizza il cursore o la casella di testo per inserire un valore per il numero di risposte da generare.
    • Risposte dinamiche: attiva questa opzione per stampare le risposte man mano che vengono generate.
    • Soglia del filtro di sicurezza: seleziona la soglia di probabilità di ricevere risposte potenzialmente dannose.
    • Abilita grounding: il grounding non è supportato per i prompt multimodali.
    • Regione: seleziona la regione che vuoi utilizzare.
    • Temperatura: utilizza il cursore o la casella di testo per inserire un valore per la temperatura.

          
The temperature is used for sampling during response generation, which occurs when topP
and topK are applied. Temperature controls the degree of randomness in token selection.
Lower temperatures are good for prompts that require a less open-ended or creative response, while
higher temperatures can lead to more diverse or creative results. A temperature of 0
means that the highest probability tokens are always selected. In this case, responses for a given
prompt are mostly deterministic, but a small amount of variation is still possible.


      If the model returns a response that's too generic, too short, or the model gives a fallback
response, try increasing the temperature. If the model enters infinite generation, increasing the
temperature to at least 0.1 may lead to improved results.
       1.0 is the
recommended starting value for temperature.
</li>
  <li>**Output token limit**: Use the slider or textbox to enter a value for
    the max output limit.

    
Maximum number of tokens that can be generated in the response. A token is
approximately four characters. 100 tokens correspond to roughly 60-80 words.


      Specify a lower value for shorter responses and a higher value for potentially longer
responses.
      
</li>
  <li>**Add stop sequence**: Optional. Enter a stop sequence, which is a
    series of characters that includes spaces. If the model encounters a
    stop sequence, the response generation stops. The stop sequence isn't
    included in the response, and you can add up to five stop sequences.</li>
</ul>

  5. Fai clic su Inserisci contenuti multimediali e seleziona un'origine per il file.

    Carica

    Seleziona il file che vuoi caricare e fai clic su Apri.

    Tramite URL

    Inserisci l'URL del file che vuoi utilizzare e fai clic su Inserisci.

    Cloud Storage

    Seleziona il bucket e poi il file da importare dal bucket, quindi fai clic su Seleziona.

    Google Drive

    1. Scegli un account e concedi ad Agent Studio il consenso per accedere al tuo account la prima volta che selezioni questa opzione. Puoi caricare più file con una dimensione totale massima di 10 MB. Un singolo file non può superare i 7 MB.
    2. Fai clic sul file che vuoi aggiungere.

    3. Fai clic su Seleziona.

      La miniatura del file viene visualizzata nel riquadro Prompt. Viene visualizzato anche il numero totale di token. Se i dati del prompt superano il limite di token, i token vengono troncati e non vengono inclusi nell'elaborazione dei dati.

  6. Inserisci il prompt testuale nel riquadro Prompt.

  7. (Facoltativo) Per visualizzare l'ID token in testo e gli ID token, fai clic sul conteggio dei token nel riquadro Prompt.

  8. Fai clic su Invia.

  9. (Facoltativo) Per salvare il prompt in I miei prompt, fai clic su Salva.

  10. (Facoltativo) Per ottenere il codice Python o un comando curl per il prompt, fai clic su Crea con il codice > Ottieni codice.

Imposta i parametri facoltativi del modello

Ogni modello ha un insieme di parametri facoltativi che puoi impostare. Per ulteriori informazioni, consulta Parametri di generazione dei contenuti.

Tokenizzazione dei documenti

Con i modelli Gemini 3, la tokenizzazione dei documenti utilizza una lunghezza di sequenza variabile che sostituisce il metodo Pan and Scan utilizzato nei modelli precedenti per migliorare la qualità e la latenza.

Puoi specificare una risoluzione dei contenuti multimediali per gli input PDF, che influisce sulla modalità di tokenizzazione dei documenti e sul numero di token utilizzati per ogni documento. Puoi impostare media_resolution in generationConfig in modo che venga applicato a tutti i contenuti multimediali della richiesta oppure impostarlo per singole parti multimediali, il che sostituirà l'impostazione di primo livello.

Per i modelli Gemini 3 sono disponibili le seguenti risoluzioni:

  • MEDIA_RESOLUTION_HIGH: 1120 token per i PDF
  • MEDIA_RESOLUTION_MEDIUM: 560 token per i PDF
  • MEDIA_RESOLUTION_LOW: 280 token per pagina per i PDF
  • MEDIA_RESOLUTION_UNSPECIFIED: 560 per i PDF (predefinito)

Questo esempio di codice mostra come regolare media_resolution:

API GenerateContent

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
  model="gemini-3.1-pro-preview",
  contents=[
      types.Part(
          file_data=types.FileData(
              file_uri="gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png",
              mime_type="image/jpeg",
          ),
          media_resolution=types.PartMediaResolution(
              level=types.PartMediaResolutionLevel.MEDIA_RESOLUTION_HIGH
          ),
      ),
      types.Part(
          file_data=types.FileData(
              file_uri="gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4",
              mime_type="video/mp4",
          ),
          media_resolution=types.PartMediaResolution(
              level=types.PartMediaResolutionLevel.MEDIA_RESOLUTION_LOW
          ),
      ),
      "When does the image appear in the video? What is the context?",
  ],
)
print(response.text)

API Interactions

from google import genai

client = genai.Client(
    enterprise=True,
    project="PROJECT_ID",
    location="global",
)

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {
            "type": "image",
            "uri": "gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png",
            "mime_type": "image/png",
            "resolution": "high",  # Options: "low", "medium", "high", "ultra_high"
        },
        {
            "type": "video",
            "uri": "gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4",
            "mime_type": "video/mp4",
            "resolution": "low",  # Options: "low", "medium", "high", "ultra_high"
        },
        {
            "type": "text",
            "text": "When does the image appear in the video? What is the context?",
        },
    ],
)
print(interaction.output_text)

Best practice per i PDF

Quando utilizzi i PDF, segui queste best practice e informazioni per ottenere i risultati migliori:

  • Se il prompt contiene un singolo PDF, inserisci il PDF prima del prompt di testo nella richiesta.
  • Se hai un documento lungo, valuta la possibilità di suddividerlo in più PDF per elaborarlo.
  • Utilizza PDF creati con testo visualizzato come testo anziché utilizzare testo in immagini scansionate. Questo formato garantisce che il testo sia leggibile da macchina, in modo che sia più facile per il modello modificarlo, cercarlo e manipolarlo rispetto ai PDF di immagini scansionate. Questa pratica fornisce risultati ottimali quando si lavora con documenti con molto testo, come i contratti.

Limitazioni

Sebbene i modelli multimodali Gemini siano potenti in molti casi d'uso multimodali, è importante comprenderne i limiti:

  • Ragionamento spaziale: i modelli non sono precisi nell'individuare testo o oggetti nei PDF. Potrebbero restituire solo i conteggi approssimativi degli oggetti.
  • Accuratezza: i modelli potrebbero generare allucinazioni durante l'interpretazione del testo scritto a mano nei documenti PDF.

Passaggi successivi