Using files

L'API Gemini permet d'importer des fichiers multimédias séparément de l'entrée de requête. Vous pouvez ainsi réutiliser vos contenus multimédias dans plusieurs requêtes et plusieurs requêtes. Pour en savoir plus, consultez le guide Utiliser des éléments multimédias dans les requêtes.

Méthode : media.upload

Importe des données dans un ragStore, les prétraite et les segmente avant de les stocker dans un document RagStore.

Point de terminaison

  • URI d'importation pour les demandes d'importation de contenus multimédias :
post https://generativelanguage.googleapis.com/upload/v1beta/{ragStoreName=ragStores/*}:uploadToRagStore
  • URI des métadonnées, pour les demandes de métadonnées uniquement :
post https://generativelanguage.googleapis.com/v1beta/{ragStoreName=ragStores/*}:uploadToRagStore

Paramètres de chemin d'accès

ragStoreName string

Obligatoire. Immuable. Nom du RagStore dans lequel importer le fichier. Exemple : ragStores/my-rag-store-123 se présente sous la forme ragStores/{ragstore}.

Corps de la requête

Le corps de la requête contient des données présentant la structure suivante :

Champs
displayName string

Facultatif. Nom à afficher du document créé.

customMetadata[] object (CustomMetadata)

Métadonnées personnalisées à associer aux données.

chunkingConfig object (ChunkingConfig)

Facultatif. Configuration permettant d'indiquer au service comment segmenter les données. Si aucune valeur n'est fournie, le service utilisera les paramètres par défaut.

mimeType string

Facultatif. Type MIME des données. Si aucune valeur n'est fournie, elle sera déduite du contenu importé.

Corps de la réponse

Il s'agit d'une copie de google.longrunning.Operation. Nous devons le copier, car pour interagir avec Scotty, nous devons ajouter un champ spécifique à Scotty qui ne peut pas être ajouté dans le proto Operation de premier niveau.

Si la requête aboutit, le corps de la réponse contient des données qui ont la structure suivante :

Champs
name string

Nom attribué par le serveur. Unique au sein du service qui le renvoie initialement. Si vous utilisez le mappage HTTP par défaut, le champ name doit être un nom de ressource se terminant par operations/{unique_id}.

metadata object

Métadonnées spécifiques au service associées à l'opération. Ce champ contient généralement des informations de progression et des métadonnées courantes telles que la date de création. Certains services peuvent ne pas fournir ce genre de métadonnées. Toute méthode renvoyant une opération de longue durée doit indiquer le type de métadonnées, le cas échéant.

Objet contenant des champs d'un type arbitraire. Un champ supplémentaire "@type" contient un URI identifiant le type. Exemple : { "id": 1234, "@type": "types.example.com/standard/id" }.

done boolean

Si la valeur est false, cela signifie que l'opération est toujours en cours. Si elle est définie sur true, l'opération est terminée, et un message error ou response est disponible.

result Union type
Résultat de l'opération, qui peut être une erreur (message error) ou une réponse valide (message response). Si done == false, ni error, ni response ne sont définis. Si done == true, une seule des options error ou response peut être définie. Certains services peuvent ne pas fournir le résultat. result ne peut être qu'un des éléments suivants :
error object (Status)

Résultat d'erreur de l'opération en cas d'échec ou d'annulation.

response object

Réponse normale indiquant la réussite de l'opération. Si la méthode d'origine ne renvoie aucune donnée en cas de réussite (telle que Delete), la réponse est google.protobuf.Empty. Si la méthode d'origine est une méthode Get/Create/Update standard, la réponse doit correspondre à la ressource. Pour les autres méthodes, la réponse doit avoir le type XxxResponse, où Xxx est le nom de la méthode d'origine. Par exemple, si le nom de la méthode d'origine est TakeSnapshot(), le type de réponse déduit est TakeSnapshotResponse.

Objet contenant des champs d'un type arbitraire. Un champ supplémentaire "@type" contient un URI identifiant le type. Exemple : { "id": 1234, "@type": "types.example.com/standard/id" }.

Représentation JSON
{
  "name": string,
  "metadata": {
    "@type": string,
    field1: ...,
    ...
  },
  "done": boolean,

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

ChunkingConfig

Paramètres permettant d'indiquer au service comment segmenter le fichier. Inspiré de google3/cloud/ai/platform/extension/lib/retrieval/config/chunker_config.proto

Champs
config Union type
Configuration de segmentation à utiliser. config ne peut être qu'un des éléments suivants :
whiteSpaceConfig object (WhiteSpaceConfig)

Configuration de la segmentation des espaces blancs.

Représentation JSON
{

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

WhiteSpaceConfig

Configuration d'un algorithme de segmentation des espaces blancs [délimités par des espaces blancs].

Champs
maxTokensPerChunk integer

Nombre maximal de jetons par bloc. Les jetons sont définis comme des mots pour cet algorithme de segmentation. Remarque : Nous définissons les jetons comme des mots séparés par des espaces, et non comme le résultat d'un tokenizer. Au 17/04/2025, la fenêtre de contexte du dernier modèle d'embedding Gemini est actuellement de 8 192 jetons. Nous partons du principe qu'un mot moyen comporte cinq caractères. Nous avons donc défini la limite supérieure sur 2**9, soit 512 mots ou 2 560 jetons, en supposant le pire scénario (un caractère par jeton). Il s'agit d'une estimation prudente visant à éviter le dépassement de la fenêtre de contexte.

maxOverlapTokens integer

Nombre maximal de jetons se chevauchant entre deux blocs adjacents.

Représentation JSON
{
  "maxTokensPerChunk": integer,
  "maxOverlapTokens": integer
}

Méthode : files.get

Obtient les métadonnées pour le File donné.

Point de terminaison

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

Paramètres de chemin d'accès

name string

Obligatoire. Nom du File à obtenir. Exemple : files/abc-123 se présente sous la forme files/{file}.

Corps de la requête

Le corps de la requête doit être vide.

Exemple de requête

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)

Coquille Rose

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

Corps de la réponse

Si la requête aboutit, le corps de la réponse contient une instance de File.

Méthode : files.list

Liste les métadonnées des File appartenant au projet demandeur.

Point de terminaison

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

Paramètres de requête

pageSize integer

Facultatif. Nombre maximal de File à renvoyer par page. Si aucune valeur n'est spécifiée, la valeur par défaut est 10. La valeur maximale de pageSize est de 100.

pageToken string

Facultatif. Jeton de page reçu d'un appel files.list précédent.

Corps de la requête

Le corps de la requête doit être vide.

Exemple de requête

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)
}

Coquille Rose

echo "My files: "

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

Corps de la réponse

Réponse pour files.list.

Si la requête aboutit, le corps de la réponse contient des données qui ont la structure suivante :

Champs
files[] object (File)

Liste des File.

nextPageToken string

Jeton pouvant être envoyé en tant que pageToken dans un appel files.list ultérieur.

Représentation JSON
{
  "files": [
    {
      object (File)
    }
  ],
  "nextPageToken": string
}

Méthode : files.delete

Supprime le File.

Point de terminaison

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

Paramètres de chemin d'accès

name string

Obligatoire. Nom du File à supprimer. Exemple : files/abc-123 se présente sous la forme files/{file}.

Corps de la requête

Le corps de la requête doit être vide.

Exemple de requête

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")

Coquille Rose

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

Corps de la réponse

Si la requête aboutit, le corps de la réponse est un objet JSON vide.

Ressource REST : fichiers

Ressource : File

Fichier importé dans l'API. Identifiant suivant : 15

Champs
name string

Immuable. Identifiant. Nom de la ressource File. L'ID (nom sans le préfixe "files/") peut contenir jusqu'à 40 caractères alphanumériques en minuscule ou des tirets (-). Il ne peut pas commencer ni se terminer par un tiret. Si le nom est vide lors de la création, un nom unique est généré. Exemple : files/123-456

displayName string

Facultatif. Nom à afficher lisible pour File. Le nom à afficher ne doit pas comporter plus de 512 caractères, espaces compris. Exemple : "Image de bienvenue"

mimeType string

Uniquement en sortie. Type MIME du fichier.

sizeBytes string (int64 format)

Uniquement en sortie. Taille du fichier en octets.

createTime string (Timestamp format)

Uniquement en sortie. Code temporel de création de File.

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

updateTime string (Timestamp format)

Uniquement en sortie. Code temporel de la dernière mise à jour de File.

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

expirationTime string (Timestamp format)

Uniquement en sortie. Code temporel correspondant à la suppression de File. Défini uniquement si File doit expirer.

Utilise la norme RFC 3339, où la sortie générée utilise toujours le format UTC (indiqué par "Z" pour le temps universel coordonné) avec des secondes fractionnaires de 0, 3, 6 ou 9 chiffres décimaux. Des décalages horaires autres que "Z" (UTC) sont également acceptés. Exemples : "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" ou "2014-10-02T15:01:23+05:30".

sha256Hash string (bytes format)

Uniquement en sortie. Hachage SHA-256 des octets importés.

Chaîne encodée en base64.

uri string

Uniquement en sortie. URI du File.

downloadUri string

Uniquement en sortie. URI de téléchargement de File.

state enum (State)

Uniquement en sortie. État de traitement du fichier.

source enum (Source)

Source du fichier.

error object (Status)

Uniquement en sortie. État d'erreur si le traitement du fichier a échoué.

metadata Union type
Métadonnées du fichier. metadata ne peut être qu'un des éléments suivants :
videoMetadata object (VideoFileMetadata)

Uniquement en sortie. Métadonnées d'une vidéo.

Représentation 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

Métadonnées d'une vidéo File.

Champs
videoDuration string (Duration format)

Durée de la vidéo.

Durée en secondes avec neuf chiffres au maximum après la virgule et se terminant par "s". Exemple : "3.5s"

Représentation JSON
{
  "videoDuration": string
}

État

États du cycle de vie d'un fichier.

Enums
STATE_UNSPECIFIED Valeur par défaut. Cette valeur est utilisée si l'état est omis.
PROCESSING Le fichier est en cours de traitement et ne peut pas encore être utilisé pour l'inférence.
ACTIVE Le fichier est traité et disponible pour l'inférence.
FAILED Le traitement du fichier a échoué.

Source

Enums
SOURCE_UNSPECIFIED Utilisé si la source n'est pas spécifiée.
UPLOADED Indique que le fichier a été importé par l'utilisateur.
GENERATED Indique que le fichier est généré par Google.
REGISTERED Indique que le fichier est enregistré, c'est-à-dire qu'il s'agit d'un fichier Google Cloud Storage.

État

Le type Status définit un modèle d'erreur logique adapté aux différents environnements de programmation, y compris les API REST et RPC. Il est utilisé par le protocole gRPC. Chaque message Status contient trois éléments de données : un code d'erreur, un message d'erreur et les détails de l'erreur.

Pour en savoir plus sur ce modèle d'erreur et sur son utilisation, consultez le Guide de conception d'API.

Champs
code integer

Code d'état, qui doit être une valeur d'énumération de google.rpc.Code.

message string

Message d'erreur destiné au développeur, qui doit être en anglais. Tout message d'erreur destiné aux utilisateurs doit être localisé et envoyé dans le champ google.rpc.Status.details, ou localisé par le client.

details[] object

Liste de messages comportant les détails de l'erreur. Il existe un ensemble commun de types de message utilisable par les API.

Objet contenant des champs d'un type arbitraire. Un champ supplémentaire "@type" contient un URI identifiant le type. Exemple : { "id": 1234, "@type": "types.example.com/standard/id" }.

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