Gemini 3 Pro & Flash, Gemini 3 Pro Image (nano banana pro), and the latest Gemini Live API native audio models are now available to use with Firebase AI Logic on all platforms!

Gemini 2.0 Flash and Flash-Lite models will be retired on March 3, 2026. To avoid service disruption, update to a newer model like gemini-2.5-flash-lite. Learn more.

Modèles avec réflexion

Les modèles Gemini 3 et Gemini 2.5 peuvent utiliser un "processus de réflexion" interne qui améliore considérablement leurs capacités de raisonnement et de planification en plusieurs étapes. Ils sont donc très efficaces pour les tâches complexes telles que le codage, les mathématiques avancées et l'analyse de données.

Les modèles de réflexion proposent les configurations et options suivantes :

Contrôler la quantité de réflexion
Vous pouvez configurer la quantité de "réflexion" qu'un modèle peut effectuer. Cette configuration est particulièrement importante si la réduction de la latence ou des coûts est une priorité. Consultez également la comparaison des difficultés des tâches pour déterminer dans quelle mesure un modèle peut avoir besoin de ses capacités de réflexion.

Vous pouvez contrôler cette configuration avec les niveaux de réflexion(modèles Gemini 3 et ultérieurs) ou les budgets de réflexion(modèles Gemini 2.5).
Obtenir des résumés de réflexion
Vous pouvez activer les résumés de réflexion pour les inclure dans la réponse générée. Ces résumés sont des versions synthétisées des réflexions brutes du modèle et offrent des informations sur son processus de raisonnement interne.
Gérer les signatures de pensée
Les SDK Firebase AI Logic gèrent automatiquement les signatures de pensée pour vous, ce qui garantit que le modèle a accès au contexte de pensée des tours précédents, en particulier lors de l'utilisation de l'appel de fonction.

Assurez-vous de consulter les bonnes pratiques et les conseils pour les requêtes concernant l'utilisation des modèles de réflexion.

Utiliser un modèle de réflexion

Utilisez un modèle de réflexion comme vous le feriez avec n'importe quel autre modèle Gemini.

Pour exploiter pleinement les modèles de réflexion, consultez les bonnes pratiques et les conseils de requête pour utiliser les modèles de réflexion plus loin sur cette page.

Modèles compatibles avec cette fonctionnalité

Seuls les modèles Gemini 3 et Gemini 2.5 sont compatibles avec cette fonctionnalité.

gemini-3-pro-preview
gemini-3-pro-image-preview (alias "nano banana pro")
gemini-3-flash-preview
gemini-2.5-pro
gemini-2.5-flash
gemini-2.5-flash-lite

Bonnes pratiques et conseils pour rédiger des requêtes pour les modèles à raisonnement

Nous vous recommandons de tester votre requête dans Google AI Studio ou Vertex AI Studio, où vous pourrez consulter l'intégralité du processus de réflexion. Vous pouvez identifier les domaines dans lesquels le modèle a pu s'égarer afin d'affiner vos requêtes pour obtenir des réponses plus cohérentes et précises.

Commencez par un prompt général décrivant le résultat souhaité, puis observez la réflexion initiale du modèle sur la manière de déterminer sa réponse. Si la réponse ne correspond pas à vos attentes, aidez le modèle à générer une meilleure réponse en utilisant l'une des techniques de requête suivantes :

Fournir des instructions détaillées
Fournissez plusieurs exemples de paires d'entrée-sortie.
Donne des conseils sur la façon de formuler et de mettre en forme les résultats et les réponses.
Fournir des étapes de validation spécifiques

En plus des requêtes, pensez à utiliser les recommandations suivantes :

Définissez des instructions système, qui sont comme un "préambule" que vous ajoutez avant que le modèle ne soit exposé à d'autres instructions provenant de la requête ou de l'utilisateur final. Elles vous permettent d'orienter le comportement du modèle en fonction de vos besoins et de vos cas d'utilisation spécifiques.
Définissez un niveau de réflexion (ou un budget de réflexion pour les modèles Gemini 2.5) pour contrôler la capacité de réflexion du modèle. Si vous le définissez sur un niveau élevé, le modèle peut réfléchir davantage si nécessaire. Si vous la définissez sur une valeur inférieure, le modèle ne "suranalysera" pas sa réponse. Il réservera également une plus grande partie de la limite totale de jetons de sortie pour la réponse proprement dite, ce qui peut contribuer à réduire la latence et les coûts.
Activez AI Monitoring dans la console Firebase pour surveiller le nombre de jetons de réflexion et la latence de vos requêtes pour lesquelles la réflexion est activée. Si vous avez activé les résumés de réflexion, ils s'affichent dans la console, où vous pouvez examiner le raisonnement détaillé du modèle pour vous aider à déboguer et à affiner vos requêtes.

Contrôler la quantité de réflexion

Vous pouvez configurer le temps de "réflexion" et de raisonnement qu'un modèle peut effectuer avant de renvoyer une réponse. Cette configuration est particulièrement importante si la réduction de la latence ou des coûts est une priorité.

Veillez à consulter la comparaison des difficultés des tâches pour déterminer dans quelle mesure un modèle peut avoir besoin de ses capacités de réflexion. Voici quelques conseils généraux :

Définissez une valeur de réflexion plus faible pour les tâches moins complexes ou si la réduction de la latence ou des coûts est une priorité pour vous.
Définissez une valeur de réflexion plus élevée pour les tâches plus complexes.

Vous pouvez contrôler cette configuration avec les niveaux de réflexion(modèles Gemini 3 et ultérieurs) ou les budgets de réflexion(modèles Gemini 2.5).

Niveaux de réflexion (modèles Gemini 3)

Pour contrôler le niveau de réflexion d'un modèle Gemini 3 lors de la génération de sa réponse, vous pouvez spécifier un niveau de réflexion pour le nombre de jetons de réflexion qu'il est autorisé à utiliser.

Définir le niveau de réflexion

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques à ce fournisseur sur cette page.

Définissez le niveau de réflexion dans un GenerationConfig lors de la création de l'instance GenerativeModel pour un modèle Gemini 3. La configuration est conservée pendant toute la durée de vie de l'instance. Si vous souhaitez utiliser différents niveaux de réflexion pour différentes requêtes, créez des instances GenerativeModel configurées avec chaque niveau.

Vous trouverez plus d'informations sur les valeurs acceptées pour le niveau de réflexion dans la suite de cette section.

Swift

Définissez le niveau de réflexion dans un GenerationConfig lors de la création d'une instance 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_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

Définissez les valeurs des paramètres dans un GenerationConfig lorsque vous créez une instance 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_MODEL_NAME",
  generationConfig,
)

// ...

Java

Définissez les valeurs des paramètres dans un GenerationConfig lorsque vous créez une instance 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_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

Définissez les valeurs des paramètres dans un GenerationConfig lorsque vous créez une instance 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_MODEL_NAME", generationConfig });

// ...

Dart

Définissez les valeurs des paramètres dans un GenerationConfig lors de la création d'une instance 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_MODEL_NAME',
  config: generationConfig,
);

// ...

Unity

Définissez les valeurs des paramètres dans un GenerationConfig lorsque vous créez une instance 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_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

Valeurs de niveau de réflexion acceptées

Le tableau suivant répertorie les valeurs de niveau de réflexion que vous pouvez définir pour chaque modèle en configurant le thinkingLevel du modèle.

	`MINIMAL`	`LOW`	`MEDIUM`	`HIGH`
	Le modèle utilise le moins de jetons possible, avec une réflexion quasi nulle. Tâches de faible complexité	Le modèle utilise moins de jetons, ce qui minimise la latence et les coûts. Tâches simples et tâches à haut débit	Le modèle utilise une approche équilibrée Tâches de complexité modérée	Le modèle utilise des jetons jusqu'à son niveau maximal. Requêtes complexes nécessitant un raisonnement approfondi
Gemini 3 Pro				(par défaut)
Gemini 3 Pro Image ("nano banana pro")				(par défaut)
Gemini 3 Flash				(par défaut)

Budgets de réflexion (modèles Gemini 2.5)

Pour contrôler la quantité de réflexion qu'un modèle Gemini 2.5 peut effectuer pour générer sa réponse, vous pouvez spécifier un budget de réflexion pour le nombre de jetons de réflexion qu'il est autorisé à utiliser.

Définir le budget de réflexion

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques à ce fournisseur sur cette page.

Définissez le budget de réflexion dans un GenerationConfig lors de la création de l'instance GenerativeModel pour un modèle Gemini 2.5. La configuration est conservée pendant toute la durée de vie de l'instance. Si vous souhaitez utiliser des budgets de réflexion différents pour différentes requêtes, créez des instances GenerativeModel configurées avec chaque budget.

Vous trouverez plus d'informations sur les valeurs acceptées pour le budget de réflexion plus loin dans cette section.

Swift

Définissez le budget de réflexion dans un GenerationConfig lors de la création d'une instance 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

Définissez les valeurs des paramètres dans un GenerationConfig lorsque vous créez une instance 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

Définissez les valeurs des paramètres dans un GenerationConfig lorsque vous créez une instance 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

Définissez les valeurs des paramètres dans un GenerationConfig lorsque vous créez une instance 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

Définissez les valeurs des paramètres dans un GenerationConfig lors de la création d'une instance 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',
  config: generationConfig,
);

// ...

Unity

Définissez les valeurs des paramètres dans un GenerationConfig lorsque vous créez une instance 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
);

// ...

Valeurs acceptées pour le budget de réflexion

Le tableau suivant répertorie les valeurs de budget de réflexion que vous pouvez définir pour chaque modèle en configurant le thinkingBudget du modèle.

Modèle	Valeur par défaut	Plage disponible pour le budget de réflexion		Valeur pour désactiver la réflexion	Valeur permettant d' activer la pensée dynamique
Modèle	Valeur par défaut			Valeur pour désactiver la réflexion	Valeur permettant d' activer la pensée dynamique	Valeur minimale	Valeur maximale
Gemini 2.5 Pro	`8,192`	`128`	`32,768`	ne peut pas être désactivé	`-1`
Gemini 2.5 Flash	`8,192`	`1`	`24,576`	`0`	`-1`
Gemini 2.5 Flash‑Lite	`0` (la réflexion est désactivée par défaut)	`512`	`24,576`	`0` (ou ne configurez pas du tout le budget de réflexion)	`-1`

Désactiver la réflexion pour les modèles Gemini 2.5

Pour certaines tâches plus simples, la capacité de réflexion n'est pas aussi nécessaire et l'inférence traditionnelle est suffisante. De plus, si la réduction de la latence ou des coûts est une priorité, vous ne souhaitez peut-être pas que le modèle prenne plus de temps ou coûte plus cher que nécessaire pour générer une réponse.

Dans ces situations, vous pouvez désactiver la réflexion pour certains modèles :

Gemini 2.5 Pro : la réflexion ne peut pas être désactivée
Gemini 2.5 Flash : désactivez la réflexion en définissant thinkingBudget sur 0 jetons.
Gemini 2.5 Flash‑Lite : la réflexion est désactivée par défaut (n'indiquez donc pas explicitement thinkingBudget ou définissez-la simplement sur 0)

Notez que pour tous les modèles Gemini 3, la réflexion ne peut pas être désactivée.

Activer la pensée dynamique pour les modèles Gemini 2.5

Avec la réflexion dynamique, le modèle décide quand et combien il réfléchit (jusqu'à un budget de réflexion maximal, comme décrit ci-dessous).

Activez la pensée dynamique en définissant thinkingBudget sur -1.
Lorsque la réflexion dynamique est activée, le nombre maximal de jetons de réflexion est toujours de 8 192.

Notez que tous les modèles Gemini 3 utilisent toujours la pensée dynamique.

Complexité des tâches pour tous les modèles à raisonnement

Tâches faciles : la réflexion n'est pas nécessaire
Demandes simples ne nécessitant pas de raisonnement complexe, comme la récupération ou la classification d'informations. Exemples :
- "Où DeepMind a-t-elle été fondée ?"
- "Cet e-mail demande-t-il une réunion ou fournit-il simplement des informations ?"
Tâches modérées : une certaine réflexion est probablement nécessaire
Requêtes courantes qui bénéficient d'un traitement par étapes ou d'une compréhension plus approfondie. Exemples :
- "Crée une analogie entre la photosynthèse et le fait de grandir."
- "Compare et oppose les voitures électriques et les voitures hybrides."
Tâches difficiles : une réflexion maximale peut être nécessaire
Défis vraiment complexes, comme résoudre des problèmes de mathématiques complexes ou des tâches de programmation. Ces types de tâches exigent du modèle qu'il mobilise toutes ses capacités de raisonnement et de planification, ce qui implique souvent de nombreuses étapes internes avant de fournir une réponse. Exemples :
- "Résous le problème 1 de l'AIME 2025 : trouve la somme de toutes les bases entières b > 9 pour lesquelles 17b est un diviseur de 97b."
- "Écris du code Python pour une application Web qui visualise les données boursières en temps réel, y compris l'authentification des utilisateurs. Rends-le aussi efficace que possible."

Résumés des pensées

Les résumés de réflexion sont des versions synthétisées des réflexions brutes du modèle et offrent des informations sur son processus de raisonnement interne.

Voici quelques raisons d'inclure des résumés de la réflexion dans les réponses :

Vous pouvez afficher le résumé des réflexions dans l'UI de votre application ou le rendre accessible à vos utilisateurs. Le résumé de la pensée est renvoyé dans une partie distincte de la réponse afin que vous puissiez mieux contrôler son utilisation dans votre application.
Si vous activez également le monitoring de l'IA dans la console Firebase, des résumés de réflexion s'affichent dans la console. Vous pouvez y examiner le raisonnement détaillé du modèle pour vous aider à déboguer et à affiner vos requêtes.

Voici quelques points clés à retenir concernant les résumés de réflexion :

Les résumés de réflexion ne sont pas contrôlés par les budgets de réflexion (les budgets ne s'appliquent qu'aux réflexions brutes du modèle). Toutefois, si la réflexion est désactivée, le modèle ne renverra pas de résumé de la réflexion.
Les résumés de réflexion sont considérés comme faisant partie de la réponse en texte généré habituelle du modèle et sont comptabilisés comme des jetons de sortie.

Activer les résumés de réflexion

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques à ce fournisseur sur cette page.

Vous pouvez activer les résumés de réflexion en définissant includeThoughts sur "true" dans la configuration de votre modèle. Vous pouvez ensuite accéder au récapitulatif en consultant le champ thoughtSummary de la réponse.

Voici un exemple montrant comment activer et récupérer les résumés de pensée avec la réponse :

Swift

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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('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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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}");
}

Afficher la réponse et le résumé de la réflexion

# 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.

Diffuser des résumés de pensées

Vous pouvez également afficher des résumés de la réflexion si vous choisissez de diffuser une réponse à l'aide de generateContentStream. Cela renverra des résumés cumulatifs et incrémentaux pendant la génération de la réponse.

Swift

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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('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

Activez les résumés de réflexion dans GenerationConfig lors de la création d'une instance 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;
    }
}

Signatures de pensée

Lorsque vous utilisez la réflexion dans des interactions multitours, le modèle n'a pas accès au contexte de réflexion des tours précédents. Toutefois, si vous utilisez les appels de fonction, vous pouvez profiter des signatures de pensée pour conserver le contexte de pensée tout au long des tours de conversation. Les signatures de réflexion sont des représentations chiffrées du processus de réflexion interne du modèle. Elles sont disponibles lorsque vous utilisez la réflexion et les appels de fonction. Plus précisément, les signatures de pensée sont générées dans les cas suivants :

La réflexion est activée et des pensées sont générées.
La requête inclut des déclarations de fonctions.

Pour profiter des signatures de pensée, utilisez l'appel de fonction comme d'habitude. Les SDK Firebase AI Logic simplifient le processus en gérant l'état et en traitant automatiquement les signatures de pensée pour vous. Les SDK transmettent automatiquement les signatures de pensée générées entre les appels sendMessage ou sendMessageStream suivants dans une session Chat.

Tarification et jetons de réflexion

Les jetons de réflexion utilisent les mêmes tarifs que les jetons de sortie de texte. Si vous activez les résumés de réflexion, ils sont considérés comme des jetons de réflexion et sont facturés en conséquence.

Vous pouvez activer AI Monitoring dans la console Firebase pour surveiller le nombre de jetons de réflexion pour les requêtes pour lesquelles la réflexion est activée.

Vous pouvez obtenir le nombre total de jetons de réflexion à partir du champ thoughtsTokenCount dans l'attribut usageMetadata de la réponse :

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}");
}

Pour en savoir plus sur les jetons, consultez le guide sur le décompte des jetons.

Modèles avec réflexion Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Utiliser un modèle de réflexion

Modèles compatibles avec cette fonctionnalité

Bonnes pratiques et conseils pour rédiger des requêtes pour les modèles à raisonnement

Contrôler la quantité de réflexion

Niveaux de réflexion (modèles Gemini 3)

Définir le niveau de réflexion

Swift

Kotlin

Java

Web

Dart

Unity

Valeurs de niveau de réflexion acceptées

Budgets de réflexion (modèles Gemini 2.5)

Définir le budget de réflexion

Swift

Kotlin

Java

Web

Dart

Unity

Valeurs acceptées pour le budget de réflexion

Désactiver la réflexion pour les modèles Gemini 2.5

Activer la pensée dynamique pour les modèles Gemini 2.5

Complexité des tâches pour tous les modèles à raisonnement

Résumés des pensées

Activer les résumés de réflexion

Swift

Kotlin

Java

Web

Dart

Unity

Diffuser des résumés de pensées

Swift

Kotlin

Java

Web

Dart

Unity

Signatures de pensée

Tarification et jetons de réflexion

Swift

Kotlin

Java

Web

Dart

Unity

Modèles avec réflexion