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.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Modèles avec réflexion

Tous les modèles Gemini utilisent un "processus de réflexion" interne qui améliore considérablement leurs capacités de raisonnement et de planification en plusieurs étapes, ce qui les rend 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 des niveaux de réflexion pour contrôler 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 sa capacité de réflexion.
Obtenir des résumés de réflexion
Vous pouvez activer les résumés de réflexion à inclure dans la réponse générée. Ces résumés sont des versions synthétisées des pensées brutes du modèle et offrent des insights 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 de prompting pour utiliser les modèles de réflexion.

Remarques :

Les modèles Gemini 2.5 utilisent un budget de réflexion au lieu d'un niveau de réflexion. Les modèles Gemini 3.x à usage général et les derniers modèles Gemini Nano Banana sont compatibles avec le budget de réflexion pour assurer la rétrocompatibilité. Toutefois, les modèles Gemini 4.x ne sont pas compatibles avec le budget de réflexion (et renverront une erreur 400 s'il est défini).
Les modèles TTS Gemini ne sont pas compatibles avec la fonctionnalité de réflexion.
Les modèles Gemini Live API sont compatibles avec la fonctionnalité de raisonnement. Toutefois, Firebase AI Logic ne permet pas encore d'ajouter une configuration de réflexion pour les modèles Live API, mais cette fonctionnalité sera bientôt disponible.

Bonnes pratiques et conseils de rédaction de requêtes pour utiliser les modèles à raisonnement

Nous vous recommandons de tester votre requête dans Google AI Studio ou Agent Studio, où vous pouvez voir l'intégralité du processus de réflexion. Vous pouvez identifier les domaines dans lesquels le modèle s'est peut-être égaré 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 dont il détermine sa réponse. Si la réponse n'est pas celle attendue, aidez le modèle à générer une meilleure réponse en utilisant l'une des techniques de prompting suivantes :

Fournir des instructions détaillées
Fournissez plusieurs exemples de paires d'entrée-sortie.
Fournissez des instructions sur la formulation et le formatage des résultats et des réponses.
Fournir des étapes de validation spécifiques

En plus du prompting, tenez compte des 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 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 raisonnement pour contrôler la quantité de raisonnement que le modèle peut effectuer. Si vous le définissez sur une valeur élevée, le modèle peut raisonner davantage, si nécessaire. Si vous définissez une valeur inférieure, le modèle ne "réfléchira pas trop" à sa réponse. De plus, il réservera une plus grande partie de la limite totale de jetons de sortie pour la réponse réelle, 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 raisonnement et la latence de vos requêtes pour lesquelles le raisonnement est activé. Si vous avez activé les résumés de réflexion, ils s'afficheront dans la console, où vous pourrez inspecter le raisonnement détaillé du modèle pour vous aider à déboguer et à affiner vos prompts.

Contrôler le niveau de réflexion

Vous pouvez configurer des niveaux de réflexion pour contrôler la quantité 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é.

Assurez-vous de consulter la comparaison des difficultés des tâches pour déterminer dans quelle mesure un modèle peut avoir besoin de sa capacité 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.

Niveaux de raisonnement

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

Remarques :

Les modèles Gemini 3.x et ultérieurs à usage général, ainsi que les derniers modèles Gemini Nano Banana, utilisent toujours le raisonnement. Vous ne pouvez pas désactiver la réflexion pour ces modèles.
Les modèles Gemini 3.x et ultérieurs à usage général et les derniers modèles Gemini Nano Banana utilisent toujours la pensée dynamique. Cela signifie que le modèle décide quand et combien il pense, jusqu'à la quantité configurée.
Les modèles Gemini 2.5 utilisent un budget de réflexion au lieu d'un niveau de réflexion. Les modèles Gemini 3.x à usage général et les derniers modèles Gemini Nano Banana sont compatibles avec le budget de réflexion pour assurer la rétrocompatibilité. Toutefois, les modèles Gemini 4.x ne sont pas compatibles avec le budget de réflexion (et renverront une erreur 400 s'il est défini).

Définir le niveau de raisonnement

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

Définissez le niveau de réflexion dans un GenerationConfig lors de la création de l'instance GenerativeModel. 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.

Découvrez les valeurs acceptées pour le niveau de réflexion plus loin dans 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.x_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

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

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

Définissez les valeurs des paramètres dans un GenerationConfig lors de la création d'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.x_MODEL_NAME", generationConfig });

// ...

Dart

Définissez les valeurs des paramètres dans un fichier 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.x_MODEL_NAME',
  generationConfig: generationConfig,
);

// ...

Unity

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).
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
);

// ...

Valeurs de niveau de réflexion acceptées

Le tableau suivant liste 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, presque sans raisonnement. Tâches à faible complexité	Le modèle utilise moins de jetons, ce qui réduit 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 4 Argon `gemini-4-argon`	¹		(par défaut)
Gemini 3.x Pro `gemini-3.1-pro-preview`				(par défaut)
Gemini 3.x Flash `gemini-3.8-flash` `gemini-3.7-flash` `gemini-3.6-flash` `gemini-3.5-flash`	non compatible avec `gemini-3.8-flash` ou `gemini-3.7-flash` ¹		(par défaut)
Gemini 3.x Flash‑Lite `gemini-3.5-flash-lite` `gemini-3.1-flash-lite`	(par défaut)
Gemini Nano Banana 2.1 `gemini-nano-banana-2.1`			(par défaut)
Gemini Nano Banana 2 `gemini-3.1-flash-image`				(par défaut)
Gemini Nano Banana 2 Lite `gemini-3.1-flash-lite-image`	(par défaut)
Gemini Nano Banana Pro `gemini-3-pro-image`				(par défaut)

^{1 gemini-4-argon, gemini-3.8-flash et gemini-3.7-flash ne sont pas compatibles avec le niveau de réflexion MINIMAL. Si vous définissez le niveau de réflexion sur MINIMAL, la requête échouera avec une erreur 400.}

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

Pour contrôler le niveau 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 (modèles Gemini 2.5)

Cliquez sur votre fournisseur Gemini API pour afficher le contenu et le code spécifiques au 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.

Découvrez 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 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).
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 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).
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 lors de la création d'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 fichier 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',
  generationConfig: generationConfig,
);

// ...

Unity

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).
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 de budget de réflexion acceptées (modèles Gemini 2.5)

Le tableau suivant liste les valeurs de budget de réflexion que vous pouvez définir pour chaque modèle en configurant le paramètre 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 pour activer le raisonnement dynamique
Modèle	Valeur par défaut			Valeur pour désactiver la réflexion	Valeur pour activer le raisonnement dynamique	Valeur minimale	Valeur maximale
Gemini 2.5 Pro	`8,192`	`128`	`32,768`	cannot be disabled	`-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 de budget de réflexion)	`-1`

Désactiver la réflexion (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 ce cas, 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 le raisonnement en définissant thinkingBudget sur 0 jetons.
Gemini 2.5 Flash‑Lite : la réflexion est désactivée par défaut (ne définissez donc pas thinkingBudget explicitement ou définissez-le simplement sur 0).

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

Activer la réflexion dynamique (modèles Gemini 2.5)

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

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

Notez que tous les modèles Gemini 3.x et ultérieurs utilisent toujours la réflexion dynamique.

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

Tâches faciles : la réflexion n'est pas aussi nécessaire
Requêtes simples ne nécessitant pas de raisonnement complexe, comme la récupération de faits ou la classification. Exemples :
- "Où DeepMind a-t-il été fondé ?"
- "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 certain degré de 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 les voitures électriques et les voitures hybrides."
Tâches difficiles : un raisonnement maximal peut être nécessaire
Des défis vraiment complexes, comme la résolution de problèmes mathématiques complexes ou des tâches de codage. Ces types de tâches nécessitent que le modèle utilise 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. Rendez-le aussi efficace que possible."

Résumés des réflexions

Les résumés des étapes du raisonnement sont des versions synthétisées des étapes du raisonnement brutes du modèle et fournissent des insights sur le processus de raisonnement interne du modèle.

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

Vous pouvez afficher le résumé de la pensée dans l'interface utilisateur de votre application ou le rendre accessible à vos utilisateurs. Le résumé de la pensée est renvoyé en tant que partie distincte de la réponse, ce qui vous permet de mieux contrôler son utilisation dans votre application.
Si vous activez également l'AI Monitoring dans la console Firebase, les résumés de pensée s'affichent dans la console, où vous pouvez inspecter le raisonnement détaillé du modèle pour vous aider à déboguer et à affiner vos prompts.

Voici quelques points importants à retenir concernant les résumés de pensée :

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 renvoie pas de résumé de réflexion.
Les résumés de réflexion sont considérés comme faisant partie de la réponse textuelle générée par le modèle et sont comptabilisés comme des jetons de sortie.

Activer les résumés de raisonnement

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

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

Voici un exemple montrant comment activer et récupérer des résumés de réflexion 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([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

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 les résumés des réflexions

Vous pouvez également afficher des résumés de réflexion si vous choisissez de diffuser une réponse en streaming à l'aide de generateContentStream. Cela renverra des résumés incrémentiels et continus 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([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

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 réflexion

Lorsque vous utilisez le raisonnement dans des interactions multitours, le modèle n'a pas accès au contexte de raisonnement des tours précédents. Toutefois, si vous utilisez l'appel de fonction, vous pouvez exploiter les signatures de pensée pour conserver le contexte de pensée d'un tour à l'autre. 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 le raisonnement et l'appel de fonction. Plus précisément, les signatures de pensée sont générées lorsque :

Le raisonnement est activé et des pensées sont générées.
La requête inclut des déclarations de fonction.

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 gérant automatiquement les signatures de pensée pour vous. Les SDK transmettent automatiquement toutes les signatures de réflexion générées entre les appels sendMessage ou sendMessageStream suivants dans une session Chat.

Tarification et comptage des jetons de raisonnement

Les jetons de raisonnement sont soumis aux 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 raisonnement et sont facturés en conséquence.

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

Vous pouvez obtenir le nombre total de jetons de raisonnement à partir du champ thoughtsTokenCount de 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.

Bonnes pratiques et conseils de rédaction de requêtes pour utiliser les modèles à raisonnement

Contrôler le niveau de réflexion

Niveaux de raisonnement

Définir le niveau de raisonnement

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 (modèles Gemini 2.5)

Swift

Kotlin

Java

Web

Dart

Unity

Valeurs de budget de réflexion acceptées (modèles Gemini 2.5)

Désactiver la réflexion (modèles Gemini 2.5)

Activer la réflexion dynamique (modèles Gemini 2.5)

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

Résumés des réflexions

Activer les résumés de raisonnement

Swift

Kotlin

Java

Web

Dart

Unity

Diffuser les résumés des réflexions

Swift

Kotlin

Java

Web

Dart

Unity

Signatures de réflexion

Tarification et comptage des jetons de raisonnement

Swift

Kotlin

Java

Web

Dart

Unity

Modèles avec réflexion