Using files

L'API Gemini supporta il caricamento di file multimediali separatamente dall'input del prompt, consentendo il riutilizzo dei contenuti multimediali in più richieste e più prompt. Per maggiori dettagli, consulta la guida Prompt con contenuti multimediali.

Metodo: media.upload

Carica i dati in un ragStore, li pre-elabora e li suddivide in blocchi prima di archiviarli in un documento RagStore.

Endpoint

  • URI di caricamento, per le richieste di caricamento dei contenuti multimediali:
post https://generativelanguage.googleapis.com/upload/v1beta/{ragStoreName=ragStores/*}:uploadToRagStore
  • URI dei metadati, per le richieste solo di metadati:
post https://generativelanguage.googleapis.com/v1beta/{ragStoreName=ragStores/*}:uploadToRagStore

Parametri del percorso

ragStoreName string

Obbligatorio. Immutabile. Il nome del RagStore in cui caricare il file. Esempio: ragStores/my-rag-store-123 Assume la forma ragStores/{ragstore}.

Corpo della richiesta

Il corpo della richiesta contiene dati con la seguente struttura:

Campi
displayName string

Facoltativo. Il nome visualizzato del documento creato.

customMetadata[] object (CustomMetadata)

Metadati personalizzati da associare ai dati.

chunkingConfig object (ChunkingConfig)

Facoltativo. Configurazione per indicare al servizio come segmentare i dati. Se non vengono forniti, il servizio utilizzerà i parametri predefiniti.

mimeType string

Facoltativo. Tipo MIME dei dati. Se non viene fornito, verrà dedotto dai contenuti caricati.

Corpo della risposta

Questa è una copia di google.longrunning.Operation. Dobbiamo copiarlo perché per interagire con Scotty dobbiamo aggiungere un campo specifico di Scotty che non può essere aggiunto nel proto dell'operazione di primo livello.

In caso di esito positivo, il corpo della risposta contiene dati con la seguente struttura:

Campi
name string

Il nome assegnato dal server, che è univoco solo all'interno dello stesso servizio che lo restituisce originariamente. Se utilizzi la mappatura HTTP predefinita, name deve essere un nome di risorsa che termina con operations/{unique_id}.

metadata object

Metadati specifici del servizio associati all'operazione. In genere contengono informazioni sullo stato di avanzamento e metadati comuni come l'ora di creazione. Alcuni servizi potrebbero non fornire questi metadati. Qualsiasi metodo che restituisce un'operazione a lunga esecuzione deve documentare il tipo di metadati, se presenti.

Un oggetto contenente campi di un tipo arbitrario. Un campo aggiuntivo "@type" contiene un URI che identifica il tipo. Esempio: { "id": 1234, "@type": "types.example.com/standard/id" }

done boolean

Se il valore è false, significa che l'operazione è ancora in corso. Se true, l'operazione viene completata e sono disponibili error o response.

result Union type
Il risultato dell'operazione, che può essere un error o una response valida. Se done == false, né errorresponse vengono impostati. Se done == true, è possibile impostare esattamente uno dei valori error o response. Alcuni servizi potrebbero non fornire il risultato. result può essere solo uno dei seguenti:
error object (Status)

Il risultato di errore dell'operazione in caso di errore o annullamento.

response object

La risposta normale e con esito positivo dell'operazione. Se il metodo originale non restituisce dati in caso di esito positivo, ad esempio Delete, la risposta è google.protobuf.Empty. Se il metodo originale è Get/Create/Update standard, la risposta deve essere la risorsa. Per gli altri metodi, la risposta deve avere il tipo XxxResponse, dove Xxx è il nome del metodo originale. Ad esempio, se il nome del metodo originale è TakeSnapshot(), il tipo di risposta dedotto è TakeSnapshotResponse.

Un oggetto contenente campi di un tipo arbitrario. Un campo aggiuntivo "@type" contiene un URI che identifica il tipo. Esempio: { "id": 1234, "@type": "types.example.com/standard/id" }

Rappresentazione JSON
{
  "name": string,
  "metadata": {
    "@type": string,
    field1: ...,
    ...
  },
  "done": boolean,

  // result
  "error": {
    object (Status)
  },
  "response": {
    "@type": string,
    field1: ...,
    ...
  }
  // Union type
}

ChunkingConfig

Parametri per indicare al servizio come segmentare il file. Ispirato a google3/cloud/ai/platform/extension/lib/retrieval/config/chunker_config.proto

Campi
config Union type
La configurazione di suddivisione in blocchi da utilizzare. config può essere solo uno dei seguenti:
whiteSpaceConfig object (WhiteSpaceConfig)

Configurazione della suddivisione degli spazi vuoti.

Rappresentazione JSON
{

  // config
  "whiteSpaceConfig": {
    object (WhiteSpaceConfig)
  }
  // Union type
}

WhiteSpaceConfig

Configurazione per un algoritmo di suddivisione in blocchi degli spazi vuoti [delimitati da spazi vuoti].

Campi
maxTokensPerChunk integer

Numero massimo di token per blocco. I token sono definiti come parole per questo algoritmo di chunking. Nota: definiamo i token come parole separate da spazi bianchi anziché come output di un tokenizzatore. Al 17 aprile 2025, la finestra contestuale dell'ultimo modello di incorporamento Gemini è attualmente di 8192 token. Supponiamo che una parola media sia composta da 5 caratteri. Pertanto, abbiamo impostato il limite superiore a 2**9, ovvero 512 parole o 2560 token, supponendo nel caso peggiore un carattere per token. Si tratta di una stima prudente pensata per evitare l'overflow della finestra contestuale.

maxOverlapTokens integer

Numero massimo di token sovrapposti tra due chunk adiacenti.

Rappresentazione JSON
{
  "maxTokensPerChunk": integer,
  "maxOverlapTokens": integer
}

Metodo: files.get

Recupera i metadati per l'elemento File specificato.

Endpoint

get https://generativelanguage.googleapis.com/v1beta/{name=files/*}

Parametri del percorso

name string

Obbligatorio. Il nome di File da ottenere. Esempio: files/abc-123 Assume la forma files/{file}.

Corpo della richiesta

Il corpo della richiesta deve essere vuoto.

Esempio di richiesta

Python

from google import genai

client = genai.Client()
myfile = client.files.upload(file=media / "poem.txt")
file_name = myfile.name
print(file_name)  # "files/*"

myfile = client.files.get(name=file_name)
print(myfile)

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const myfile = await ai.files.upload({
  file: path.join(media, "poem.txt"),
});
const fileName = myfile.name;
console.log(fileName);

const fetchedFile = await ai.files.get({ name: fileName });
console.log(fetchedFile);

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
myfile, err := client.Files.UploadFromPath(
	ctx,
	filepath.Join(getMedia(), "poem.txt"), 
	&genai.UploadFileConfig{
		MIMEType: "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
fileName := myfile.Name
fmt.Println(fileName)
file, err := client.Files.Get(ctx, fileName, nil)
if err != nil {
	log.Fatal(err)
}
fmt.Println(file)

Conchiglia

name=$(jq ".file.name" file_info.json)
# Get the file of interest to check state
curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
# Print some information about the file you got
name=$(jq ".file.name" file_info.json)
echo name=$name
file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

Corpo della risposta

In caso di esito positivo, il corpo della risposta contiene un'istanza di File.

Metodo: files.list

Elenca i metadati per File di proprietà del progetto richiedente.

Endpoint

get https://generativelanguage.googleapis.com/v1beta/files

Parametri di query

pageSize integer

Facoltativo. Il numero massimo di File da restituire per pagina. Se non specificato, il valore predefinito è 10. Il valore massimo di pageSize è 100.

pageToken string

Facoltativo. Un token di pagina di una precedente chiamata files.list.

Corpo della richiesta

Il corpo della richiesta deve essere vuoto.

Esempio di richiesta

Python

from google import genai

client = genai.Client()
print("My files:")
for f in client.files.list():
    print("  ", f.name)

Node.js

// Make sure to include the following import:
// import {GoogleGenAI} from '@google/genai';
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
console.log("My files:");
// Using the pager style to list files
const pager = await ai.files.list({ config: { pageSize: 10 } });
let page = pager.page;
const names = [];
while (true) {
  for (const f of page) {
    console.log("  ", f.name);
    names.push(f.name);
  }
  if (!pager.hasNextPage()) break;
  page = await pager.nextPage();
}

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
fmt.Println("My files:")
page, err := client.Files.List(ctx, nil)
if err != nil {
	log.Fatal(err)
}
for _, f := range page.Items {
	fmt.Println("  ", f.Name)
}

Conchiglia

echo "My files: "

curl "https://generativelanguage.googleapis.com/v1beta/files?key=$GEMINI_API_KEY"

Corpo della risposta

Risposta per files.list.

In caso di esito positivo, il corpo della risposta contiene dati con la seguente struttura:

Campi
files[] object (File)

L'elenco di File.

nextPageToken string

Un token che può essere inviato come pageToken in una successiva chiamata files.list.

Rappresentazione JSON
{
  "files": [
    {
      object (File)
    }
  ],
  "nextPageToken": string
}

Metodo: files.delete

Elimina File.

Endpoint

delete https://generativelanguage.googleapis.com/v1beta/{name=files/*}

Parametri del percorso

name string

Obbligatorio. Il nome di File da eliminare. Esempio: files/abc-123 Assume la forma files/{file}.

Corpo della richiesta

Il corpo della richiesta deve essere vuoto.

Esempio di richiesta

Python

from google import genai

client = genai.Client()
myfile = client.files.upload(file=media / "poem.txt")

client.files.delete(name=myfile.name)

try:
    result = client.models.generate_content(
        model="gemini-2.0-flash", contents=[myfile, "Describe this file."]
    )
    print(result)
except genai.errors.ClientError:
    pass

Node.js

// The Gen AI SDK for TypeScript and JavaScript is in preview.
// Some features have not been implemented.

Go

ctx := context.Background()
client, err := genai.NewClient(ctx, &genai.ClientConfig{
	APIKey:  os.Getenv("GEMINI_API_KEY"),
	Backend: genai.BackendGeminiAPI,
})
if err != nil {
	log.Fatal(err)
}
myfile, err := client.Files.UploadFromPath(
	ctx, 
	filepath.Join(getMedia(), "poem.txt"), 
	&genai.UploadFileConfig{
		MIMEType: "text/plain",
	},
)
if err != nil {
	log.Fatal(err)
}
// Delete the file.
_, err = client.Files.Delete(ctx, myfile.Name, nil)
if err != nil {
	log.Fatal(err)
}
// Attempt to use the deleted file.
parts := []*genai.Part{
	genai.NewPartFromURI(myfile.URI, myfile.MIMEType,),
	genai.NewPartFromText("Describe this file."),
}

contents := []*genai.Content{
	genai.NewContentFromParts(parts, genai.RoleUser),
}

_, err = client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
// Expect an error when using a deleted file.
if err != nil {
	return nil
}
return fmt.Errorf("expected an error when using deleted file")

Conchiglia

curl --request "DELETE" https://generativelanguage.googleapis.com/v1beta/files/$name?key=$GEMINI_API_KEY

Corpo della risposta

In caso di esito positivo, il corpo della risposta è un oggetto JSON vuoto.

Risorsa REST: files

Risorsa: File

Un file caricato nell'API. Next ID: 15

Campi
name string

Immutabile. Identificatore. Il nome della risorsa File. L'ID (nome escluso il prefisso "files/") può contenere fino a 40 caratteri alfanumerici minuscoli o trattini (-). L'ID non può iniziare o terminare con un trattino. Se il nome è vuoto al momento della creazione, verrà generato un nome univoco. Esempio: files/123-456

displayName string

Facoltativo. Il nome visualizzato leggibile per File. Il nome visualizzato non deve contenere più di 512 caratteri, spazi inclusi. Esempio: "Immagine di benvenuto"

mimeType string

Solo output. Tipo MIME del file.

sizeBytes string (int64 format)

Solo output. Le dimensioni del file in byte.

createTime string (Timestamp format)

Solo output. Timestamp della creazione di File.

Utilizza RFC 3339, in cui l'output generato è sempre normalizzato in base al fuso orario UTC e utilizza 0, 3, 6 o 9 cifre frazionarie. Sono accettati anche offset diversi da "Z". Esempi: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" o "2014-10-02T15:01:23+05:30".

updateTime string (Timestamp format)

Solo output. Il timestamp dell'ultimo aggiornamento di File.

Utilizza RFC 3339, in cui l'output generato è sempre normalizzato in base al fuso orario UTC e utilizza 0, 3, 6 o 9 cifre frazionarie. Sono accettati anche offset diversi da "Z". Esempi: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" o "2014-10-02T15:01:23+05:30".

expirationTime string (Timestamp format)

Solo output. Il timestamp che indica quando verrà eliminato il File. Impostato solo se la scadenza di File è programmata.

Utilizza RFC 3339, in cui l'output generato è sempre normalizzato in base al fuso orario UTC e utilizza 0, 3, 6 o 9 cifre frazionarie. Sono accettati anche offset diversi da "Z". Esempi: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" o "2014-10-02T15:01:23+05:30".

sha256Hash string (bytes format)

Solo output. Hash SHA-256 dei byte caricati.

Una stringa con codifica Base64.

uri string

Solo output. L'URI di File.

downloadUri string

Solo output. L'URI di download di File.

state enum (State)

Solo output. Stato di elaborazione del file.

source enum (Source)

Origine del file.

error object (Status)

Solo output. Stato di errore se l'elaborazione del file non è riuscita.

metadata Union type
Metadati del file. metadata può essere solo uno dei seguenti:
videoMetadata object (VideoFileMetadata)

Solo output. Metadati di un video.

Rappresentazione JSON
{
  "name": string,
  "displayName": string,
  "mimeType": string,
  "sizeBytes": string,
  "createTime": string,
  "updateTime": string,
  "expirationTime": string,
  "sha256Hash": string,
  "uri": string,
  "downloadUri": string,
  "state": enum (State),
  "source": enum (Source),
  "error": {
    object (Status)
  },

  // metadata
  "videoMetadata": {
    object (VideoFileMetadata)
  }
  // Union type
}

VideoFileMetadata

Metadati di un video File.

Campi
videoDuration string (Duration format)

Durata del video.

Una durata in secondi con un massimo di nove cifre frazionarie, che termina con "s". Esempio: "3.5s".

Rappresentazione JSON
{
  "videoDuration": string
}

Stato

Stati del ciclo di vita di un file.

Enum
STATE_UNSPECIFIED Il valore predefinito. Questo valore viene utilizzato se lo stato viene omesso.
PROCESSING Il file è in fase di elaborazione e non può ancora essere utilizzato per l'inferenza.
ACTIVE Il file viene elaborato ed è disponibile per l'inferenza.
FAILED L'elaborazione del file non è riuscita.

Origine

Enum
SOURCE_UNSPECIFIED Utilizzato se l'origine non è specificata.
UPLOADED Indica che il file è stato caricato dall'utente.
GENERATED Indica che il file è generato da Google.
REGISTERED Indica che il file è registrato, ovvero un file Google Cloud Storage.

Stato

Il tipo Status definisce un modello di errore logico adatto a diversi ambienti di programmazione, tra cui API REST e API RPC. Viene utilizzato da gRPC. Ogni messaggio Status contiene tre elementi di dati: codice di errore, messaggio di errore e dettagli dell'errore.

Puoi scoprire di più su questo modello di errore e su come utilizzarlo nella guida alla progettazione delle API.

Campi
code integer

Il codice di stato, che deve essere un valore enum di google.rpc.Code.

message string

Un messaggio di errore rivolto agli sviluppatori, che deve essere in inglese. Qualsiasi messaggio di errore rivolto all'utente deve essere localizzato e inviato nel campo google.rpc.Status.details o localizzato dal client.

details[] object

Un elenco di messaggi che contengono i dettagli dell'errore. Esiste un insieme comune di tipi di messaggi che le API possono utilizzare.

Un oggetto contenente campi di un tipo arbitrario. Un campo aggiuntivo "@type" contiene un URI che identifica il tipo. Esempio: { "id": 1234, "@type": "types.example.com/standard/id" }

Rappresentazione JSON
{
  "code": integer,
  "message": string,
  "details": [
    {
      "@type": string,
      field1: ...,
      ...
    }
  ]
}