Firebase is back at Google I/O on May 20-21! Register now.

Cette page a été traduite par l'API Cloud Translation.

Analyser des fichiers image à l'aide de l'API Gemini
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

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

Grâce à cette fonctionnalité, vous pouvez effectuer les actions suivantes:

Créer des légendes ou répondre à des questions sur des images
Écrire une nouvelle ou un poème à partir d'une image
Détecter des objets dans une image et renvoyer leurs coordonnées de cadre de délimitation
Étiqueter ou catégoriser un ensemble d'images en fonction de l'opinion, du style ou d'autres caractéristiques

Accéder aux exemples de code Accéder au code pour les réponses en flux

Consultez d'autres guides pour découvrir d'autres options de travail avec les images
Générer une sortie structurée Chat multitour Générer des images

Avant de commencer

Si ce n'est pas déjà fait, consultez le guide de démarrage, qui explique comment configurer votre projet Firebase, connecter votre application à Firebase, ajouter le SDK, initialiser le service Vertex AI et créer une instance GenerativeModel.

Pour tester et itérer vos requêtes, et même obtenir un extrait de code généré, nous vous recommandons d'utiliser Vertex AI Studio.

Avez-vous besoin d'un exemple de fichier image ?

Vous pouvez utiliser ce fichier accessible au public avec un type MIME de image/jpeg (afficher ou télécharger le fichier). https://storage.googleapis.com/cloud-samples-data/generative-ai/image/scones.jpg

Envoyer des fichiers image (encodés en base64) et recevoir du texte

Assurez-vous d'avoir terminé la section Avant de commencer de ce guide avant d'essayer cet exemple.

Vous pouvez demander à un modèle Gemini de générer du texte en lui fournissant du texte et des images, en fournissant le mimeType de chaque fichier d'entrée et le fichier lui-même. Vous trouverez les exigences et 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 d'un seul fichier

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Create a `GenerativeModel` instance with a model that supports your use case
let model = vertex.generativeModel(modelName: "gemini-2.0-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.")

Saisie de plusieurs fichiers

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Create a `GenerativeModel` instance with a model that supports your use case
let model = vertex.generativeModel(modelName: "gemini-2.0-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.")

Remarque: L'exemple ci-dessus utilise une méthode simplifiée pour gérer les types d'images natifs de la plate-forme (UIImage, NSImage, CIImage et CGImage) dans les requêtes multimodales. Ces types d'images (quel que soit leur format d'origine) sont convertis côté client au format JPEG avec une qualité de 80% avant d'être envoyés au serveur. Cela signifie que lorsque vous fournissez des images intégrées comme dans l'exemple ci-dessus, vous n'avez pas besoin de spécifier le type MIME.

Pour mieux contrôler les formats et les conversions d'images, vous pouvez fournir les images en tant que InlineDataPart et indiquer le type MIME spécifique. Par exemple : InlineDataPart(data: Data(/* PNG Data */), mimeType: "image/png").

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'un champ d'application de coroutine.}

Entrée d'un seul fichier

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-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 = generativeModel.generateContent(prompt)
print(response.text)

Saisie de plusieurs fichiers

^{Pour Kotlin, les méthodes de ce SDK sont des fonctions de suspension et doivent être appelées à partir d'un champ d'application de coroutine.}

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-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 = generativeModel.generateContent(prompt)
print(response.text)

Remarque: L'exemple ci-dessus exploite une méthode simplifiée pour gérer les types d'images natifs de la plate-forme (Bitmap) dans les requêtes multimodales. Ces types d'images (quel que soit leur format d'origine) sont convertis côté client au format JPEG avec une qualité de 80% avant d'être envoyés au serveur. Cela signifie que lorsque vous fournissez des images intégrées comme dans l'exemple ci-dessus, vous n'avez pas besoin de spécifier le type MIME.

Pour mieux contrôler les formats et les conversions d'images, vous pouvez fournir les images en tant que InlineDataPart et indiquer le type MIME spécifique. Par exemple : content { inlineData(/* PNG as byte array */, "image/png") }.

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 d'un seul fichier

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-2.0-flash");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

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

Saisie de plusieurs fichiers

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-2.0-flash");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

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 d'un seul fichier

import { initializeApp } from "firebase/app";
import { getVertexAI, getGenerativeModel } from "firebase/vertexai";

// 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 Vertex AI service
const vertexAI = getVertexAI(firebaseApp);

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(vertexAI, { model: "gemini-2.0-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's different between these pictures?";

  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();

Saisie de plusieurs fichiers

import { initializeApp } from "firebase/app";
import { getVertexAI, getGenerativeModel } from "firebase/vertexai";

// 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 Vertex AI service
const vertexAI = getVertexAI(firebaseApp);

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(vertexAI, { model: "gemini-2.0-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 d'un seul fichier

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

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

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
final model =
      FirebaseVertexAI.instance.generativeModel(model: 'gemini-2.0-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);

Saisie de plusieurs fichiers

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

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

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
final model =
      FirebaseVertexAI.instance.generativeModel(model: 'gemini-2.0-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);

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

Afficher la réponse de manière progressive

Assurez-vous d'avoir terminé la section Avant de commencer de ce guide avant d'essayer cet exemple.

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 le streaming pour gérer les résultats partiels. Pour diffuser la réponse, appelez generateContentStream.

Voir un exemple: diffuser du texte généré à partir de fichiers image

Swift

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

Entrée d'un seul fichier

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Create a `GenerativeModel` instance with a model that supports your use case
let model = vertex.generativeModel(modelName: "gemini-2.0-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 stream generated text output, call generateContentStream and pass in the prompt
let contentStream = try model.generateContentStream(image, prompt)
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
  }
}

Saisie de plusieurs fichiers

import FirebaseVertexAI

// Initialize the Vertex AI service
let vertex = VertexAI.vertexAI()

// Create a `GenerativeModel` instance with a model that supports your use case
let model = vertex.generativeModel(modelName: "gemini-2.0-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 stream generated text output, call generateContentStream and pass in the prompt
let contentStream = try model.generateContentStream(image1, image2, prompt)
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
  }
}

Kotlin

Vous pouvez appeler generateContentStream() pour diffuser du texte généré à 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'un champ d'application de coroutine.}

Entrée d'un seul fichier

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-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 stream generated text output, call generateContentStream with the prompt
var fullResponse = ""
generativeModel.generateContentStream(prompt).collect { chunk ->
  print(chunk.text)
  fullResponse += chunk.text
}

Saisie de plusieurs fichiers

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
val generativeModel = Firebase.vertexAI.generativeModel("gemini-2.0-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's different between these pictures?")
}

// To stream generated text output, call generateContentStream with the prompt
var fullResponse = ""
generativeModel.generateContentStream(prompt).collect { chunk ->
  print(chunk.text)
  fullResponse += chunk.text
}

Java

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

^{Pour Java, les méthodes de streaming de ce SDK renvoient un type Publisher de la bibliothèque Reactive Streams.}

Entrée d'un seul fichier

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-2.0-flash");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

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

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

// To stream generated text output, call generateContentStream with the prompt
Publisher<GenerateContentResponse> streamingResponse = model.generateContentStream(prompt);

final String[] fullResponse = {""};

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        fullResponse[0] += chunk;
    }

    @Override
    public void onComplete() {
        System.out.println(fullResponse[0]);
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onSubscribe(Subscription s) {
    }
});

Saisie de plusieurs fichiers

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
GenerativeModel gm = FirebaseVertexAI.getInstance()
        .generativeModel("gemini-2.0-flash");
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

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 stream generated text output, call generateContentStream with the prompt
Publisher<GenerateContentResponse> streamingResponse = model.generateContentStream(prompt);

final String[] fullResponse = {""};

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        fullResponse[0] += chunk;
    }

    @Override
    public void onComplete() {
        System.out.println(fullResponse[0]);
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onSubscribe(Subscription s) {
    }
});

Web

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

Entrée d'un seul fichier

import { initializeApp } from "firebase/app";
import { getVertexAI, getGenerativeModel } from "firebase/vertexai";

// 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 Vertex AI service
const vertexAI = getVertexAI(firebaseApp);

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(vertexAI, { model: "gemini-2.0-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?";

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

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

  for await (const chunk of result.stream) {
    const chunkText = chunk.text();
    console.log(chunkText);
  }
}

run();

Saisie de plusieurs fichiers

import { initializeApp } from "firebase/app";
import { getVertexAI, getGenerativeModel } from "firebase/vertexai";

// 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 Vertex AI service
const vertexAI = getVertexAI(firebaseApp);

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(vertexAI, { model: "gemini-2.0-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?";

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

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

  for await (const chunk of result.stream) {
    const chunkText = chunk.text();
    console.log(chunkText);
  }
}

run();

Dart

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

Entrée d'un seul fichier

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

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

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
final model =
      FirebaseVertexAI.instance.generativeModel(model: 'gemini-2.0-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 stream generated text output, call generateContentStream with the text and image
final response = await model.generateContentStream([
  Content.multi([prompt,imagePart])
]);
await for (final chunk in response) {
  print(chunk.text);
}

Saisie de plusieurs fichiers

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

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

// Initialize the Vertex AI service and create a `GenerativeModel` instance
// Specify a model that supports your use case
final model =
      FirebaseVertexAI.instance.generativeModel(model: 'gemini-2.0-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 stream generated text output, call generateContentStream with the text and images
final response = await model.generateContentStream([
  Content.multi([prompt, ...imageParts])
]);
await for (final chunk in response) {
  print(chunk.text);
}

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

Consultez la section "Fichiers d'entrée compatibles et exigences pour Vertex AI Gemini API" pour en savoir plus sur les éléments suivants:

Différentes options pour fournir un fichier dans une requête (en ligne ou à l'aide de l'URL ou de l'URI du fichier)
Exigences et bonnes pratiques concernant les fichiers image

Types MIME d'image compatibles

Les modèles multimodaux Gemini sont compatibles avec les types MIME d'image suivants:

Type MIME de l'image	Gemini 2.0 Flash	Gemini 2.0 Flash‑Lite
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.

Voici le nombre maximal de fichiers image autorisé dans une requête:

Gemini 2.0 Flash et Gemini 2.0 Flash‑Lite: 3 000 images

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 pour pouvoir inclure des fichiers volumineux dans vos requêtes multimodales et disposer d'une solution plus gérée pour fournir des fichiers dans les requêtes. Il peut s'agir d'images, de PDF, de vidéos et de fichiers audio.
Commencez à penser à la préparation de la production, y compris à la configuration de Firebase App Check pour protéger Gemini API contre les utilisations abusives par des clients non autorisés. Veillez également à consulter la checklist de production.

Essayer d'autres fonctionnalités

Créez des conversations multitours (chat).
Générez du texte à partir de requêtes textuelles uniquement.
Générez une sortie structurée (comme JSON) à partir d'invites textuelles et multimodales.
Générez des images à partir de requêtes textuelles.
Utilisez l'appel de fonction pour connecter des modèles génératifs à des systèmes et des informations externes.

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

Comprendre la conception des requêtes, y compris les bonnes pratiques, les stratégies et les exemples de requêtes.
Configurez les paramètres du modèle, comme la température et le nombre maximal de jetons de sortie (pour Gemini) ou le format et la génération de personnes (pour Imagen).
Utilisez les paramètres de sécurité pour ajuster la probabilité d'obtenir des réponses pouvant être considérées comme dangereuses.

Vous pouvez également tester des requêtes et des configurations de modèle à l'aide de Vertex 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 leurs tarifs.

Envoyer des commentaires sur votre expérience avec Vertex AI in Firebase

Analyser des fichiers image à l'aide de l'API Gemini Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Envoyer des fichiers image (encodés en base64) et recevoir du texte

Swift

Entrée d'un seul fichier

Saisie de plusieurs fichiers

Kotlin

Entrée d'un seul fichier

Saisie de plusieurs fichiers

Java

Entrée d'un seul fichier

Saisie de plusieurs fichiers

Web

Entrée d'un seul fichier

Saisie de plusieurs fichiers

Dart

Entrée d'un seul fichier

Saisie de plusieurs fichiers

Afficher la réponse de manière progressive

Voir un exemple: diffuser du texte généré à partir de fichiers image

Swift

Entrée d'un seul fichier

Saisie de plusieurs fichiers

Kotlin

Entrée d'un seul fichier

Saisie de plusieurs fichiers

Java

Entrée d'un seul fichier

Saisie de plusieurs fichiers

Web

Entrée d'un seul fichier

Saisie de plusieurs fichiers

Dart

Entrée d'un seul fichier

Saisie de plusieurs fichiers

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

Types MIME d'image compatibles

Limites par requête

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

Essayer d'autres fonctionnalités

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

En savoir plus sur les modèles compatibles

Analyser des fichiers image à l'aide de l'API Gemini
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.