Gerar imagens com o Gemini

O Gemini 2.5 Flash Image oferece suporte à geração de respostas em várias modalidades, incluindo texto e imagens.

Geração de imagens

O Gemini 2.5 Flash Image (gemini-2.5-flash-image) permite gerar imagens além de texto. Isso amplia os recursos do Gemini para incluir o seguinte:

  • Gere imagens de forma iterativa por conversa em linguagem natural, ajustando as imagens e mantendo a consistência e o contexto.
  • Gere imagens com renderização de texto longo de alta qualidade.
  • Gere uma saída de texto e imagem intercalada. Por exemplo, uma postagem de blog com texto e imagens em uma única interação. Antes, isso exigia a junção de vários modelos.
  • Gere imagens usando o conhecimento de mundo e os recursos de raciocínio do Gemini.

Com essa versão experimental pública, o Gemini 2.5 Flash Image pode gerar imagens em 1024 px, criar imagens de pessoas e contém filtros de segurança atualizados que oferecem uma experiência do usuário mais flexível e menos restritiva.

Ele é compatível com as seguintes modalidades e recursos:

  • Texto para imagem

    • Exemplo de comando: "Gere uma imagem da Torre Eiffel com fogos de artifício ao fundo".

  • Texto para imagem (renderização de texto)

    • Exemplo de comando: "gere uma foto cinematográfica de um grande edifício com esta projeção de texto gigante mapeada na frente do edifício: "O Gemini 2.5 agora pode gerar textos longos""

  • Texto para imagens e texto (intercalado)

    • Exemplo de comando: "Gere uma receita ilustrada de paella. Crie imagens ao lado do texto enquanto gera a receita".
    • Exemplo de comando: "Gere uma história sobre um cachorro em um estilo de animação de desenho animado em 3D. Para cada cena, gere uma imagem"

  • Imagens e texto para imagens e texto (intercalados)

    • Comando de exemplo: (com uma imagem de um quarto mobiliado) "Quais outros sofás de cores ficariam bons no meu espaço? Você pode atualizar a imagem?"

  • Geração de imagens com reconhecimento de localidade

    • Exemplo de comando: "Gere uma imagem de um café da manhã".

Práticas recomendadas

Para melhorar os resultados da geração de imagens, siga estas práticas recomendadas:

  • Seja específico:mais detalhes dão mais controle. Por exemplo, em vez de "armadura de fantasia", tente "armadura de placa élfica ornamentada, gravada com padrões de folha de prata, com um colar alto e ombreiras em forma de asas de falcão".

  • Forneça contexto e intenção:explique a finalidade da imagem para ajudar o modelo a entender o contexto. Por exemplo, "Crie um logotipo para uma marca de cuidados com a pele sofisticada e minimalista" funciona melhor do que "Crie um logotipo".

  • Itere e refine:não espere uma imagem perfeita na primeira tentativa. Use comandos de acompanhamento para fazer pequenas mudanças, por exemplo, "Deixe a iluminação mais quente" ou "Mude a expressão do personagem para algo mais sério".

  • Use instruções detalhadas:para cenas complexas, divida seu pedido em etapas. Por exemplo: "Primeiro, crie um plano de fundo de uma floresta serena e enevoada ao amanhecer. Em seguida, em primeiro plano, adicione um altar de pedra antigo coberto de musgo. Por fim, coloque uma única espada brilhante em cima do altar."

  • Descreva o que você quer, não o que você não quer:em vez de dizer "sem carros", descreva a cena de forma positiva dizendo "uma rua vazia e deserta sem sinais de trânsito".

  • Controlar a câmera:guie a visualização da câmera. Use termos fotográficos e cinematográficos para descrever a composição, por exemplo, "foto grande-angular", "foto macro" ou "perspectiva de baixo ângulo".

  • Comando para imagens:descreva a intenção usando frases como "crie uma imagem de" ou "gere uma imagem de". Caso contrário, o modelo multimodal pode responder com texto em vez da imagem.

Limitações:

  • Para ter o melhor desempenho, use os seguintes idiomas: EN, es-MX, ja-JP, zh-CN e hi-IN.

  • A geração de imagens não aceita entradas de áudio ou vídeo.

  • O modelo pode não criar o número exato de imagens que você pediu.

  • Para ter os melhores resultados, inclua no máximo três imagens em uma entrada.

  • Ao gerar uma imagem com texto, primeiro gere o texto e depois gere uma imagem com esse texto.

  • A geração de imagens ou texto pode não funcionar como esperado nestas situações:

    • O modelo só pode criar texto. Se você quiser imagens, peça isso de forma clara na sua solicitação. Por exemplo, "forneça imagens à medida que avança".

    • O modelo pode criar texto como uma imagem. Para gerar texto, peça especificamente uma saída de texto. Por exemplo, "gere texto narrativo com ilustrações".

    • O modelo pode parar de gerar conteúdo mesmo quando não tiver terminado. Se isso acontecer, tente de novo ou use outro comando.

    • Se um comando for potencialmente não seguro, o modelo poderá não processar a solicitação e vai retornar uma resposta indicando que não é possível criar imagens não seguras. Nesse caso, o FinishReason é STOP.

Gerar imagens

As seções a seguir mostram como gerar imagens usando o Vertex AI Studio ou a API.

Para orientações e práticas recomendadas de comandos, consulte Criar comandos multimodais.

Console

Para usar a geração de imagens:

  1. Abra Vertex AI Studio > Criar comando.
  2. Clique em Trocar modelo e selecione gemini-2.5-flash-image no menu.
  3. No painel Saídas, selecione Imagem e texto no menu suspenso.
  4. Escreva uma descrição da imagem que você quer gerar na área de texto Escreva um comando.
  5. Clique no botão Comando ().

O Gemini vai gerar uma imagem com base na sua descrição. Esse processo leva alguns segundos, mas pode ser comparativamente mais lento dependendo da capacidade.

Python

Instalar

pip install --upgrade google-genai

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com a 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 saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com a 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

Saiba como instalar ou atualizar o Java.

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com a 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

Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual: 

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

O Gemini vai gerar uma imagem com base na sua descrição. Esse processo leva alguns segundos, mas pode ser comparativamente mais lento dependendo da capacidade.

Gerar resposta com textos e imagens

O Gemini 2.5 Flash Image pode gerar imagens intercaladas com as respostas de texto. Por exemplo, você pode gerar imagens de como cada etapa de uma receita gerada pode ser para acompanhar o texto dessa etapa, sem precisar fazer solicitações separadas ao modelo para isso.

Console

Para gerar imagens intercaladas com respostas de texto:

  1. Abra Vertex AI Studio > Criar comando.
  2. Clique em Trocar modelo e selecione gemini-2.5-flash-image no menu.
  3. No painel Saídas, selecione Imagem e texto no menu suspenso.
  4. Escreva uma descrição da imagem que você quer gerar na área de texto Escreva um comando. Por exemplo, "Crie um tutorial explicando como fazer um sanduíche de pasta de amendoim e geleia em três etapas simples. Para cada etapa, forneça um título com o número da etapa, uma explicação e também gere uma imagem, cada uma em uma proporção de 1:1."
  5. Clique no botão Comando ().

O Gemini vai gerar uma resposta com base na sua descrição. Esse processo leva alguns segundos, mas pode ser comparativamente mais lento dependendo da capacidade.

Python

Instalar

pip install --upgrade google-genai

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com a 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

Saiba como instalar ou atualizar o Java.

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com a 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

Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual: 

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

O Gemini vai gerar uma imagem com base na sua descrição. Esse processo leva alguns segundos, mas pode ser comparativamente mais lento dependendo da capacidade.

Geração de imagens com reconhecimento de localidade

O Gemini 2.5 Flash Image também pode incluir informações sobre sua localização ao fornecer respostas em texto ou imagem. Por exemplo, você pode gerar imagens de tipos de lugares ou experiências que consideram sua localização atual sem precisar especificar seu local para o modelo.

Console

Para usar a geração de imagens com reconhecimento de localidade:

  1. Abra Vertex AI Studio > Criar comando.
  2. Clique em Trocar modelo e selecione gemini-2.5-flash-image no menu.
  3. No painel Saídas, selecione Imagem e texto no menu suspenso.
  4. Escreva uma descrição da imagem que você quer gerar na área de texto Escreva um comando. Por exemplo, "Gere uma foto de um café da manhã típico".
  5. Clique no botão Comando ().

O Gemini vai gerar uma resposta com base na sua descrição. Esse processo leva alguns segundos, mas pode ser comparativamente mais lento dependendo da capacidade.

Python

Instalar

pip install --upgrade google-genai

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com a 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

Saiba como instalar ou atualizar o Java.

Para saber mais, consulte a documentação de referência do SDK.

Defina variáveis de ambiente para usar o SDK de IA generativa com a 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

Execute o comando a seguir no terminal para criar ou substituir esse arquivo no diretório atual: 

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

O Gemini vai gerar uma imagem com base na sua descrição. Esse processo leva alguns segundos, mas pode ser comparativamente mais lento dependendo da capacidade.