Cette page a été traduite par l'API Cloud Translation.

Modèles avec réflexion

Les modèles 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, 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 :

Budget de réflexion : vous pouvez configurer la quantité de "réflexion" qu'un modèle peut effectuer à l'aide d'un budget de réflexion. 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.
Résumés de la réflexion : vous pouvez activer les résumés de la 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.
Signatures de pensée : les SDK Firebase AI Logic gèrent automatiquement les signatures de pensée pour vous. Cela garantit que le modèle a accès au contexte de pensée des tours précédents, en particulier lorsque vous utilisez 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 pour n'importe quel autre modèle Gemini (initialisez le fournisseur Gemini API de votre choix, créez une instance GenerativeModel, etc.). Ces modèles peuvent être utilisés pour des tâches de génération de texte ou de code, comme la génération de résultats structurés ou l'analyse d'entrées multimodales (comme des images, des vidéos, de l'audio ou des PDF). Vous pouvez même utiliser des modèles de réflexion lorsque vous diffusez la sortie.

Modèles compatibles avec cette fonctionnalité

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

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 une requête générale 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 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 budget de réflexion pour configurer le niveau de réflexion du modèle. Si vous définissez un budget faible, le modèle ne "suranalysera" pas sa réponse. Si vous définissez un budget élevé, le modèle peut réfléchir davantage si nécessaire. Définir un budget de réflexion permet également de réserver une plus grande partie de la limite totale de jetons de sortie pour la réponse proprement dite.
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 le budget de réflexion

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

Vous pouvez définir manuellement le budget de réflexion dans les situations où vous avez besoin de plus ou moins de jetons que le budget de réflexion par défaut. Vous trouverez des conseils plus détaillés sur la complexité des tâches et les budgets suggérés plus loin dans cette section. Voici quelques conseils généraux :

Définissez un budget de réflexion faible si la latence est importante ou pour les tâches moins complexes.
Définissez un budget de réflexion élevé pour les tâches plus complexes.

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. 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 de budget de réflexion acceptées 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_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_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_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_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(thinkingBudget: 1024);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_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_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

Valeurs de budget de réflexion acceptées

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 certaines tâches plus simples, la capacité de réflexion n'est pas nécessaire et l'inférence traditionnelle est suffisante. Si la réduction de la latence est une priorité, vous ne voudrez peut-être pas que le modèle prenne plus de temps que nécessaire pour générer une réponse.

Dans ces situations, vous pouvez désactiver la réflexion :

Gemini 2.5 Pro : la réflexion ne peut pas être désactivée
Gemini 2.5 Flash : définissez thinkingBudget sur 0 jetons.
Gemini 2.5 Flash‑Lite : la réflexion est désactivée par défaut.

Activer la pensée dynamique

Vous pouvez laisser le modèle décider quand et combien il réfléchit (appelé réflexion dynamique) en définissant thinkingBudget sur -1. Le modèle peut utiliser autant de jetons qu'il le juge approprié, jusqu'à la valeur maximale de jetons indiquée ci-dessus.

Complexité de la tâche

Tâches faciles : la réflexion peut être désactivée
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 moyennes : budget par défaut ou budget de réflexion supplémentaire nécessaire
Demandes courantes qui bénéficient d'un traitement étape par étape 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 : un budget de réflexion maximal peut être nécessaire
Défis vraiment complexes, comme la résolution de problèmes mathématiques complexes ou de tâches de codage. 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."

Inclure des résumés de la réflexion dans les réponses

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 réflexion dans les réponses :

Vous pouvez afficher le résumé des réflexions dans l'interface utilisateur 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, les résumés de réflexion s'affichent dans la console, où vous pouvez inspecter 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.

Afficher les résumés de pensée

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

Comprendre les 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 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 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 comptabilisation des 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 la surveillance de l'IA 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 le budget de réflexion

Définir le budget de réflexion

Swift

Kotlin

Java

Web

Dart

Unity

Valeurs de budget de réflexion acceptées

Désactiver la réflexion

Activer la pensée dynamique

Complexité de la tâche

Inclure des résumés de la réflexion dans les réponses

Activer les résumés de réflexion

Swift

Kotlin

Java

Web

Dart

Unity

Afficher les résumés de pensée

Swift

Kotlin

Java

Web

Dart

Unity

Comprendre les signatures de pensée

Tarification et comptabilisation des jetons de réflexion

Swift

Kotlin

Java

Web

Dart

Unity

Modèles avec réflexion