Gere imagens com o Gemini

O Gemini 2.5 Flash Image suporta a 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) suporta a capacidade de gerar imagens, além de texto. Isto expande as capacidades do Gemini para incluir o seguinte:

  • Gerar imagens iterativamente através de conversas com linguagem natural, ajustando as imagens e mantendo a consistência e o contexto.
  • Gere imagens com renderização de texto longo de alta qualidade.
  • Gerar resultados de texto e imagem intercalados. Por exemplo, uma publicação no blogue com texto e imagens num único comando. Anteriormente, isto exigia a combinação de vários modelos.
  • Gere imagens com o conhecimento do mundo e as capacidades de raciocínio do Gemini.

Com esta versão experimental pública, o Gemini 2.5 Flash Image pode gerar imagens em 1024 px, suporta a geração de imagens de pessoas e contém filtros de segurança atualizados que proporcionam uma experiência do utilizador mais flexível e menos restritiva.

Suporta as seguintes modalidades e capacidades:

  • Texto para imagem

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

  • Text to Image (renderização de texto)

    • Exemplo de comando: "gera 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 já pode gerar texto de formato longo""

  • Texto para imagens e texto (intercalado)

    • Exemplo de comando: "Gera uma receita ilustrada de uma paelha. Cria imagens juntamente com o texto à medida que gera a receita."
    • Exemplo de comando: "Gera uma história sobre um cão num estilo de animação de desenho animado 3D. Para cada cena, gera uma imagem"

  • Imagens e texto para imagens e texto (intercalados)

    • Comando de exemplo: (com uma imagem de uma sala mobilada) "Que outras cores de sofás ficariam bem no meu espaço? Pode atualizar a imagem?"

  • Geração de imagens com reconhecimento da localização

    • Exemplo de comando: "Gera uma imagem de uma refeição ao pequeno-almoço."

Práticas recomendadas

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

  • Seja específico: mais detalhes dão-lhe mais controlo. Por exemplo, em vez de "armadura de fantasia", experimente "armadura de placas élfica ornamentada, gravada com padrões de folhas de prata, com uma gola alta 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 compreender o contexto. Por exemplo, "Cria um logótipo para uma marca de cuidados de pele minimalista e de alta qualidade" funciona melhor do que "Cria um logótipo".

  • Itere e refine: não espere uma imagem perfeita à primeira tentativa. Use comandos de seguimento para fazer pequenas alterações, por exemplo, "Torna a iluminação mais quente" ou "Altera a expressão do personagem para ser mais séria".

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

  • Descreva o que quer, não o que 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âmara: orientar a vista da câmara. Use termos fotográficos e cinematográficos para descrever a composição, por exemplo, "grande angular", "macro" ou "perspetiva de ângulo baixo".

  • Comandos para imagens: descreva a intenção com expressões como "criar uma imagem de" ou "gerar uma imagem de". Caso contrário, o modelo multimodal pode responder com texto em vez da imagem.

Limitações:

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

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

  • O modelo pode não criar o número exato de imagens que pedir.

  • Para os melhores resultados, inclua um máximo de três imagens numa entrada.

  • Quando gera uma imagem com texto, primeiro gera o texto e, em seguida, gera uma imagem com esse texto.

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

    • O modelo só pode criar texto. Se quiser imagens, peça-as claramente na sua solicitação. Por exemplo, "fornece imagens à medida que avança".

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

    • O modelo pode parar de gerar conteúdo, mesmo quando não tiver terminado. Se isto ocorrer, tente novamente ou use um comando diferente.

    • Se um comando for potencialmente inseguro, o modelo pode não processar o pedido e devolve uma resposta a indicar que não consegue criar imagens inseguras. Neste caso, o FinishReason é STOP.

Gerar imagens

As secções seguintes abordam como gerar imagens através do Vertex AI Studio ou da API.

Para ver orientações e práticas recomendadas para a criação de comandos, consulte o artigo Crie comandos multimodais.

Consola

Para usar a geração de imagens:

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

O Gemini gera uma imagem com base na sua descrição. Este processo deve demorar alguns segundos, mas pode ser comparativamente mais lento consoante a capacidade.

Python

Instalação

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 gen com o 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

Instalação

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 gen com o 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 gen com o 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 seguinte comando no terminal para criar ou substituir este ficheiro 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 gera uma imagem com base na sua descrição. Este processo deve demorar alguns segundos, mas pode ser comparativamente mais lento consoante a capacidade.

Gere imagens e texto intercalados

O Gemini 2.5 Flash Image pode gerar imagens intercaladas com as respetivas respostas de texto. Por exemplo, pode gerar imagens de como cada passo de uma receita gerada pode ser para acompanhar o texto desse passo, sem ter de fazer pedidos separados ao modelo para o fazer.

Consola

Para gerar imagens intercaladas com respostas de texto:

  1. Abra o Vertex AI Studio > Criar comando.
  2. Clique em Mudar modelo e selecione gemini-2.5-flash-image no menu.
  3. No painel Resultados, selecione Imagem e texto no menu pendente.
  4. Escreva uma descrição da imagem que quer gerar na área de texto de Escreva um comando. Por exemplo, "Cria um tutorial a explicar como fazer uma sanduíche de manteiga de amendoim e geleia em três passos simples. Para cada passo, indique um título com o número do passo, uma explicação e também gere uma imagem. Gere cada imagem numa proporção de 1:1."
  5. Clique no botão Comando ().

O Gemini gera uma resposta com base na sua descrição. Este processo deve demorar alguns segundos, mas pode ser comparativamente mais lento consoante a capacidade.

Python

Instalação

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 gen com o 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 gen com o 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 seguinte comando no terminal para criar ou substituir este ficheiro 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 gera uma imagem com base na sua descrição. Este processo deve demorar alguns segundos, mas pode ser comparativamente mais lento consoante a capacidade.

Geração de imagens com reconhecimento da localização

A imagem do Gemini 2.5 Flash também pode incluir informações sobre a sua localização quando fornece respostas de texto ou de imagem. Por exemplo, pode gerar imagens de tipos de localizações ou experiências que têm em conta a sua localização atual sem ter de especificar a sua localização ao modelo para o fazer.

Consola

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

  1. Abra o Vertex AI Studio > Criar comando.
  2. Clique em Mudar modelo e selecione gemini-2.5-flash-image no menu.
  3. No painel Resultados, selecione Imagem e texto no menu pendente.
  4. Escreva uma descrição da imagem que quer gerar na área de texto de Escreva um comando. Por exemplo, "Gera uma foto de um pequeno-almoço típico."
  5. Clique no botão Comando ().

O Gemini gera uma resposta com base na sua descrição. Este processo deve demorar alguns segundos, mas pode ser comparativamente mais lento consoante a capacidade.

Python

Instalação

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 gen com o 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 gen com o 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 seguinte comando no terminal para criar ou substituir este ficheiro 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 gera uma imagem com base na sua descrição. Este processo deve demorar alguns segundos, mas pode ser comparativamente mais lento consoante a capacidade.