Inclure des fichiers volumineux dans des requêtes multimodales et gérer les fichiers à l'aide de Cloud Storage for Firebase

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Lorsque vous appelez Gemini API à partir de votre application à l'aide d'un SDK Vertex AI in Firebase, vous pouvez demander au modèle Gemini de générer du texte à partir d'une entrée multimodale. Les requêtes multimodales peuvent inclure plusieurs modalités (ou types d'entrée), comme du texte avec des images, des PDF, des vidéos et de l'audio.

Pour les parties non textuelles de l'entrée (comme les fichiers multimédias), vous pouvez éventuellement utiliser Cloud Storage for Firebase pour inclure des fichiers dans la requête. Voici quelques points à retenir sur cette fonctionnalité:

• Vous pouvez utiliser Cloud Storage for Firebase avec n'importe quelle requête multimodale (comme la génération de texte et le chat). Les exemples de ce guide montrent une entrée de texte et d'image de base.

• Vous spécifiez le type MIME du fichier et son URL Cloud Storage for Firebase (qui commence toujours par gs://) dans l'entrée de la requête. Ces valeurs sont des métadonnées automatiquement attribuées à tout fichier importé dans un bucket Cloud Storage.

• Vous devez utiliser un type de fichier et une URL compatibles.

Ce guide de solution explique comment configurer Cloud Storage for Firebase, importer un fichier dans un bucket Cloud Storage for Firebase à partir de votre application, puis inclure le type MIME et l'URL Cloud Storage for Firebase du fichier dans votre requête multimodale à l'Gemini API.

Voulez-vous voir les exemples de code ? Avez-vous déjà configuré Cloud Storage for Firebase et êtes-vous prêt à l'utiliser avec vos requêtes multimodales ?

Accéder aux exemples de code

Pourquoi utiliser Cloud Storage for Firebase avec votre application ?

Cloud Storage for Firebase utilise la même infrastructure rapide, sécurisée et évolutive que Google Cloud Storage pour stocker des blobs et des fichiers. Ses SDK clients sont spécifiquement conçus pour les applications mobiles et Web.

Pour les SDK Vertex AI in Firebase, la taille maximale de la requête est de 20 Mo. Vous recevez une erreur HTTP 413 si une requête est trop volumineuse. Si la taille d'un fichier fait que la taille totale de la requête dépasse 20 Mo, utilisez une URL Cloud Storage for Firebase pour inclure le fichier dans votre requête multimodale. Toutefois, si un fichier est de petite taille, vous pouvez souvent le transmettre directement en tant que données intégrées (notez toutefois qu'un fichier fourni en tant que données intégrées est encodé en base64 en transit, ce qui augmente la taille de la requête).

Voici quelques autres avantages de l'utilisation de Cloud Storage for Firebase:

• Vous pouvez demander aux utilisateurs finaux d'importer des images directement depuis votre application dans un bucket Cloud Storage for Firebase, puis d'inclure ces images dans vos requêtes multimodales simplement en spécifiant le type MIME du fichier et l'URL Cloud Storage for Firebase (qui est un identifiant du fichier).

• Vous pouvez faire gagner du temps et de la bande passante à vos utilisateurs finaux s'ils doivent fournir des images, en particulier s'ils ont une qualité réseau médiocre ou instable.

  • Si une importation ou un téléchargement de fichier est interrompu, les SDK Cloud Storage for Firebase redémarrent automatiquement l'opération là où elle s'est arrêtée.
  • Le même fichier importé peut être utilisé plusieurs fois sans que l'utilisateur final ait à importer le même fichier chaque fois qu'il est nécessaire dans votre application (comme dans une nouvelle requête multimodale).

• Vous pouvez limiter l'accès des utilisateurs finaux aux fichiers stockés dans Cloud Storage for Firebase à l'aide de Firebase Security Rules, qui ne permet qu'à un utilisateur autorisé d'importer, de télécharger ou de supprimer des fichiers.

• Vous pouvez accéder aux fichiers de votre bucket depuis Firebase ou depuis Google Cloud. Vous pouvez ainsi effectuer des traitements côté serveur, tels que le filtrage d'images ou le transcodage de vidéos à l'aide des API Google Cloud Storage.

Quels types de fichiers et d'URL sont acceptés ?

Voici les exigences concernant les fichiers et les URL lorsque vous souhaitez utiliser des URL Cloud Storage for Firebase avec les SDK Vertex AI in Firebase:

• Le fichier doit respecter les exigences des fichiers d'entrée pour les requêtes multimodales lorsque vous utilisez les SDK Vertex AI in Firebase. Cela inclut des exigences telles que le type MIME et la taille de fichier.

• Le fichier doit être stocké dans un bucket Cloud Storage for Firebase (ce qui signifie que le bucket est accessible aux services Firebase, comme Firebase Security Rules). Si vous pouvez afficher votre bucket dans la console Firebase, il s'agit d'un bucket Cloud Storage for Firebase.

• Le bucket Cloud Storage for Firebase doit se trouver dans le même projet Firebase que celui dans lequel vous avez enregistré votre application.

• L'URL Cloud Storage for Firebase du fichier doit commencer par gs://, ce qui est la façon dont toutes les URL Google Cloud Storage sont construites.

• L'URL du fichier ne peut pas être une URL de "navigateur" (par exemple, l'URL d'une image que vous trouvez sur Internet).

De plus, l'Firebase Security Rules de votre bucket doit autoriser un accès approprié au fichier. Exemple :

• Si vous avez des règles publiques, n'importe quel utilisateur ou client peut accéder au fichier et fournir son URL dans un appel à l'aide d'un SDK Vertex AI in Firebase. Ces types de règles ne doivent être utilisés que pour commencer et lors du prototypage initial (sauf si les fichiers sont destinés à être entièrement accessibles au public).

• Si vous disposez de règles robustes (recommandées vivement), Firebase vérifie que l'utilisateur ou le client connecté dispose d'un accès suffisant au fichier avant d'autoriser l'appel à passer avec l'URL fournie.

Utiliser des URL Cloud Storage for Firebase avec Vertex AI in Firebase

Étape 1: Configurer Cloud Storage for Firebase

Vous trouverez des instructions détaillées sur la configuration de Cloud Storage for Firebase dans son guide de démarrage : iOS+ | Android | Web | Flutter

Voici les tâches générales que vous devrez effectuer:

1. Créez ou importez un bucket Cloud Storage for Firebase dans votre projet Firebase.

2. Appliquez Firebase Security Rules à ce bucket. Rules vous aide à sécuriser vos fichiers en limitant l'accès aux utilisateurs finaux autorisés.

3. Ajoutez la bibliothèque cliente pour Cloud Storage for Firebase à votre application.

   Notez que vous pouvez ignorer cette tâche, mais vous devez alors toujours inclure explicitement le type MIME et les valeurs d'URL dans vos requêtes.

Étape 2: Importez un fichier dans un bucket

Dans la documentation Cloud Storage, vous pouvez découvrir toutes les différentes façons d'importer des fichiers dans un bucket. Par exemple, vous pouvez importer des fichiers locaux à partir de l'appareil de l'utilisateur final, tels que des photos et des vidéos de l'appareil photo. En savoir plus : iOS+ | Android | Web | Flutter

Lorsque vous importez un fichier dans un bucket, Cloud Storage applique automatiquement les deux informations suivantes au fichier. Vous devrez inclure ces valeurs dans la requête (comme indiqué à l'étape suivante de ce guide).

• Type MIME: il s'agit du type de média du fichier (par exemple, image/png). Nous tenterons automatiquement de détecter le type MIME lors de l'importation et d'appliquer ces métadonnées à l'objet du bucket. Toutefois, vous pouvez éventuellement spécifier le type MIME lors de l'importation.

• URL Cloud Storage for Firebase: identifiant unique du fichier. L'URL doit commencer par gs://.

Étape 3: Incluez le type MIME et l'URL du fichier dans une requête multimodale

Une fois un fichier stocké dans un bucket, vous pouvez inclure son type MIME et son URL dans une requête. Notez que ces exemples montrent une requête generateContent sans streaming, mais vous pouvez également utiliser des URL avec streaming et chat.

Pour inclure le fichier dans la requête, vous pouvez utiliser l'une des options suivantes:

• Option 1:Inclure le type MIME et l'URL à l'aide d'une référence Storage

• Option 2:Inclure explicitement le type MIME et l'URL

Option 1: Inclure le type MIME et l'URL à l'aide d'une référence Storage

Utilisez cette option si vous venez d'importer le fichier dans le bucket et que vous souhaitez l'inclure immédiatement (via une référence Storage) dans la requête. L'appel nécessite à la fois le type MIME et l'URL Cloud Storage for Firebase.

// Upload an image file using Cloud Storage for Firebase.
let storageRef = Storage.storage().reference(withPath: "images/image.jpg")
guard let imageURL = Bundle.main.url(forResource: "image", withExtension: "jpg") else {
  fatalError("File 'image.jpg' not found in main bundle.")
}
let metadata = try await storageRef.putFileAsync(from: imageURL)

// Get the MIME type and Cloud Storage for Firebase URL.
guard let mimeType = metadata.contentType else {
  fatalError("The MIME type of the uploaded image is nil.")
}
// Construct a URL in the required format.
let storageURL = "gs://\(storageRef.bucket)/\(storageRef.fullPath)"

let prompt = "What's in this picture?"
// Construct the imagePart with the MIME type and the URL.
let imagePart = FileDataPart(uri: storageURL, mimeType: mimeType)

// To generate text output, call generateContent with the prompt and the imagePart.
let result = try await model.generateContent(prompt, imagePart)
if let text = result.text {
  print(text)
}

// Upload an image file using Cloud Storage for Firebase.
val storageRef = Firebase.storage.reference.child("images/image.jpg")
val fileUri = Uri.fromFile(File("image.jpg"))
try {
    val taskSnapshot = storageRef.putFile(fileUri).await()
    // Get the MIME type and Cloud Storage for Firebase file path.
    val mimeType = taskSnapshot.metadata?.contentType
    val bucket = taskSnapshot.metadata?.bucket
    val filePath = taskSnapshot.metadata?.path

    if (mimeType != null && bucket != null) {
        // Construct a URL in the required format.
        val storageUrl = "gs://$bucket/$filePath"
        // Construct a prompt that includes text, the MIME type, and the URL.
        val prompt = content {
            fileData(mimeType = mimeType, uri = storageUrl)
            text("What's in this picture?")
        }
        // To generate text output, call generateContent with the prompt.
        val response = generativeModel.generateContent(prompt)
        println(response.text)
    }
} catch (e: StorageException) {
    // An error occurred while uploading the file.
} catch (e: GoogleGenerativeAIException) {
    // An error occurred while generating text.
}

// Upload an image file using Cloud Storage for Firebase.
StorageReference storage = FirebaseStorage.getInstance().getReference("images/image.jpg");
Uri fileUri = Uri.fromFile(new File("images/image.jpg"));

storage.putFile(fileUri).addOnSuccessListener(taskSnapshot -> {
    // Get the MIME type and Cloud Storage for Firebase file path.
    String mimeType = taskSnapshot.getMetadata().getContentType();
    String bucket = taskSnapshot.getMetadata().getBucket();
    String filePath = taskSnapshot.getMetadata().getPath();

    if (mimeType != null && bucket != null) {
        // Construct a URL in the required format.
        String storageUrl = "gs://" + bucket + "/" + filePath;
        // Create a prompt that includes text, the MIME type, and the URL.
        Content prompt = new Content.Builder()
                .addFileData(storageUrl, mimeType)
                .addText("What's in this picture?")
                .build();

        // To generate text output, call generateContent with the prompt.
        GenerativeModelFutures modelFutures = GenerativeModelFutures.from(model);
        ListenableFuture<GenerateContentResponse> response = modelFutures.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String resultText = result.getText();
                System.out.println(resultText);
            }

            @Override
            public void onFailure(@NonNull Throwable t) {
                t.printStackTrace();
            }
        }, executor);
    }
}).addOnFailureListener(e -> {
    // An error occurred while uploading the file.
    e.printStackTrace();
});

// Upload an image file using Cloud Storage for Firebase.
const storageRef = ref(storage, "image.jpg");
const uploadResult = await uploadBytes(storageRef, file);

// Get the MIME type and Cloud Storage for Firebase URL.
// toString() is the simplest way to construct the Cloud Storage for Firebase URL
// in the required format.
const mimeType = uploadResult.metadata.contentType;
const storageUrl = uploadResult.ref.toString();

// Construct the imagePart with the MIME type and the URL.
const imagePart = { fileData: { mimeType, fileUri: storageUrl }};

// To generate text output, call generateContent with the prompt and imagePart.
const result = await model.generateContent([prompt, imagePart]);
console.log(result.response.text());

// Upload an image file using Cloud Storage for Firebase.
final storageRef = FirebaseStorage.instance.ref();
final imageRef = storageRef.child("images/image.jpg");
await imageRef.putData(data);

// Get the MIME type and Cloud Storage for Firebase file path.
final metadata = await imageRef.getMetadata();
final mimeType = metadata.contentType;
final bucket = imageRef.bucket;
final fullPath = imageRef.fullPath;

final prompt = TextPart("What's in the picture?");
// Construct a URL in the required format.
final storageUrl = 'gs://$bucket/$fullPath';
// Construct the filePart with the MIME type and the URL.
final filePart = FileData(mimeType, storageUrl);
// To generate text output, call generateContent with the text and the filePart.
final response = await model.generateContent([
  Content.multi([prompt, filePart])
]);
print(response.text);

Option 2: Inclure explicitement le type MIME et l'URL

Utilisez cette option si vous connaissez les valeurs du type MIME et de l'URL Cloud Storage for Firebase, et si vous souhaitez les inclure explicitement dans la requête multimodale. L'appel nécessite à la fois le type MIME et l'URL.

let prompt = "What's in this picture?"
// Construct an imagePart that explicitly includes the MIME type and
// Cloud Storage for Firebase URL values.
let imagePart = FileDataPart(uri: "gs://bucket-name/path/image.jpg", mimeType: "image/jpeg")

// To generate text output, call generateContent with the prompt and imagePart.
let result = try await model.generateContent(prompt, imagePart)
if let text = result.text {
  print(text)
}

// Construct a prompt that explicitly includes the MIME type and Cloud Storage for Firebase URL values.
val prompt = content {
    fileData(mimeType = "image/jpeg", uri = "gs://bucket-name/path/image.jpg")
    text("What's in this picture?")
}
// To generate text output, call generateContent with the prompt.
val response = generativeModel.generateContent(prompt)
println(response.text)

// Construct a prompt that explicitly includes the MIME type and Cloud Storage for Firebase URL values.
Content prompt = new Content.Builder()
        .addFilePart("gs://bucket-name/path/image.jpg", "image/jpeg")
        .addText("What's in this picture?")
        .build();

// To generate text output, call generateContent with the prompt
GenerativeModelFutures modelFutures = GenerativeModelFutures.from(model);
ListenableFuture<GenerateContentResponse> response = modelFutures.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(@NonNull Throwable t) {
        t.printStackTrace();
    }
}, executor);

const prompt = "What's in this picture?";
// Construct an imagePart that explicitly includes the MIME type and Cloud Storage for Firebase URL values.
const imagePart = { fileData: { mimeType: "image/jpeg", fileUri: "gs://bucket-name/path/image.jpg" }};

// To generate text output, call generateContent with the prompt and imagePart.
const result = await model.generateContent([prompt, imagePart]);
console.log(result.response.text());

final prompt = TextPart("What's in the picture?");
// Construct a filePart that explicitly includes the MIME type and Cloud Storage for Firebase URL values.
final filePart = FileData('image/jpeg', 'gs://bucket-name/path/image.jpg'),
// To generate text output, call generateContent with the prompt and filePart.
final response = await model.generateContent([
  Content.multi([prompt, filePart])
]);
print(response.text);