Analyser des fichiers image à l'aide de l'API Gemini

Vous pouvez demander à un Gemini modèle d'analyser les fichiers image que vous fournissez de manière intégrée (encodés en base64) ou via une URL. Lorsque vous utilisez Firebase AI Logic, vous pouvez effectuer cette requête directement depuis votre application.

Cette fonctionnalité vous permet d'effectuer les opérations suivantes :

  • Créer des légendes ou répondre à des questions sur des images
  • Écrire une nouvelle ou un poème sur une image
  • Détecter des objets dans une image et renvoyer les coordonnées de leur cadre de délimitation
  • Libeller ou classer un ensemble d'images en fonction de leur sentiment, de leur style ou d'une autre caractéristique

Ce guide explique comment générer du texte à partir d'une entrée image, mais vous pouvez également générer des images à partir d'une entrée image.

Accéder aux exemples de code

Accéder au code pour les réponses diffusées


Consultez d'autres guides pour découvrir d'autres options permettant d'utiliser des images
Générer une sortie structurée Chat en plusieurs tours Analyser des images sur l'appareil Générer des images

Avant de commencer

Cliquez sur votre fournisseur Gemini API pour afficher le contenu spécifique au fournisseur et le code sur cette page.

Si ce n'est pas déjà fait, suivez le guide de démarrage, qui explique comment configurer votre projet Firebase, connecter votre application à Firebase, ajouter le SDK, initialiser le service de backend pour le fournisseur Gemini API de votre choix et créer une instance GenerativeModel.

Pour tester et effectuer des itérations de vos requêtes, nous vous recommandons d'utiliser Google AI Studio.

Modèles compatibles avec cette fonctionnalité

Ce guide explique comment générer du texte à partir d'une entrée image. Il s'applique aux modèles Gemini suivants :

  • gemini-3.1-pro-preview
  • gemini-3.6-flash (et l'ancien gemini-3.5-flash)
  • gemini-3.5-flash-lite (et l'ancien gemini-3.1-flash-lite)
  • gemini-2.5-pro
  • gemini-2.5-flash
  • gemini-2.5-flash-lite

Générer du texte à partir de fichiers image (encodés en base64)

Avant d'essayer cet exemple, suivez les étapes de la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique au fournisseur sur cette page.

Vous pouvez demander à un Gemini modèle de générer du texte en utilisant du texte et des images comme requêtes, en fournissant le fichier d'entrée mimeType et le fichier lui-même. Vous trouverez les exigences et les recommandations concernant les fichiers d'entrée plus loin sur cette page.

Swift

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée multimodale de texte et d'images.

Entrée de fichier unique 


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case.
let model = ai.generativeModel(modelName: "gemini-3.6-flash")


guard let image = UIImage(systemName: "bicycle") else { fatalError() }

// Provide a text prompt to include with the image
let prompt = "What's in this picture?"

// To generate text output, call generateContent and pass in the prompt
let response = try await model.generateContent(image, prompt)
print(response.text ?? "No text in response.")

Entrée de plusieurs fichiers


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case.
let model = ai.generativeModel(modelName: "gemini-3.6-flash")


guard let image1 = UIImage(systemName: "car") else { fatalError() }
guard let image2 = UIImage(systemName: "car.2") else { fatalError() }

// Provide a text prompt to include with the images
let prompt = "What's different between these pictures?"

// To generate text output, call generateContent and pass in the prompt
let response = try await model.generateContent(image1, image2, prompt)
print(response.text ?? "No text in response.")

Kotlin

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée multimodale de texte et d'images.

Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'une portée de coroutine.

Entrée de fichier unique 


// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-3.6-flash")


// Loads an image from the app/res/drawable/ directory
val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)

// Provide a prompt that includes the image specified above and text
val prompt = content {
  image(bitmap)
  text("What developer tool is this mascot from?")
}

// To generate text output, call generateContent with the prompt
val response = model.generateContent(prompt)
print(response.text)

Entrée de plusieurs fichiers

Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'une portée de coroutine. 

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-3.6-flash")


// Loads an image from the app/res/drawable/ directory
val bitmap1: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)
val bitmap2: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky_eats_pizza)

// Provide a prompt that includes the images specified above and text
val prompt = content {
  image(bitmap1)
  image(bitmap2)
  text("What is different between these pictures?")
}

// To generate text output, call generateContent with the prompt
val response = model.generateContent(prompt)
print(response.text)

Java

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée multimodale de texte et d'images.

Pour Java, les méthodes de ce SDK renvoient un ListenableFuture.

Entrée de fichier unique 


// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.6-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);

// Provide a prompt that includes the image specified above and text
Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .build();

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

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

Entrée de plusieurs fichiers


// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.6-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


Bitmap bitmap1 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);
Bitmap bitmap2 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky_eats_pizza);

// Provide a prompt that includes the images specified above and text
Content prompt = new Content.Builder()
    .addImage(bitmap1)
    .addImage(bitmap2)
    .addText("What's different between these pictures?")
    .build();

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

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

Web

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée multimodale de texte et d'images.

Entrée de fichier unique 


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case.
const model = getGenerativeModel(ai, { model: "gemini-3.6-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the image
  const prompt = "What do you see?";

  const fileInputEl = document.querySelector("input[type=file]");
  const imagePart = await fileToGenerativePart(fileInputEl.files[0]);

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

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Entrée de plusieurs fichiers


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case.
const model = getGenerativeModel(ai, { model: "gemini-3.6-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the images
  const prompt = "What's different between these pictures?";

  // Prepare images for input
  const fileInputEl = document.querySelector("input[type=file]");
  const imageParts = await Promise.all(
    [...fileInputEl.files].map(fileToGenerativePart)
  );

  // To generate text output, call generateContent with the text and images
  const result = await model.generateContent([prompt, ...imageParts]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart

Vous pouvez appeler generateContent() pour générer du texte à partir d'une entrée multimodale de texte et d'images.

Entrée de fichier unique 


import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-3.6-flash');


// Provide a text prompt to include with the image
final prompt = TextPart("What's in the picture?");
// Prepare images for input
final image = await File('image0.jpg').readAsBytes();
final imagePart = InlineDataPart('image/jpeg', image);

// To generate text output, call generateContent with the text and image
final response = await model.generateContent([
  Content.multi([prompt,imagePart])
]);
print(response.text);

Entrée de plusieurs fichiers


import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports your use case.
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-3.6-flash');


final (firstImage, secondImage) = await (
  File('image0.jpg').readAsBytes(),
  File('image1.jpg').readAsBytes()
).wait;
// Provide a text prompt to include with the images
final prompt = TextPart("What's different between these pictures?");
// Prepare images for input
final imageParts = [
  InlineDataPart('image/jpeg', firstImage),
  InlineDataPart('image/jpeg', secondImage),
];

// To generate text output, call generateContent with the text and images
final response = await model.generateContent([
  Content.multi([prompt, ...imageParts])
]);
print(response.text);

Unity

Vous pouvez appeler GenerateContentAsync() pour générer du texte à partir d’une entrée multimodale de texte et d’images.

Entrée de fichier unique 


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case.
var model = ai.GetGenerativeModel(modelName: "gemini-3.6-flash");


// Convert a Texture2D into InlineDataParts
var grayImage = ModelContent.InlineData("image/png",
      UnityEngine.ImageConversion.EncodeToPNG(UnityEngine.Texture2D.grayTexture));

// Provide a text prompt to include with the image
var prompt = ModelContent.Text("What's in this picture?");

// To generate text output, call GenerateContentAsync and pass in the prompt
var response = await model.GenerateContentAsync(new [] { grayImage, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Entrée de plusieurs fichiers


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case.
var model = ai.GetGenerativeModel(modelName: "gemini-3.6-flash");


// Convert Texture2Ds into InlineDataParts
var blackImage = ModelContent.InlineData("image/png",
      UnityEngine.ImageConversion.EncodeToPNG(UnityEngine.Texture2D.blackTexture));
var whiteImage = ModelContent.InlineData("image/png",
      UnityEngine.ImageConversion.EncodeToPNG(UnityEngine.Texture2D.whiteTexture));

// Provide a text prompt to include with the images
var prompt = ModelContent.Text("What's different between these pictures?");

// To generate text output, call GenerateContentAsync and pass in the prompt
var response = await model.GenerateContentAsync(new [] { blackImage, whiteImage, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Découvrez comment choisir un modèle adapté à votre cas d'utilisation et à votre application.

Diffuser la réponse

Avant d'essayer cet exemple, suivez les étapes de la section Avant de commencer de ce guide pour configurer votre projet et votre application.
Dans cette section, vous cliquerez également sur un bouton pour le fournisseur Gemini API de votre choix afin d'afficher le contenu spécifique au fournisseur sur cette page.

Vous pouvez accélérer les interactions en n'attendant pas le résultat complet de la génération du modèle et en utilisant plutôt la diffusion en flux continu pour gérer les résultats partiels. Pour diffuser la réponse, appelez generateContentStream.


Exigences et recommandations concernant les fichiers image d'entrée

Notez 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. Une erreur HTTP 413 s'affiche si une requête est trop volumineuse.

Consultez la page "Fichiers d'entrée et exigences compatibles" pour en savoir plus sur les éléments suivants :

Types MIME d'image compatibles

Gemini modèles multimodaux sont compatibles avec les types vidéo MIME suivants :

  • PNG - image/png
  • JPEG - image/jpeg
  • WebP - image/webp

Limites par requête

Il n'y a pas de limite spécifique au nombre de pixels dans une image. Cependant, les images plus volumineuses sont réduites et remplies pour correspondre à une résolution maximale de 3072 x 3072, tout en préservant leur format d'origine.

Nombre maximal de fichiers par requête : 3 000 fichiers image


Qu'est-ce que tu sais faire d'autre ?

  • Découvrez comment compter les jetons avant d'envoyer des requêtes longues au modèle.
  • Configurez Cloud Storage for Firebase afin de pouvoir inclure des fichiers volumineux dans vos requêtes multimodales et de disposer d'une solution plus gérée pour fournir des fichiers dans les requêtes. Les fichiers peuvent inclure des images, des PDF, des vidéos et des fichiers audio.
  • Commencez à réfléchir à la préparation de la production (consultez la checklist de production) :
    • Configurez Firebase App Check dès que possible pour protéger la Gemini API contre les utilisations abusives par des clients non autorisés.
    • Intégrez Firebase Remote Config pour mettre à jour les valeurs de votre application (comme le nom du modèle) sans publier de nouvelle version de l'application.

Essayer d'autres fonctionnalités

Découvrez comment contrôler la génération de contenu

Vous pouvez également tester des requêtes et des configurations de modèle, et même obtenir un extrait de code généré à l'aide de Google AI Studio.

En savoir plus sur les modèles compatibles

Découvrez les modèles disponibles pour différents cas d'utilisation ainsi que leurs quotas et tarifs.


Envoyer des commentaires sur votre expérience avec Firebase AI Logic