Generar imágenes con Gemini

Gemini 2.5 Flash Image admite la generación de respuestas en varias modalidades, como texto e imágenes.

Generación de imágenes

Gemini 2.5 Flash Image (gemini-2.5-flash-image) permite generar imágenes además de texto. De esta forma, Gemini puede hacer lo siguiente:

  • Genera imágenes de forma iterativa mediante conversaciones con lenguaje natural y ajusta las imágenes manteniendo la coherencia y el contexto.
  • Genera imágenes con renderización de texto largo de alta calidad.
  • Genera una salida de texto e imagen intercalada. Por ejemplo, una entrada de blog con texto e imágenes en una sola petición. Antes, esto requería encadenar varios modelos.
  • Genera imágenes usando el conocimiento del mundo y las capacidades de razonamiento de Gemini.

Con esta versión experimental pública, Gemini 2.5 Flash Image puede generar imágenes de 1024 px, admite la generación de imágenes de personas y contiene filtros de seguridad actualizados que ofrecen una experiencia de usuario más flexible y menos restrictiva.

Admite las siguientes modalidades y funciones:

  • Texto a imagen

    • Petición de ejemplo: "Genera una imagen de la Torre Eiffel con fuegos artificiales de fondo".

  • Texto a imagen (renderización de texto)

    • Petición de ejemplo: "genera una foto cinematográfica de un edificio grande con esta proyección de texto gigante en la parte delantera del edificio: "Gemini 2.5 ahora puede generar texto extenso""

  • Texto a imagen(es) y texto (intercalado)

    • Petición de ejemplo: "Genera una receta ilustrada de paella. Crea imágenes junto al texto a medida que generas la receta".
    • Petición de ejemplo: "Genera una historia sobre un perro con un estilo de animación de dibujos animados en 3D. Genera una imagen para cada escena"

  • Imágenes y texto a imágenes y texto (intercalados)

    • Petición de ejemplo: (Con una imagen de una habitación amueblada) "¿Qué otros colores de sofá quedarían bien en mi espacio? ¿Puedes actualizar la imagen?"

  • Generación de imágenes según la configuración regional

    • Petición de ejemplo: "Genera una imagen de un desayuno".

Prácticas recomendadas

Para mejorar los resultados de generación de imágenes, siga estas prácticas recomendadas:

  • Especifica: cuantos más detalles proporciones, más control tendrás. Por ejemplo, en lugar de "armadura de fantasía", prueba con "armadura de placas élfica ornamentada, grabada con patrones de hojas de plata, con un cuello alto y hombreras con forma de alas de halcón".

  • Proporciona contexto e intención: explica el propósito de la imagen para ayudar al modelo a entender el contexto. Por ejemplo, "Crea un logotipo para una marca de alta gama y minimalista de cuidado de la piel" funciona mejor que "Crea un logotipo".

  • Repetir y perfeccionar: no esperes obtener una imagen perfecta en el primer intento. Usa peticiones de seguimiento para hacer pequeños cambios, como "Haz que la iluminación sea más cálida" o "Cambia la expresión del personaje para que sea más seria".

  • Usa instrucciones detalladas: en escenas complejas, divide tu petición en pasos. Por ejemplo, "Primero, crea un fondo de un bosque sereno y brumoso al amanecer. Después, en primer plano, añade un altar de piedra antiguo cubierto de musgo. Por último, coloca una espada brillante sobre el altar".

  • Describe lo que quieres, no lo que no quieres: en lugar de decir "sin coches", describe la escena de forma positiva diciendo "una calle vacía y desierta sin señales de tráfico".

  • Controlar la cámara: guía la vista de la cámara. Usa términos fotográficos y cinematográficos para describir la composición, como "plano general", "macro" o "plano desde abajo".

  • Peticiones de imágenes: describe la intención con frases como "crea una imagen de" o "genera una imagen de". De lo contrario, el modelo multimodal podría responder con texto en lugar de con la imagen.

Limitaciones:

  • Para obtener el mejor rendimiento posible, usa los siguientes idiomas: inglés, español de México, japonés, chino y hindi.

  • La generación de imágenes no admite entradas de audio ni de vídeo.

  • Es posible que el modelo no cree el número exacto de imágenes que le pidas.

  • Para obtener los mejores resultados, incluye un máximo de tres imágenes en una petición.

  • Cuando generes una imagen que contenga texto, primero genera el texto y, después, genera una imagen con ese texto.

  • Es posible que la generación de imágenes o texto no funcione como se espera en las siguientes situaciones:

    • Es posible que el modelo solo cree texto. Si quieres imágenes, pídelas claramente en tu solicitud. Por ejemplo, "proporciona imágenes a medida que avanzamos".

    • El modelo podría crear texto como una imagen. Para generar texto, pide específicamente que se muestre texto. Por ejemplo, "genera texto narrativo junto con ilustraciones".

    • Es posible que el modelo deje de generar contenido aunque no haya terminado. Si esto ocurre, vuelve a intentarlo o usa otra petición.

    • Si una petición es potencialmente peligrosa, es posible que el modelo no la procese y devuelva una respuesta que indique que no puede crear imágenes peligrosas. En este caso, el FinishReason es STOP.

Generar imágenes

En las siguientes secciones se explica cómo generar imágenes con Vertex AI Studio o con la API.

Para obtener directrices y prácticas recomendadas sobre cómo crear peticiones, consulta Diseñar peticiones multimodales.

Consola

Para usar la generación de imágenes, sigue estos pasos:

  1. Abre Vertex AI Studio > Crear petición.
  2. Haz clic en Cambiar modelo y selecciona gemini-2.5-flash-image en el menú.
  3. En el panel Resultados, selecciona Imagen y texto en el menú desplegable.
  4. Escribe una descripción de la imagen que quieras generar en el área de texto Escribe una petición.
  5. Haz clic en el botón Petición ().

Gemini generará una imagen basada en tu descripción. Este proceso debería tardar unos segundos, pero puede ser relativamente más lento en función de la capacidad.

Python

Instalar

pip install --upgrade google-genai

Para obtener más información, consulta la documentación de referencia del SDK.

Define variables de entorno para usar el SDK de IA generativa con 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

Instalar

npm install @google/genai

Para obtener más información, consulta la documentación de referencia del SDK.

Define variables de entorno para usar el SDK de IA generativa con 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

Consulta cómo instalar o actualizar Java.

Para obtener más información, consulta la documentación de referencia del SDK.

Define variables de entorno para usar el SDK de IA generativa con 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

Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual: 

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 generará una imagen basada en tu descripción. Este proceso debería tardar unos segundos, pero puede ser relativamente más lento en función de la capacidad.

Generar imágenes y texto intercalados

Gemini 2.5 Flash Image puede generar imágenes intercaladas con sus respuestas de texto. Por ejemplo, puedes generar imágenes de cada paso de una receta generada para acompañar el texto de ese paso, sin tener que hacer solicitudes independientes al modelo para ello.

Consola

Para generar imágenes intercaladas con respuestas de texto, sigue estos pasos:

  1. Abre Vertex AI Studio > Crear petición.
  2. Haz clic en Cambiar modelo y selecciona gemini-2.5-flash-image en el menú.
  3. En el panel Resultados, selecciona Imagen y texto en el menú desplegable.
  4. Escribe una descripción de la imagen que quieras generar en el área de texto Escribe una petición. Por ejemplo, "Crea un tutorial en el que se explique cómo hacer un sándwich de mantequilla de cacahuete y mermelada en tres sencillos pasos. En cada paso, indica un título con el número del paso y una explicación. Además, genera una imagen con una relación de aspecto de 1:1".
  5. Haz clic en el botón Petición ().

Gemini generará una respuesta basada en tu descripción. Este proceso debería tardar unos segundos, pero puede ser relativamente más lento en función de la capacidad.

Python

Instalar

pip install --upgrade google-genai

Para obtener más información, consulta la documentación de referencia del SDK.

Define variables de entorno para usar el SDK de IA generativa con 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

Consulta cómo instalar o actualizar Java.

Para obtener más información, consulta la documentación de referencia del SDK.

Define variables de entorno para usar el SDK de IA generativa con 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

Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual: 

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 generará una imagen basada en tu descripción. Este proceso debería tardar unos segundos, pero puede ser relativamente más lento en función de la capacidad.

Generación de imágenes según la configuración regional

Gemini 2.5 Flash Image también puede incluir información sobre tu ubicación al proporcionar respuestas de texto o de imagen. Por ejemplo, puedes generar imágenes de tipos de ubicaciones o experiencias que tengan en cuenta tu ubicación actual sin tener que especificarla en el modelo.

Consola

Para usar la generación de imágenes en función de la configuración regional, sigue estos pasos:

  1. Abre Vertex AI Studio > Crear petición.
  2. Haz clic en Cambiar modelo y selecciona gemini-2.5-flash-image en el menú.
  3. En el panel Resultados, selecciona Imagen y texto en el menú desplegable.
  4. Escribe una descripción de la imagen que quieras generar en el área de texto Escribe una petición. Por ejemplo, "Genera una foto de un desayuno típico".
  5. Haz clic en el botón Petición ().

Gemini generará una respuesta basada en tu descripción. Este proceso debería tardar unos segundos, pero puede ser relativamente más lento en función de la capacidad.

Python

Instalar

pip install --upgrade google-genai

Para obtener más información, consulta la documentación de referencia del SDK.

Define variables de entorno para usar el SDK de IA generativa con 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

Consulta cómo instalar o actualizar Java.

Para obtener más información, consulta la documentación de referencia del SDK.

Define variables de entorno para usar el SDK de IA generativa con 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

Ejecuta el siguiente comando en el terminal para crear o sobrescribir este archivo en el directorio actual: 

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 generará una imagen basada en tu descripción. Este proceso debería tardar unos segundos, pero puede ser relativamente más lento en función de la capacidad.