Starting November 2, 2026, Firebase App Check enforcement will be required to use Firebase AI Logic. Learn more.

Model updates:

Gemini 4 Argon is now available to use with Firebase AI Logic! Learn more.
Gemini 2.5 models are limited to projects that actively used them in the past. For the Agent Platform Gemini API, these models will shut down for all projects in October 2026. To avoid service disruptions, update to a newer model (like gemini-4-argon, gemini-3.8-flash, or gemini-nano-banana-2.1). Any stable Gemini Live API 2.5 models are not impacted. Learn more.

O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Pensando

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

Os modelos de raciocínio oferecem as seguintes configurações e opções:

Controlar a quantidade de raciocínio
É possível configurar os níveis de raciocínio para controlar o quanto um modelo pode "pensar". Essa configuração é particularmente importante se a redução da latência ou do custo for uma prioridade. Além disso, confira a comparação de dificuldades de tarefas para decidir o quanto um modelo pode precisar da capacidade de raciocínio.
Receber resumos de pensamentos
Você pode ativar os resumos de pensamentos para incluir na resposta gerada. Esses resumos são versões sintetizadas dos pensamentos brutos do modelo e oferecem insights sobre o processo de raciocínio interno dele.
Processar assinaturas de pensamento
Os SDKs do Firebase AI Logic processam automaticamente as assinaturas de pensamento para você, o que garante que o modelo tenha acesso ao contexto de pensamento de turnos anteriores, especificamente ao usar a chamada de função.

Confira as práticas recomendadas e as orientações de comandos para usar modelos de raciocínio.

Observações:

Os modelos Gemini 2.5 usam o orçamento de pensamento em vez do nível de pensamento. Os modelos Gemini 3.x de uso geral e os modelos Gemini Nano Banana mais recentes são compatíveis com o orçamento de raciocínio para compatibilidade com versões anteriores. No entanto, os modelos Gemini 4.x não são compatíveis com o orçamento de pensamento (e vão retornar um erro 400 se ele estiver definido).
Os modelos de TTS Gemini não são compatíveis com o recurso de raciocínio.
Os modelos Gemini Live API são compatíveis com o recurso de raciocínio. No entanto, o Firebase AI Logic ainda não permite adicionar uma configuração de pensamento para os modelos Live API, mas esse recurso será lançado em breve.

Práticas recomendadas e orientações de comandos para usar modelos de raciocínio

Recomendamos testar seu comando no Google AI Studio ou no Agent Studio, onde você pode conferir todo o processo de raciocínio. Você pode identificar as áreas em que o modelo pode ter se desviado para refinar os comandos e receber respostas mais consistentes e precisas.

Comece com um comando geral que descreva o resultado desejado e observe as considerações 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 de verificação específicas

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

Defina instruções do sistema, que são como um "preâmbulo" adicionado antes que o modelo seja exposto a outras instruções do comando ou do usuário final. Elas permitem que você oriente o comportamento do modelo com base nas suas necessidades e casos de uso específicos.
Defina um nível de raciocínio para controlar o quanto o modelo pode pensar. Se você definir um nível alto, o modelo poderá pensar mais, se necessário. Se você definir um valor mais baixo, o modelo não vai "pensar demais" na resposta e também vai reservar mais do limite total de saída de tokens para a resposta real, o que pode ajudar a reduzir a latência e o custo.
Ative o AI monitoring no console do Firebase para monitorar a contagem de tokens de raciocínio e a latência das suas solicitações com o raciocínio ativado. Se você tiver os resumos de pensamento ativados, eles vão aparecer no console, onde é possível inspecionar o raciocínio detalhado do modelo para ajudar você a depurar e refinar seus comandos.

Controlar a quantidade de pensamento

É possível configurar níveis de pensamento para controlar quanto "pensamento" e raciocínio um modelo pode fazer antes de retornar uma resposta. Essa configuração é particularmente importante se a redução da latência ou do custo for uma prioridade.

Confira a comparação de dificuldades de tarefas para decidir o quanto um modelo pode precisar da capacidade de raciocínio. Confira algumas orientações gerais:

Defina um valor de pensamento mais baixo para tarefas menos complexas ou se reduzir a latência ou o custo for uma prioridade para você.
Defina um valor de pensamento mais alto para tarefas mais complexas.

Níveis de raciocínio

Para controlar o quanto um modelo pode pensar para gerar uma resposta, especifique um nível de raciocínio para a quantidade de tokens de raciocínio que ele pode usar.

Observações:

Os modelos Gemini 3.x e posteriores de uso geral e os modelos Gemini Nano Banana mais recentes sempre usam o raciocínio. Não é possível desativar o pensamento para esses modelos.
Os modelos Gemini 3.x e posteriores de uso geral e os modelos Gemini Nano Banana mais recentes sempre usam o raciocínio dinâmico. Isso significa que o modelo decide quando e quanto ele pensa até o valor configurado.
Os modelos Gemini 2.5 usam o orçamento de pensamento em vez do nível de pensamento. Os modelos Gemini 3.x de uso geral e os modelos Gemini Nano Banana mais recentes são compatíveis com o orçamento de raciocínio para compatibilidade com versões anteriores. No entanto, os modelos Gemini 4.x não são compatíveis com o orçamento de pensamento (e vão retornar um erro 400 se ele estiver definido).

Definir o nível de raciocínio

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

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

Saiba mais sobre os valores aceitos para o nível de raciocínio mais adiante nesta seção.

Swift

Defina o nível de pensamento em um GenerationConfig como parte da criação de uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Use a thinking level value appropriate for your model (example value shown here).
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(thinkingLevel: .low)
)

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

// ...

Kotlin

Defina os valores dos parâmetros em um GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Use a thinking level value appropriate for your model (example value shown here).
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      thinkingLevel = ThinkingLevel.LOW
  }
}

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

// ...

Java

Defina os valores dos parâmetros em um GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Use a thinking level value appropriate for your model (example value shown here).
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setThinkingLevel(ThinkingLevel.LOW)
    .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 */ "GEMINI_3.x_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

Defina os valores dos parâmetros em um GenerationConfig ao criar uma instância GenerativeModel.


// ...

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

// Set the thinking configuration.
// Use a thinking level value appropriate for your model (example value shown here).
const generationConfig = {
  thinkingConfig: {
    thinkingLevel: ThinkingLevel.LOW
  }
};

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

// ...

Dart

Defina os valores dos parâmetros em um GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Use a thinking level value appropriate for your model (example value shown here).
final thinkingConfig = ThinkingConfig.withThinkingLevel(ThinkingLevel.low);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_3.x_MODEL_NAME',
  generationConfig: generationConfig,
);

// ...

Unity

Defina os valores dos parâmetros em um GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Use a thinking level value appropriate for your model (example value shown here).
var thinkingConfig = new ThinkingConfig(thinkingLevel: ThinkingLevel.Low);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance.
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_3.x_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

Valores aceitos para o nível de raciocínio

A tabela a seguir lista os valores de nível de pensamento que podem ser definidos para cada modelo configurando o thinkingLevel do modelo.

	`MINIMAL`	`LOW`	`MEDIUM`	`HIGH`
	O modelo usa o mínimo de tokens possível, quase sem raciocínio Tarefas de baixa complexidade	O modelo usa menos tokens, o que minimiza a latência e o custo Tarefas simples e de alta capacidade de processamento	O modelo usa uma abordagem equilibrada Tarefas de complexidade moderada	O modelo usa tokens até o nível máximo Comandos complexos que exigem raciocínio profundo
Gemini 4 Argon `gemini-4-argon`	¹		(padrão)
Gemini 3.x Pro `gemini-3.1-pro-preview`				(padrão)
Gemini 3.x Flash `gemini-3.8-flash` `gemini-3.7-flash` `gemini-3.6-flash` `gemini-3.5-flash`	não é compatível com `gemini-3.8-flash` ou `gemini-3.7-flash` ¹		(padrão)
Gemini 3.x Flash‑Lite `gemini-3.5-flash-lite` `gemini-3.1-flash-lite`	(padrão)
Gemini Nano Banana 2.1 `gemini-nano-banana-2.1`			(padrão)
Gemini Nano Banana 2 `gemini-3.1-flash-image`				(padrão)
Gemini Nano Banana 2 Lite `gemini-3.1-flash-lite-image`	(padrão)
Gemini Nano Banana Pro `gemini-3-pro-image`				(padrão)

^{1 gemini-4-argon, gemini-3.8-flash
e gemini-3.7-flash não são compatíveis com o
nível de raciocínio MINIMAL. Se você definir o nível de pensamento como
MINIMAL, a solicitação vai falhar com um erro 400.}

Orçamentos de raciocínio (modelos Gemini 2.5)

Para controlar o quanto um modelo Gemini 2.5 pode pensar para gerar a resposta, especifique um orçamento de pensamento para a quantidade de tokens de pensamento que ele pode usar.

Definir o orçamento de pensamento (modelos Gemini 2.5)

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

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

Saiba mais sobre os valores aceitos para o orçamento de pensamento mais adiante 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_2.5_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

Defina os valores dos parâmetros em um GenerationConfig ao criar 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_2.5_MODEL_NAME",
  generationConfig,
)

// ...

Java

Defina os valores dos parâmetros em um GenerationConfig ao criar 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 */ "GEMINI_2.5_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

Defina os valores dos parâmetros em um GenerationConfig ao criar 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_2.5_MODEL_NAME", generationConfig });

// ...

Dart

Defina os valores dos parâmetros em um GenerationConfig ao criar uma instância GenerativeModel.


// ...

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

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_2.5_MODEL_NAME',
  generationConfig: generationConfig,
);

// ...

Unity

Defina os valores dos parâmetros em um GenerationConfig ao criar uma instância GenerativeModel.


// ...

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

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance.
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_2.5_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

Valores de orçamento de pensamento aceitos (modelos Gemini 2.5)

A tabela a seguir lista os valores de orçamento de pensamento que podem ser definidos para cada modelo configurando 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
Modelo	Valor padrão			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 fica desativado por padrão)	`512`	`24,576`	`0` (ou não configure o orçamento de pensamento)	`-1`

Desativar o pensamento (modelos Gemini 2.5)

Para algumas tarefas mais simples, a capacidade de raciocínio não é tão necessária, e a inferência tradicional é suficiente. Além disso, se a redução da latência ou do custo for uma prioridade, talvez você não queira que o modelo leve mais tempo ou custe mais do que o necessário para gerar uma resposta.

Nessas situações, você pode desativar o pensamento em alguns modelos:

Gemini 2.5 Pro: o pensamento não pode ser desativado
Gemini 2.5 Flash: desativar o raciocínio definindo thinkingBudget como 0 tokens
Gemini 2.5 Flash‑Lite: o pensamento fica desativado por padrão (não defina thinkingBudget explicitamente ou defina como 0)

Em todos os modelos Gemini 3.x e mais recentes, o pensamento não pode ser desativado.

Ativar o pensamento dinâmico (modelos Gemini 2.5)

Com o pensamento dinâmico, o modelo decide quando e quanto pensa (até um orçamento máximo de pensamento, conforme descrito abaixo).

Ative o pensamento dinâmico definindo thinkingBudget como -1.
Quando o raciocínio dinâmico está ativado, o limite de tokens de raciocínio é sempre de 8.192 tokens.

Todos os modelos Gemini 3.x e mais recentes sempre usam o pensamento dinâmico.

Complexidade da tarefa para todos os modelos de raciocínio

Tarefas fáceis — o raciocínio não é tão necessário
Solicitações simples em que o raciocínio complexo não é necessário, como recuperação de fatos ou classificação. Exemplos:
- "Onde a DeepMind foi fundada?"
- "Este e-mail está pedindo uma reunião ou apenas fornecendo informações?"
Tarefas moderadas: é provável que seja necessário pensar um pouco
Solicitações comuns que se beneficiam de um grau de processamento detalhado ou compreensão mais profunda. Exemplos:
- "Crie uma analogia entre a fotossíntese e o crescimento."
- "Compare e contraste carros elétricos e carros híbridos."
Tarefas difíceis: pode ser necessário usar o nível máximo de raciocínio
Desafios realmente complexos, como resolver problemas de matemática complexos ou tarefas de programação. Esses tipos de tarefas exigem que o modelo use todos os recursos de raciocínio e planejamento, geralmente envolvendo muitas etapas internas antes de fornecer uma resposta. Exemplos:
- "Resolva o problema 1 do 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ário. Faça com que seja o mais eficiente possível."

Resumos de raciocínio

Os resumos de pensamentos são versões sintetizadas dos pensamentos brutos do modelo e oferecem insights sobre o processo de raciocínio interno dele.

Confira alguns motivos para incluir resumos de pensamento nas respostas:

Você pode mostrar o resumo do pensamento na interface do app ou disponibilizá-lo para os usuários. O resumo do pensamento é retornado como uma parte separada na resposta para que você tenha mais controle sobre como ele é usado no app.
Se você também ativar o AI monitoring no console do Firebase, os resumos de pensamento serão mostrados no console, onde você poderá inspecionar o raciocínio detalhado do modelo para ajudar a depurar e refinar seus comandos.

Confira algumas observações importantes sobre os resumos de pensamentos:

Os resumos de pensamento não são controlados por orçamentos de pensamento (os orçamentos se aplicam apenas aos pensamentos brutos do modelo). No entanto, se o pensamento estiver desativado, o modelo não vai retornar um resumo do pensamento.
Os resumos de pensamento são considerados parte da resposta de texto gerado regular do modelo e contam como tokens de saída.

Ativar resumos de raciocínio

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

Para ativar os resumos de pensamento, defina includeThoughts como verdadeiro na configuração do modelo. Em seguida, você pode acessar o resumo verificando o campo thoughtSummary da resposta.

Confira um exemplo que demonstra como ativar e recuperar resumos de pensamento com a resposta:

Swift

Ative os resumos de pensamento na GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(includeThoughts: true)
)

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

let response = try await model.generateContent("solve x^2 + 4x + 4 = 0")

// Handle the response that includes thought summaries.
if let thoughtSummary = response.thoughtSummary {
  print("Thought Summary: \(thoughtSummary)")
}
guard let text = response.text else {
  fatalError("No text in response.")
}
print("Answer: \(text)")

Kotlin

Ative os resumos de pensamento na GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      includeThoughts = true
  }
}

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

val response = model.generateContent("solve x^2 + 4x + 4 = 0")

// Handle the response that includes thought summaries.
response.thoughtSummary?.let {
    println("Thought Summary: $it")
}
response.text?.let {
    println("Answer: $it")
}

Java

Ative os resumos de pensamento na GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setIncludeThoughts(true)
    .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 */ "GEMINI_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// Handle the response that includes thought summaries.
ListenableFuture responseFuture = model.generateContent("solve x^2 + 4x + 4 = 0");
Futures.addCallback(responseFuture, new FutureCallback() {
    @Override
    public void onSuccess(GenerateContentResponse response) {
        if (response.getThoughtSummary() != null) {
            System.out.println("Thought Summary: " + response.getThoughtSummary());
        }
        if (response.getText() != null) {
            System.out.println("Answer: " + response.getText());
        }
    }

    @Override
    public void onFailure(Throwable t) {
        // Handle error
    }
}, MoreExecutors.directExecutor());

Web

Ative os resumos de pensamento na GenerationConfig ao criar uma instância GenerativeModel.


// ...

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

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
const generationConfig = {
  thinkingConfig: {
    includeThoughts: true
  }
};

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

const result = await model.generateContent("solve x^2 + 4x + 4 = 0");
const response = result.response;

// Handle the response that includes thought summaries.
if (response.thoughtSummary()) {
    console.log(`Thought Summary: ${response.thoughtSummary()}`);
}
const text = response.text();
console.log(`Answer: ${text}`);

Dart

Ative os resumos de pensamento no GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
final thinkingConfig = ThinkingConfig(includeThoughts: true);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  generationConfig: generationConfig,
);

final response = await model.generateContent([Content.text('solve x^2 + 4x + 4 = 0')]);

// Handle the response that includes thought summaries.
if (response.thoughtSummary != null) {
  print('Thought Summary: ${response.thoughtSummary}');
}
if (response.text != null) {
  print('Answer: ${response.text}');
}

Unity

Ative os resumos de pensamento na GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
var thinkingConfig = new ThinkingConfig(includeThoughts: true);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance.
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
);

var response = await model.GenerateContentAsync("solve x^2 + 4x + 4 = 0");

// Handle the response that includes thought summaries.
if (response.ThoughtSummary != null) {
    Debug.Log($"Thought Summary: {response.ThoughtSummary}");
}
if (response.Text != null) {
    Debug.Log($"Answer: {response.Text}");
}

Ver a resposta e o resumo do pensamento

# Example Response:
#     Okay, let's solve the quadratic equation x² + 4x + 4 = 0.
#     ...
#     **Answer:**
#     The solution to the equation x² + 4x + 4 = 0 is x = -2. This is a repeated root (or a root with multiplicity 2).

# Example Thought Summary:
#     **My Thought Process for Solving the Quadratic Equation**
#
#     Alright, let's break down this quadratic, x² + 4x + 4 = 0. First things first:
#     it's a quadratic; the x² term gives it away, and we know the general form is
#     ax² + bx + c = 0.
#
#     So, let's identify the coefficients: a = 1, b = 4, and c = 4. Now, what's the
#     most efficient path to the solution? My gut tells me to try factoring; it's
#     often the fastest route if it works. If that fails, I'll default to the quadratic
#     formula, which is foolproof. Completing the square? It's good for deriving the
#     formula or when factoring is difficult, but not usually my first choice for
#     direct solving, but it can't hurt to keep it as an option.
#
#     Factoring, then. I need to find two numbers that multiply to 'c' (4) and add
#     up to 'b' (4). Let's see... 1 and 4 don't work (add up to 5). 2 and 2? Bingo!
#     They multiply to 4 and add up to 4. This means I can rewrite the equation as
#     (x + 2)(x + 2) = 0, or more concisely, (x + 2)² = 0. Solving for x is now
#     trivial: x + 2 = 0, thus x = -2.
#
#     Okay, just to be absolutely certain, I'll run the quadratic formula just to
#     double-check. x = [-b ± √(b² - 4ac)] / 2a. Plugging in the values, x = [-4 ±
#     √(4² - 4 * 1 * 4)] / (2 * 1). That simplifies to x = [-4 ± √0] / 2. So, x =
#     -2 again - a repeated root. Nice.
#
#     Now, let's check via completing the square. Starting from the same equation,
#     (x² + 4x) = -4. Take half of the b-value (4/2 = 2), square it (2² = 4), and
#     add it to both sides, so x² + 4x + 4 = -4 + 4. Which simplifies into (x + 2)²
#     = 0. The square root on both sides gives us x + 2 = 0, therefore x = -2, as
#      expected.
#
#     Always, *always* confirm! Let's substitute x = -2 back into the original
#     equation: (-2)² + 4(-2) + 4 = 0. That's 4 - 8 + 4 = 0. It checks out.
#
#     Conclusion: the solution is x = -2. Confirmed.

Resumos de raciocínio de streaming

Também é possível conferir resumos de pensamentos se você optar por transmitir uma resposta usando generateContentStream. Isso vai retornar resumos contínuos e incrementais durante a geração da resposta.

Swift

Ative os resumos de pensamento na GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(includeThoughts: true)
)

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

let stream = try model.generateContentStream("solve x^2 + 4x + 4 = 0")

// Handle the streamed response that includes thought summaries.
var thoughts = ""
var answer = ""
for try await response in stream {
  if let thought = response.thoughtSummary {
    if thoughts.isEmpty {
      print("--- Thoughts Summary ---")
    }
    print(thought)
    thoughts += thought
  }

  if let text = response.text {
    if answer.isEmpty {
      print("--- Answer ---")
    }
    print(text)
    answer += text
  }
}

Kotlin

Ative os resumos de pensamento na GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      includeThoughts = true
  }
}

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

// Handle the streamed response that includes thought summaries.
var thoughts = ""
var answer = ""
model.generateContentStream("solve x^2 + 4x + 4 = 0").collect { response ->
    response.thoughtSummary?.let {
        if (thoughts.isEmpty()) {
            println("--- Thoughts Summary ---")
        }
        print(it)
        thoughts += it
    }
    response.text?.let {
        if (answer.isEmpty()) {
            println("--- Answer ---")
        }
        print(it)
        answer += it
    }
}

Java

Ative os resumos de pensamento na GenerationConfig como parte da criação de uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setIncludeThoughts(true)
    .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 */ "GEMINI_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// Streaming with Java is complex and depends on the async library used.
// This is a conceptual example using a reactive stream.
Flowable responseStream = model.generateContentStream("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
StringBuilder thoughts = new StringBuilder();
StringBuilder answer = new StringBuilder();

responseStream.subscribe(response -> {
    if (response.getThoughtSummary() != null) {
        if (thoughts.length() == 0) {
            System.out.println("--- Thoughts Summary ---");
        }
        System.out.print(response.getThoughtSummary());
        thoughts.append(response.getThoughtSummary());
    }
    if (response.getText() != null) {
        if (answer.length() == 0) {
            System.out.println("--- Answer ---");
        }
        System.out.print(response.getText());
        answer.append(response.getText());
    }
}, throwable -> {
    // Handle error
});

Web

Ative os resumos de pensamento na GenerationConfig como parte da criação de uma instância GenerativeModel.


// ...

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

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
const generationConfig = {
  thinkingConfig: {
    includeThoughts: true
  }
};

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

const result = await model.generateContentStream("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries.
let thoughts = "";
let answer = "";
for await (const chunk of result.stream) {
  if (chunk.thoughtSummary()) {
    if (thoughts === "") {
      console.log("--- Thoughts Summary ---");
    }
    // In Node.js, process.stdout.write(chunk.thoughtSummary()) could be used
    // to avoid extra newlines.
    console.log(chunk.thoughtSummary());
    thoughts += chunk.thoughtSummary();
  }

  const text = chunk.text();
  if (text) {
    if (answer === "") {
      console.log("--- Answer ---");
    }
    // In Node.js, process.stdout.write(text) could be used.
    console.log(text);
    answer += text;
  }
}

Dart

Ative os resumos de pensamento no GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
final thinkingConfig = ThinkingConfig(includeThoughts: true);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  generationConfig: generationConfig,
);

final responses = model.generateContentStream([Content.text('solve x^2 + 4x + 4 = 0')]);

// Handle the streamed response that includes thought summaries.
var thoughts = '';
var answer = '';
await for (final response in responses) {
  if (response.thoughtSummary != null) {
    if (thoughts.isEmpty) {
      print('--- Thoughts Summary ---');
    }
    thoughts += response.thoughtSummary!;
  }
  if (response.text != null) {
    if (answer.isEmpty) {
      print('--- Answer ---');
    }
    answer += response.text!;
  }
}

Unity

Ative os resumos de pensamento na GenerationConfig ao criar uma instância GenerativeModel.


// ...

// Set the thinking configuration.
// Optionally enable thought summaries in the generated response (default is false).
var thinkingConfig = new ThinkingConfig(includeThoughts: true);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance.
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
);

var stream = model.GenerateContentStreamAsync("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries.
var thoughts = "";
var answer = "";
await foreach (var response in stream)
{
    if (response.ThoughtSummary != null)
    {
        if (string.IsNullOrEmpty(thoughts))
        {
            Debug.Log("--- Thoughts Summary ---");
        }
        Debug.Log(response.ThoughtSummary);
        thoughts += response.ThoughtSummary;
    }
    if (response.Text != null)
    {
        if (string.IsNullOrEmpty(answer))
        {
            Debug.Log("--- Answer ---");
        }
        Debug.Log(response.Text);
        answer += response.Text;
    }
}

Assinaturas de raciocínio

Ao usar o raciocínio em interações de vários turnos, o modelo não tem acesso ao contexto de raciocínio de turnos anteriores. No entanto, se você estiver usando a chamada de função, poderá aproveitar as assinaturas de pensamento para manter o contexto do pensamento entre as interações. As assinaturas de pensamento são representações criptografadas do processo de pensamento interno do modelo e estão disponíveis ao usar o pensamento e a chamada de função. Especificamente, as assinaturas de pensamento são geradas quando:

O raciocínio está ativado e as ideias são geradas.
A solicitação inclui declarações de função.

Para aproveitar as assinaturas de pensamento, use a chamada de função normalmente. Os SDKs do Firebase AI Logic simplificam o processo gerenciando o estado e processando automaticamente as assinaturas de pensamento para você. Os SDKs transmitem automaticamente as assinaturas de pensamento geradas entre chamadas subsequentes de sendMessage ou sendMessageStream em uma sessão de Chat.

Preços e contagem de tokens de raciocínio

Os tokens de raciocínio usam os mesmos preços dos tokens de saída de texto. Se você ativar os resumos de pensamento, eles serão considerados tokens de raciocínio e terão o preço definido de acordo.

Ative o AI monitoring no console do Firebase para monitorar a contagem de tokens de raciocínio em solicitações com o raciocínio ativado.

É possível conferir o número total de tokens de raciocínio no 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

// ...

final response = await model.generateContent(
  Content.text("Why is the sky blue?"),
]);

if (response?.usageMetadata case final usageMetadata?) {
  print("Thoughts Token Count: ${usageMetadata.thoughtsTokenCount}");
}

Unity

// ...

var response = await model.GenerateContentAsync("Why is the sky blue?");

if (response.UsageMetadata != null)
{
    UnityEngine.Debug.Log($"Thoughts Token Count: {response.UsageMetadata?.ThoughtsTokenCount}");
}

Saiba mais sobre tokens no guia de contagem de tokens.

Pensando Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Práticas recomendadas e orientações de comandos para usar modelos de raciocínio

Controlar a quantidade de pensamento

Níveis de raciocínio

Definir o nível de raciocínio

Swift

Kotlin

Java

Web

Dart

Unity

Valores aceitos para o nível de raciocínio

Orçamentos de raciocínio (modelos Gemini 2.5)

Definir o orçamento de pensamento (modelos Gemini 2.5)

Swift

Kotlin

Java

Web

Dart

Unity

Valores de orçamento de pensamento aceitos (modelos Gemini 2.5)

Desativar o pensamento (modelos Gemini 2.5)

Ativar o pensamento dinâmico (modelos Gemini 2.5)

Complexidade da tarefa para todos os modelos de raciocínio

Resumos de raciocínio

Ativar resumos de raciocínio

Swift

Kotlin

Java

Web

Dart

Unity

Resumos de raciocínio de streaming

Swift

Kotlin

Java

Web

Dart

Unity

Assinaturas de raciocínio

Preços e contagem de tokens de raciocínio

Swift

Kotlin

Java

Web

Dart

Unity

Pensando