Générer des images avec Gemini

Gemini 2.5 Flash Image permet de générer des réponses dans plusieurs modalités, y compris du texte et des images.

Génération d'images

Gemini 2.5 Flash Image (gemini-2.5-flash-image) permet de générer des images en plus du texte. Les capacités de Gemini sont ainsi étendues pour inclure les éléments suivants :

  • Générez des images de manière itérative en conversant en langage naturel, et ajustez-les tout en conservant la cohérence et le contexte.
  • Générez des images avec un rendu de texte long de haute qualité.
  • Générez du texte et des images entrelacés. Par exemple, un article de blog avec du texte et des images en un seul tour. Auparavant, cela nécessitait d'enchaîner plusieurs modèles.
  • Générez des images à l'aide des connaissances du monde et des capacités de raisonnement de Gemini.

Avec cette version expérimentale publique, Gemini 2.5 Flash Image peut générer des images en 1 024 px, prend en charge la génération d'images de personnes et contient des filtres de sécurité mis à jour qui offrent une expérience utilisateur plus flexible et moins restrictive.

Il est compatible avec les modalités et les fonctionnalités suivantes :

  • Texte vers image

    • Exemple de requête : "Génère une image de la tour Eiffel avec des feux d'artifice en arrière-plan."

  • Texte vers image (rendu de texte)

    • Exemple de requête : "génère une photo cinématographique d'un grand bâtiment avec cette projection de texte géante sur la façade : "Gemini 2.5 peut désormais générer du texte long""

  • Texte en image(s) et texte (entrelacé)

    • Exemple de requête : "Génère une recette illustrée de paella. Crée des images à côté du texte lorsque tu génères la recette."
    • Exemple de requête : "Génère une histoire sur un chien dans un style d'animation cartoon 3D. Pour chaque scène, génère une image"

  • Image(s) et texte vers image(s) et texte (entrelacés)

    • Exemple de requête : (Avec une image d'une pièce meublée) "Quelles autres couleurs de canapés conviendraient à mon espace ? Peux-tu mettre à jour l'image ?"

  • Génération d'images en fonction de la localisation

    • Exemple de requête : "Génère une image d'un petit-déjeuner."

Bonnes pratiques

Pour améliorer les résultats de la génération d'images, suivez ces bonnes pratiques :

  • Soyez précis : plus vous fournissez d'informations, plus vous avez de contrôle. Par exemple, au lieu de "armure fantastique", essayez "armure de plates elfique ornée, gravée de motifs en feuille d'argent, avec un col montant et des épaulières en forme d'ailes de faucon".

  • Fournissez le contexte et l'intention : expliquez l'objectif de l'image pour aider le modèle à comprendre le contexte. Par exemple, "Crée un logo pour une marque de soins pour la peau haut de gamme et minimaliste" fonctionne mieux que "Crée un logo".

  • Répétez et affinez : ne vous attendez pas à obtenir une image parfaite du premier coup. Utilisez des requêtes de suivi pour apporter de petites modifications, par exemple "Rends l'éclairage plus chaud" ou "Rends l'expression du personnage plus sérieuse".

  • Utilisez des instructions détaillées : pour les scènes complexes, divisez votre requête en étapes. Par exemple, "Commence par créer un arrière-plan représentant une forêt sereine et brumeuse à l'aube. Ensuite, au premier plan, ajoute un ancien autel de pierre recouvert de mousse. Enfin, placez une épée lumineuse sur l'autel."

  • Décrivez ce que vous voulez, pas ce que vous ne voulez pas : au lieu de dire "pas de voitures", décrivez la scène de manière positive en disant "une rue vide et déserte sans aucun signe de circulation".

  • Contrôler la caméra : guidez la vue de la caméra. Utilisez des termes photographiques et cinématographiques pour décrire la composition, par exemple "plan large", "macro" ou "vue en contre-plongée".

  • Requêtes pour les images : décrivez l'intention en utilisant des expressions telles que "crée une image de" ou "génère une image de". Sinon, le modèle multimodal risque de répondre avec du texte au lieu de l'image.

Limites :

  • Pour des performances optimales, utilisez les langues suivantes : EN, es-MX, ja-JP, zh-CN, hi-IN.

  • La génération d'images n'est pas compatible avec les entrées audio ou vidéo.

  • Il est possible que le modèle ne crée pas le nombre exact d'images que vous demandez.

  • Pour de meilleurs résultats, incluez au maximum trois images dans une entrée.

  • Lorsque vous générez une image contenant du texte, commencez par générer le texte, puis générez une image avec ce texte.

  • Il est possible que la génération d'images ou de texte ne fonctionne pas comme prévu dans les cas suivants :

    • Le modèle ne peut créer que du texte. Si vous souhaitez obtenir des images, demandez-les clairement dans votre requête. Par exemple, "fournis des images au fur et à mesure".

    • Le modèle peut créer du texte sous forme d'image. Pour générer du texte, demandez spécifiquement une sortie textuelle. Par exemple, "génère un texte narratif avec des illustrations".

    • Le modèle peut arrêter de générer du contenu même s'il n'a pas terminé. Si cela se produit, réessayez ou utilisez un autre prompt.

    • Si un prompt est potentiellement dangereux, le modèle peut ne pas traiter la requête et renvoyer une réponse indiquant qu'il ne peut pas créer d'images dangereuses. Dans ce cas, FinishReason est STOP.

Générer des images

Les sections suivantes expliquent comment générer des images à l'aide de Vertex AI Studio ou de l'API.

Pour obtenir des conseils et connaître les bonnes pratiques concernant les requêtes, consultez Concevoir des requêtes multimodales.

Console

Pour utiliser la génération d'images :

  1. Ouvrez Vertex AI Studio > Créer une requête.
  2. Cliquez sur Changer de modèle, puis sélectionnez gemini-2.5-flash-image dans le menu.
  3. Dans le panneau Sorties, sélectionnez Image et texte dans le menu déroulant.
  4. Dans la zone de texte Écrivez une requête, saisissez une description de l'image que vous souhaitez générer.
  5. Cliquez sur le bouton Requête ().

Gemini génère une image en fonction de votre description. Ce processus devrait prendre quelques secondes, mais peut être relativement plus lent en fonction de la capacité.

Python

Installer

pip install --upgrade google-genai

Pour en savoir plus, consultez la documentation de référence du SDK.

Définissez des variables d'environnement pour utiliser le SDK Gen AI avec Vertex AI : 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 

from google import genai
from google.genai.types import GenerateContentConfig, Modality
from PIL import Image
from io import BytesIO

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-flash-image",
    contents=("Generate an image of the Eiffel tower with fireworks in the background."),
    config=GenerateContentConfig(
        response_modalities=[Modality.TEXT, Modality.IMAGE],
        candidate_count=1,
        safety_settings=[
            {"method": "PROBABILITY"},
            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT"},
            {"threshold": "BLOCK_MEDIUM_AND_ABOVE"},
        ],
    ),
)
for part in response.candidates[0].content.parts:
    if part.text:
        print(part.text)
    elif part.inline_data:
        image = Image.open(BytesIO((part.inline_data.data)))
        image.save("output_folder/example-image-eiffel-tower.png")
# Example response:
#   I will generate an image of the Eiffel Tower at night, with a vibrant display of
#   colorful fireworks exploding in the dark sky behind it. The tower will be
#   illuminated, standing tall as the focal point of the scene, with the bursts of
#   light from the fireworks creating a festive atmosphere.

Node.js

Installer

npm install @google/genai

Pour en savoir plus, consultez la documentation de référence du SDK.

Définissez des variables d'environnement pour utiliser le SDK Gen AI avec Vertex AI : 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 

const fs = require('fs');
const {GoogleGenAI, Modality} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION =
  process.env.GOOGLE_CLOUD_LOCATION || 'us-central1';

async function generateContent(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const response = await client.models.generateContentStream({
    model: 'gemini-2.5-flash-image',
    contents:
      'Generate an image of the Eiffel tower with fireworks in the background.',
    config: {
      responseModalities: [Modality.TEXT, Modality.IMAGE],
    },
  });

  const generatedFileNames = [];
  let imageIndex = 0;
  for await (const chunk of response) {
    const text = chunk.text;
    const data = chunk.data;
    if (text) {
      console.debug(text);
    } else if (data) {
      const fileName = `generate_content_streaming_image_${imageIndex++}.png`;
      console.debug(`Writing response image to file: ${fileName}.`);
      try {
        fs.writeFileSync(fileName, data);
        generatedFileNames.push(fileName);
      } catch (error) {
        console.error(`Failed to write image file ${fileName}:`, error);
      }
    }
  }

  return generatedFileNames;
}

Java

Découvrez comment installer ou mettre à jour le Java.

Pour en savoir plus, lisez la documentation de référence du SDK.

Définissez des variables d'environnement pour utiliser le SDK Gen AI avec Vertex AI : 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 


import com.google.genai.Client;
import com.google.genai.types.Blob;
import com.google.genai.types.Candidate;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.Part;
import com.google.genai.types.SafetySetting;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;

public class ImageGenMmFlashWithText {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash-image";
    String outputFile = "resources/output/example-image-eiffel-tower.png";
    generateContent(modelId, outputFile);
  }

  // Generates an image with text input
  public static void generateContent(String modelId, String outputFile) throws IOException {
    // Client Initialization. Once created, it can be reused for multiple requests.
    try (Client client = Client.builder().location("global").vertexAI(true).build()) {

      GenerateContentConfig contentConfig =
          GenerateContentConfig.builder()
              .responseModalities("TEXT", "IMAGE")
              .candidateCount(1)
              .safetySettings(
                  SafetySetting.builder()
                      .method("PROBABILITY")
                      .category("HARM_CATEGORY_DANGEROUS_CONTENT")
                      .threshold("BLOCK_MEDIUM_AND_ABOVE")
                      .build())
              .build();

      GenerateContentResponse response =
          client.models.generateContent(
              modelId,
              "Generate an image of the Eiffel tower with fireworks in the background.",
              contentConfig);

      // Get parts of the response
      List<Part> parts =
          response
              .candidates()
              .flatMap(candidates -> candidates.stream().findFirst())
              .flatMap(Candidate::content)
              .flatMap(Content::parts)
              .orElse(new ArrayList<>());

      // For each part print text if present, otherwise read image data if present and
      // write it to the output file
      for (Part part : parts) {
        if (part.text().isPresent()) {
          System.out.println(part.text().get());
        } else if (part.inlineData().flatMap(Blob::data).isPresent()) {
          BufferedImage image =
              ImageIO.read(new ByteArrayInputStream(part.inlineData().flatMap(Blob::data).get()));
          ImageIO.write(image, "png", new File(outputFile));
        }
      }

      System.out.println("Content written to: " + outputFile);
      // Example response:
      // Here is the Eiffel Tower with fireworks in the background...
      //
      // Content written to: resources/output/example-image-eiffel-tower.png
    }
  }
}

REST

Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel : 

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://${API_ENDPOINT}:generateContent \
  -d '{
    "contents": {
      "role": "USER",
      "parts": { "text": "Create a tutorial explaining how to make a peanut butter and jelly sandwich in three easy steps."},
    },
    "generation_config": {
      "response_modalities": ["TEXT", "IMAGE"],
      "image_config": {
        "aspect_ratio": "16:9",
      },
     },
     "safetySettings": {
      "method": "PROBABILITY",
      "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
      "threshold": "BLOCK_MEDIUM_AND_ABOVE"
    },
  }' 2>/dev/null >response.json

Gemini génère une image en fonction de votre description. Ce processus devrait prendre quelques secondes, mais peut être relativement plus lent en fonction de la capacité.

Générer du texte entrecoupé d'images

Gemini 2.5 Flash Image peut générer des images intercalées avec ses réponses textuelles. Par exemple, vous pouvez générer des images de chaque étape d'une recette générée pour accompagner le texte de cette étape, sans avoir à envoyer des requêtes distinctes au modèle pour ce faire.

Console

Pour générer des images entrecoupées de réponses textuelles :

  1. Ouvrez Vertex AI Studio > Créer une requête.
  2. Cliquez sur Changer de modèle, puis sélectionnez gemini-2.5-flash-image dans le menu.
  3. Dans le panneau Sorties, sélectionnez Image et texte dans le menu déroulant.
  4. Dans la zone de texte Écrivez une requête, saisissez une description de l'image que vous souhaitez générer. Par exemple, "Crée un tutoriel expliquant comment faire un sandwich au beurre de cacahuète et à la confiture en trois étapes simples. Pour chaque étape, indique un titre avec le numéro de l'étape, une explication et génère également une image au format 1:1."
  5. Cliquez sur le bouton Requête ().

Gemini générera une réponse en fonction de votre description. Ce processus devrait prendre quelques secondes, mais peut être relativement plus lent en fonction de la capacité.

Python

Installer

pip install --upgrade google-genai

Pour en savoir plus, consultez la documentation de référence du SDK.

Définissez des variables d'environnement pour utiliser le SDK Gen AI avec Vertex AI : 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 

from google import genai
from google.genai.types import GenerateContentConfig, Modality
from PIL import Image
from io import BytesIO

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-flash-image",
    contents=(
        "Generate an illustrated recipe for a paella."
        "Create images to go alongside the text as you generate the recipe"
    ),
    config=GenerateContentConfig(response_modalities=[Modality.TEXT, Modality.IMAGE]),
)
with open("output_folder/paella-recipe.md", "w") as fp:
    for i, part in enumerate(response.candidates[0].content.parts):
        if part.text is not None:
            fp.write(part.text)
        elif part.inline_data is not None:
            image = Image.open(BytesIO((part.inline_data.data)))
            image.save(f"output_folder/example-image-{i+1}.png")
            fp.write(f"![image](example-image-{i+1}.png)")
# Example response:
#  A markdown page for a Paella recipe(`paella-recipe.md`) has been generated.
#   It includes detailed steps and several images illustrating the cooking process.

Java

Découvrez comment installer ou mettre à jour le Java.

Pour en savoir plus, lisez la documentation de référence du SDK.

Définissez des variables d'environnement pour utiliser le SDK Gen AI avec Vertex AI : 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 


import com.google.genai.Client;
import com.google.genai.types.Blob;
import com.google.genai.types.Candidate;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.Part;
import java.awt.image.BufferedImage;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;

public class ImageGenMmFlashTextAndImageWithText {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash-image";
    String outputFile = "resources/output/paella-recipe.md";
    generateContent(modelId, outputFile);
  }

  // Generates text and image with text input
  public static void generateContent(String modelId, String outputFile) throws IOException {
    // Client Initialization. Once created, it can be reused for multiple requests.
    try (Client client = Client.builder().location("global").vertexAI(true).build()) {

      GenerateContentResponse response =
          client.models.generateContent(
              modelId,
              Content.fromParts(
                  Part.fromText("Generate an illustrated recipe for a paella."),
                  Part.fromText(
                      "Create images to go alongside the text as you generate the recipe.")),
              GenerateContentConfig.builder().responseModalities("TEXT", "IMAGE").build());

      try (BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile))) {

        // Get parts of the response
        List<Part> parts =
            response
                .candidates()
                .flatMap(candidates -> candidates.stream().findFirst())
                .flatMap(Candidate::content)
                .flatMap(Content::parts)
                .orElse(new ArrayList<>());

        int index = 1;
        // For each part print text if present, otherwise read image data if present and
        // write it to the output file
        for (Part part : parts) {
          if (part.text().isPresent()) {
            writer.write(part.text().get());
          } else if (part.inlineData().flatMap(Blob::data).isPresent()) {
            BufferedImage image =
                ImageIO.read(new ByteArrayInputStream(part.inlineData().flatMap(Blob::data).get()));
            ImageIO.write(
                image, "png", new File("resources/output/example-image-" + index + ".png"));
            writer.write("![image](example-image-" + index + ".png)");
          }
          index++;
        }

        System.out.println("Content written to: " + outputFile);

        // Example response:
        // A markdown page for a Paella recipe(`paella-recipe.md`) has been generated.
        // It includes detailed steps and several images illustrating the cooking process.
        //
        // Content written to:  resources/output/paella-recipe.md
      }
    }
  }
}

REST

Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel : 

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://${API_ENDPOINT}:generateContent \
  -d '{
    "contents": {
      "role": "USER",
      "parts": { "text": "Create a tutorial explaining how to make a peanut butter and jelly sandwich in three easy steps. For each step, provide a title with the number of the step, an explanation, and also generate an image, generate each image in a 1:1 aspect ratio."},
    },
    "generation_config": {
      "response_modalities": ["TEXT", "IMAGE"],
      "image_config": {
        "aspect_ratio": "16:9",
      },
    },
    "safetySettings": {
      "method": "PROBABILITY",
      "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
      "threshold": "BLOCK_MEDIUM_AND_ABOVE"
    },
  }' 2>/dev/null >response.json

Gemini génère une image en fonction de votre description. Ce processus devrait prendre quelques secondes, mais peut être relativement plus lent en fonction de la capacité.

Génération d'images en fonction de la localisation

Gemini 2.5 Flash Image peut également inclure des informations sur votre position lorsqu'il fournit des réponses textuelles ou imagées. Par exemple, vous pouvez générer des images de types de lieux ou d'expériences qui tiennent compte de votre position actuelle sans avoir à la spécifier au modèle.

Console

Pour utiliser la génération d'images en fonction de la localisation :

  1. Ouvrez Vertex AI Studio > Créer une requête.
  2. Cliquez sur Changer de modèle, puis sélectionnez gemini-2.5-flash-image dans le menu.
  3. Dans le panneau Sorties, sélectionnez Image et texte dans le menu déroulant.
  4. Dans la zone de texte Écrivez une requête, saisissez une description de l'image que vous souhaitez générer. Par exemple, "Génère une photo d'un petit-déjeuner typique."
  5. Cliquez sur le bouton Requête ().

Gemini générera une réponse en fonction de votre description. Ce processus devrait prendre quelques secondes, mais peut être relativement plus lent en fonction de la capacité.

Python

Installer

pip install --upgrade google-genai

Pour en savoir plus, consultez la documentation de référence du SDK.

Définissez des variables d'environnement pour utiliser le SDK Gen AI avec Vertex AI : 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 

from google import genai
from google.genai.types import GenerateContentConfig, Modality
from PIL import Image
from io import BytesIO

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-flash-image",
    contents=("Generate a photo of a breakfast meal."),
    config=GenerateContentConfig(response_modalities=[Modality.TEXT, Modality.IMAGE]),
)
for part in response.candidates[0].content.parts:
    if part.text:
        print(part.text)
    elif part.inline_data:
        image = Image.open(BytesIO((part.inline_data.data)))
        image.save("output_folder/example-breakfast-meal.png")
# Example response:
#   Generates a photo of a vibrant and appetizing breakfast meal.
#   The scene will feature a white plate with golden-brown pancakes
#   stacked neatly, drizzled with rich maple syrup and ...

Java

Découvrez comment installer ou mettre à jour le Java.

Pour en savoir plus, lisez la documentation de référence du SDK.

Définissez des variables d'environnement pour utiliser le SDK Gen AI avec Vertex AI : 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 


import com.google.genai.Client;
import com.google.genai.types.Blob;
import com.google.genai.types.Candidate;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.Part;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.imageio.ImageIO;

public class ImageGenMmFlashLocaleAwareWithText {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash-image";
    String outputFile = "resources/output/example-breakfast-meal.png";
    generateContent(modelId, outputFile);
  }

  // Generates an image with text input
  public static void generateContent(String modelId, String outputFile) throws IOException {
    // Client Initialization. Once created, it can be reused for multiple requests.
    try (Client client = Client.builder().location("global").vertexAI(true).build()) {

      GenerateContentResponse response =
          client.models.generateContent(
              modelId,
              "Generate a photo of a breakfast meal.",
              GenerateContentConfig.builder().responseModalities("TEXT", "IMAGE").build());

      // Get parts of the response
      List<Part> parts =
          response
              .candidates()
              .flatMap(candidates -> candidates.stream().findFirst())
              .flatMap(Candidate::content)
              .flatMap(Content::parts)
              .orElse(new ArrayList<>());

      // For each part print text if present, otherwise read image data if present and
      // write it to the output file
      for (Part part : parts) {
        if (part.text().isPresent()) {
          System.out.println(part.text().get());
        } else if (part.inlineData().flatMap(Blob::data).isPresent()) {
          BufferedImage image =
              ImageIO.read(new ByteArrayInputStream(part.inlineData().flatMap(Blob::data).get()));
          ImageIO.write(image, "png", new File(outputFile));
        }
      }

      System.out.println("Content written to: " + outputFile);

      // Example response:
      // Here is a photo of a breakfast meal for you!
      //
      // Content written to: resources/output/example-breakfast-meal.png
    }
  }
}

REST

Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel : 

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://${API_ENDPOINT}:generateContent \
  -d '{
    "contents": {
      "role": "USER",
      "parts": { "text": "Generate a photo of a typical breakfast."},
    },
    "generation_config": {
      "response_modalities": ["TEXT", "IMAGE"],
      "image_config": {
        "aspect_ratio": "16:9",
      },
    },
    "safetySettings": {
      "method": "PROBABILITY",
      "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
      "threshold": "BLOCK_MEDIUM_AND_ABOVE"
    },
  }' 2>/dev/null >response.json

Gemini génère une image en fonction de votre description. Ce processus devrait prendre quelques secondes, mais peut être relativement plus lent en fonction de la capacité.