Pensando

Os modelos Gemini 2.5 podem usar um "processo de pensamento" interno que melhora significativamente as habilidades de raciocínio e planejamento de várias etapas, tornando-os altamente eficazes para tarefas complexas, como programação, matemática avançada e análise de dados.

É possível configurar o quanto um modelo pode pensar usando um orçamento de pensamento. Essa configuração é especialmente importante se a redução da latência ou do custo for uma prioridade. Além disso, confira a comparação de dificuldades das tarefas para decidir o quanto um modelo pode precisar da capacidade de raciocínio.

Observação: a inclusão de resumos de ideias e o processamento de assinaturas de pensamento ainda não são compatíveis com os SDKs Firebase AI Logic.

O suporte para definir um orçamento de pensamento está disponível para iOS+, Android e Web. Ele vai estar disponível para Flutter e Unity nas próximas versões.

Usar um modelo de pensamento

Use um modelo de pensamento como qualquer outro modelo Gemini (inicialize o provedor Gemini API escolhido, crie uma instância GenerativeModel etc.). Esses modelos podem ser usados para tarefas de geração de texto ou código, como gerar saída estruturada ou analisar entrada multimodal (como imagens, vídeo, áudio, ou PDFs). Você pode até usar modelos de pensamento ao transmitir a saída.

Observação :o Gemini 2.5 Flash‑Lite tem a capacidade de pensar desativada por padrão. Para ativar o pensamento desse modelo, defina o thinkingBudget como um valor compatível. Para todos os outros modelos compatíveis, o pensamento está ativado por padrão.

Modelos compatíveis

Apenas os modelos Gemini 2.5 são compatíveis com essa capacidade.

• gemini-2.5-pro
• gemini-2.5-flash
• gemini-2.5-flash-lite-preview-06-17

Práticas recomendadas para usar modelos de pensamento

Recomendamos testar o comando no Google AI Studio ou no Vertex AI Studio para conferir todo o processo de pensamento. Você pode identificar áreas em que o modelo pode ter se desviado para refinar seus comandos e receber respostas mais consistentes e precisas.

Comece com um comando geral que descreva o resultado desejado e observe os pensamentos iniciais do modelo sobre como ele determina a resposta. Se a resposta não for a esperada, ajude o modelo a gerar uma resposta melhor usando uma das seguintes técnicas de comando:

• Fornecer instruções detalhadas
• Forneça vários exemplos de pares de entrada e saída
• Forneça orientações sobre como a saída e as respostas devem ser formuladas e formatadas.
• Fornecer etapas específicas de verificação

Além de comandos, considere usar estas recomendações:

• Defina instruções do sistema, que são como um "preâmbulo" que você adiciona antes que o modelo seja exposto a outras instruções do comando ou do usuário final. Elas permitem orientar o comportamento do modelo com base nas suas necessidades e casos de uso específicos.

• Defina um orçamento de pensamento para configurar o quanto o modelo pode pensar. Se você definir um orçamento baixo, o modelo não vai "pensar demais" na resposta. Se você definir um orçamento alto, o modelo poderá pensar mais, se necessário. Definir um orçamento de pensamento também reserva mais do limite total de saída de tokens para a resposta real.

• (se estiver usando o Vertex AI Gemini API) Ative o monitoramento de IA no console Firebase para monitorar a latência das solicitações com o recurso de pensamento ativado. Os tokens de pensamento ainda não são mostrados nos painéis de monitoramento.

Controlar o orçamento de pensamento

Para controlar o quanto o modelo pode pensar para gerar uma resposta, especifique o número de tokens de orçamento de pensamento que ele pode usar.

Você pode definir manualmente o orçamento de pensamento em situações em que talvez precise de mais ou menos tokens do que o padrão. Confira orientações mais detalhadas sobre complexidade da tarefa e orçamentos sugeridos mais adiante nesta seção. Confira algumas orientações gerais:

• Defina um orçamento de pensamento baixo se a latência for importante ou para tarefas menos complexas
• Definir um orçamento de pensamento alto para tarefas mais complexas

Definir o orçamento de pensamento

Clique no seu provedor de Gemini API para conferir o conteúdo e o código específicos do provedor nesta página. API Gemini Developer API Gemini da Vertex AI

Observação: o suporte para definir um orçamento de pensamento está disponível para iOS+, Android e Web. Ele vai estar disponível para Flutter e Unity nas próximas versões.

Defina o orçamento de pensamento em um GenerationConfig como parte da criação da instância GenerativeModel. A configuração é mantida durante todo o ciclo de vida da instância. Se você quiser usar orçamentos de pensamento diferentes para solicitações diferentes, crie instâncias GenerativeModel configuradas com cada orçamento.

Saiba mais sobre os valores de orçamento de pensamento compatíveis nesta seção.

Swift

Defina o orçamento de pensamento em um GenerationConfig como parte da criação de uma instância GenerativeModel.

// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(thinkingBudget: 1024)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

Defina os valores dos parâmetros em um GenerationConfig como parte da criação de uma instância GenerativeModel.

// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      thinkingBudget = 1024
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_MODEL_NAME",
  generationConfig,
)

// ...

Java

Defina os valores dos parâmetros em um GenerationConfig como parte da criação de uma instância GenerativeModel.

// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setThinkingBudget(1024)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "<var>GEMINI_MODEL_NAME</var>",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

Defina os valores dos parâmetros em um GenerationConfig como parte da criação de uma instância GenerativeModel.

// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
const generationConfig = {
  thinkingConfig: {
    thinkingBudget: 1024
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_MODEL_NAME", generationConfig });

// ...

Dart

O suporte para definir um orçamento de pensamento para o Flutter será lançado na próxima versão.

Unity

O suporte para definir um orçamento de pensamento para o Unity será lançado na próxima versão.

Valores de limite de orçamento de pensamento aceitos

A tabela a seguir lista os valores de cota de pensamento que podem ser definidos para cada modelo ao configurar o thinkingBudget do modelo.

Modelo	Valor padrão	Intervalo disponível para o orçamento de pensamento		Valor para desativar o pensamento	Valor para ativar o pensamento dinâmico
						Valor mínimo	Valor máximo
Gemini 2.5 Pro	8,192	128	32,768	não pode ser desativado	-1
Gemini 2.5 Flash	8,192	1	24,576	0	-1
Gemini 2.5 Flash‑Lite	0 (o pensamento está desativado por padrão)	512	24,576	0 (ou não configure o orçamento de pensamento)	-1

Desativar raciocínio

Para algumas tarefas mais fáceis, a capacidade de raciocínio não é necessária, e a inferência tradicional é suficiente. Ou, se reduzir a latência for uma prioridade, talvez você não queira que o modelo leve mais tempo do que o necessário para gerar uma resposta.

Nessas situações, você pode desativar (ou desligar) o pensamento:

• Gemini 2.5 Pro: o pensamento não pode ser desativado
• Gemini 2.5 Flash: defina thinkingBudget como 0 tokens
• Gemini 2.5 Flash-Lite: o recurso de pensamento está desativado por padrão

Incentivar o pensamento dinâmico

Você pode deixar o modelo decidir quando e quanto ele pensa (chamado de pensamento dinâmico) definindo thinkingBudget como -1. O modelo pode usar quantos tokens achar adequado, até o valor máximo listado acima.

Complexidade da tarefa

• Tarefas fáceis: o pensamento pode ser desligado
  Solicitações simples em que não é necessário um raciocínio complexo, como recuperação ou classificação de fatos. Exemplos:

  • "Onde a DeepMind foi fundada?"
  • "Este e-mail está pedindo uma reunião ou apenas fornecendo informações?"

• Tarefas médias: orçamento padrão ou algum orçamento adicional de reflexão necessário
  Solicitações comuns que se beneficiam de um grau de processamento gradual ou compreensão mais profunda. Exemplos:

  • "Crie uma analogia entre a fotossíntese e o crescimento."
  • "Compare e contraste carros elétricos e híbridos."

• Tarefas difíceis: pode ser necessário um orçamento máximo de pensamento
  Desafios realmente complexos, como resolver problemas de matemática complexos ou tarefas de programação. Esses tipos de tarefas exigem que o modelo use todas as suas capacidades de raciocínio e planejamento, muitas vezes envolvendo várias etapas internas antes de fornecer uma resposta. Exemplos:

  • "Resolva o problema 1 da AIME 2025: encontre a soma de todas as bases inteiras b > 9 para as quais 17b é um divisor de 97b."
  • "Escreva um código Python para um aplicativo da Web que visualize dados do mercado de ações em tempo real, incluindo autenticação de usuários. Faça com que seja o mais eficiente possível."

Preços e contagem de tokens de pensamento

Os tokens de pensamento usam a mesma tabela de preços dos tokens de saída de texto.

Você pode receber o número total de tokens de pensamento do campo thoughtsTokenCount no atributo usageMetadata da resposta:

Swift

// ...

let response = try await model.generateContent("Why is the sky blue?")

if let usageMetadata = response.usageMetadata {
  print("Thoughts Token Count: \(usageMetadata.thoughtsTokenCount)")
}

Kotlin

// ...

val response = model.generateContent("Why is the sky blue?")

response.usageMetadata?.let { usageMetadata ->
    println("Thoughts Token Count: ${usageMetadata.thoughtsTokenCount}")
}

Java

// ...

ListenableFuture<GenerateContentResponse> response =
    model.generateContent("Why is the sky blue?");

Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String usageMetadata = result.getUsageMetadata();
        if (usageMetadata != null) {
            System.out.println("Thoughts Token Count: " +
                usageMetadata.getThoughtsTokenCount());
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web

// ...

const response = await model.generateContent("Why is the sky blue?");

if (response?.usageMetadata?.thoughtsTokenCount != null) {
    console.log(`Thoughts Token Count: ${response.usageMetadata.thoughtsTokenCount}`);
}

Dart

O suporte para contagem de tokens de pensamento para Flutter será lançado na próxima versão.

Unity

O suporte para contagem de tokens de pensamento no Unity será lançado na próxima versão.

Saiba mais sobre tokens no guia de contagem de tokens.