Wird generiert

Alle Gemini-Modelle verwenden einen internen „Denkprozess“, der ihre Fähigkeiten zur logischen Argumentation und zur Planung mehrerer Schritte erheblich verbessert. Dadurch sind sie sehr effektiv für komplexe Aufgaben wie Programmierung, fortgeschrittene Mathematik und Datenanalyse.

Thinking-Modelle bieten die folgenden Konfigurationen und Optionen:

• Den Umfang des Denkprozesses steuern
  Sie können Denkstufen konfigurieren, um zu steuern, wie viel „Denkarbeit“ ein Modell leisten kann. Diese Konfiguration ist besonders wichtig, wenn die Reduzierung von Latenz oder Kosten Priorität hat. Sehen Sie sich auch den Vergleich der Aufgabenschwierigkeiten an, um zu entscheiden, wie stark ein Modell seine Denkfähigkeit benötigt.

• Zusammenfassungen von Gedanken abrufen
  Sie können Zusammenfassungen von Gedanken aktivieren, die in die generierte Antwort aufgenommen werden sollen. Diese Zusammenfassungen sind synthetisierte Versionen der Rohgedanken des Modells und bieten Einblicke in den internen Denkprozess des Modells.

• Thought-Signaturen verarbeiten
  Die Firebase AI Logic SDKs verarbeiten Thought-Signaturen automatisch für Sie. So wird sichergestellt, dass das Modell Zugriff auf den Thought-Kontext aus vorherigen Runden hat, insbesondere bei der Verwendung von Funktionsaufrufen.

Lesen Sie sich die Best Practices und Hinweise zum Prompting für die Verwendung von Denkmodellen durch.

Beachten Sie Folgendes:

• Die Gemini 2.5-Modelle verwenden das Budget für Denkprozesse anstelle des Denkaufwands. Die universellen Gemini 3.x-Modelle und die neuesten Gemini Nano Banana-Modelle unterstützen das Thinking-Budget aus Gründen der Abwärtskompatibilität. Die Gemini 4.x-Modelle unterstützen jedoch kein Thinking-Budget und geben einen 400-Fehler zurück, wenn es festgelegt ist.
• Die Gemini-TTS-Modelle unterstützen die Denkfunktion nicht.
• Die Gemini Live API-Modelle unterstützen die Thinking-Funktion. Firebase AI Logic unterstützt jedoch noch nicht das Hinzufügen einer Thinking-Konfiguration für die Live API-Modelle. Diese Funktion wird jedoch bald verfügbar sein.

---

Best Practices und Prompt-Anleitung für die Verwendung von Denkmodellen

Wir empfehlen, den Prompt in Google AI Studio oder Agent  Studio zu testen, wo Sie den gesamten Denkprozess sehen können. Sie können Bereiche identifizieren, in denen das Modell möglicherweise vom richtigen Weg abgekommen ist, und Ihre Prompts verfeinern, um konsistentere und genauere Antworten zu erhalten.

Beginnen Sie mit einem allgemeinen Prompt, der das gewünschte Ergebnis beschreibt, und beobachten Sie die ersten Überlegungen des Modells dazu, wie es seine Antwort ermittelt. Wenn die Antwort nicht Ihren Erwartungen entspricht, können Sie dem Modell mit einer der folgenden Prompting-Techniken helfen, eine bessere Antwort zu generieren:

• Detaillierte Anleitung bereitstellen
• Mehrere Beispiele für Eingabe/Ausgabe-Paare angeben
• Anleitung dazu, wie die Ausgabe und die Antworten formuliert und formatiert werden sollen
• Geben Sie konkrete Schritte zur Bestätigung an.

Zusätzlich zu Prompts sollten Sie die folgenden Empfehlungen beachten:

• Systemanweisungen festlegen, die wie eine „Präambel“ sind, die Sie hinzufügen, bevor das Modell weitere Anweisungen aus dem Prompt oder vom Endnutzer erhält. Mit ihnen können Sie das Verhalten des Modells basierend auf Ihren spezifischen Anforderungen und Anwendungsfällen steuern.

• Legen Sie ein Denkniveau fest, um zu steuern, wie viel das Modell nachdenken kann. Wenn Sie es hoch einstellen, kann das Modell bei Bedarf mehr nachdenken. Wenn Sie einen niedrigeren Wert festlegen, wird das Modell seine Antwort nicht „überdenken“. Außerdem wird ein größerer Teil des gesamten Token-Ausgabelimits für die eigentliche Antwort reserviert, was die Latenz und die Kosten reduzieren kann.

• Aktivieren Sie das KI-Monitoring in der Firebase-Konsole, um die Anzahl der Thinking-Tokens und die Latenz Ihrer Anfragen mit aktiviertem Thinking zu überwachen. Wenn Sie Zusammenfassungen von Gedankengängen aktiviert haben, werden diese in der Console angezeigt. Dort können Sie die detaillierten Gedankengänge des Modells einsehen, um Ihre Prompts zu debuggen und zu optimieren.

---

Umfang der Denkprozesse steuern

Sie können Thinking-Stufen konfigurieren, um zu steuern, wie viel „Denkarbeit“ und Argumentation ein Modell leisten kann, bevor es eine Antwort zurückgibt. Diese Konfiguration ist besonders wichtig, wenn die Reduzierung der Latenz oder der Kosten Priorität hat.

Sehen Sie sich den Vergleich der Aufgabenschwierigkeiten an, um zu entscheiden, wie stark ein Modell seine Denkfähigkeit benötigt. Hier sind einige allgemeine Hinweise:

• Legen Sie einen niedrigeren Wert für Denkprozesse fest, wenn Sie weniger komplexe Aufgaben haben oder wenn Sie die Latenz oder die Kosten reduzieren möchten.
• Legen Sie für komplexere Aufgaben einen höheren Wert für Denkprozesse fest.

Denkaufwand

Wenn Sie festlegen möchten, wie viel Denkarbeit ein Modell für die Generierung seiner Antwort leisten darf, können Sie ein Thinking-Level für die Anzahl der Tokens für den Thinking-Modus angeben, die es verwenden darf.

Beachten Sie Folgendes:

• Die allgemeinen Modelle Gemini 3.x und höher sowie die neuesten Gemini Nano Banana-Modelle verwenden immer die Denkfunktion. Sie können das Reasoning für diese Modelle nicht deaktivieren oder ausschalten.
• Die Modelle Gemini 3.x und höher für die allgemeine Verwendung sowie die neuesten Gemini Nano Banana-Modelle verwenden immer dynamisches Denken. Das bedeutet, dass das Modell entscheidet, wann und wie viel es bis zum konfigurierten Betrag denkt.
• Die Gemini 2.5-Modelle verwenden das Budget für Denkprozesse anstelle des Denkaufwands. Die universellen Gemini 3.x-Modelle und die neuesten Gemini Nano Banana-Modelle unterstützen das Thinking-Budget aus Gründen der Abwärtskompatibilität. Die Gemini 4.x-Modelle unterstützen jedoch kein Thinking-Budget und geben einen 400-Fehler zurück, wenn es festgelegt ist.

Denkaufwand festlegen

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen. Gemini Developer API Agent Platform Gemini API

Legen Sie den Denkaufwand in einer GenerationConfig als Teil der Erstellung der GenerativeModel-Instanz fest. Die Konfiguration wird für die Lebensdauer der Instanz beibehalten. Wenn Sie für verschiedene Anfragen unterschiedliche Denkebenen verwenden möchten, erstellen Sie GenerativeModel-Instanzen, die mit den jeweiligen Ebenen konfiguriert sind.

Informationen zu den unterstützten Werten für den Denkaufwand finden Sie weiter unten in diesem Abschnitt.

Swift

Legen Sie den Denkaufwand in einer GenerationConfig beim Erstellen einer GenerativeModel-Instanz fest.

// ...

// 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

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

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

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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,
);

// ...

Einheit

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

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

// ...

Unterstützte Werte für den Denkaufwand

In der folgenden Tabelle sind die Werte für die Denkstufe aufgeführt, die Sie für jedes Modell festlegen können, indem Sie die thinkingLevel des Modells konfigurieren.

	MINIMAL	LOW	MEDIUM	HIGH
	Das Modell verwendet so wenige Tokens wie möglich; fast kein Thinking-Modus Aufgaben mit geringer Komplexität	Modell verwendet weniger Tokens; minimiert Latenz und Kosten Einfache Aufgaben und Aufgaben mit hohem Durchsatz	Das Modell verwendet einen ausgewogenen Ansatz Aufgaben mit mittlerer Komplexität	Das Modell verwendet Tokens bis zum maximalen Level Komplexe Prompts, die tiefgreifendes logisches Denken erfordern
Gemini 4 Argon gemini-4-argon	^1		(Standard)
Gemini 3.x Pro gemini-3.1-pro-preview				(Standard)
Gemini 3.x Flash gemini-3.8-flash gemini-3.7-flash gemini-3.6-flash gemini-3.5-flash	Nicht unterstützt von gemini-3.8-flash oder gemini-3.7-flash ^1		(Standard)
Gemini 3.x Flash‑Lite gemini-3.5-flash-lite gemini-3.1-flash-lite	(Standard)
Gemini Nano Banana 2.1 gemini-nano-banana-2.1			(Standard)
Gemini Nano Banana 2 gemini-3.1-flash-image				(Standard)
Gemini Nano Banana 2 Lite gemini-3.1-flash-lite-image	(Standard)
Gemini Nano Banana Pro gemini-3-pro-image				(Standard)

^{1 gemini-4-argon, gemini-3.8-flash und gemini-3.7-flash unterstützen die Denkstufe MINIMAL nicht. Wenn Sie den Denkaufwand auf MINIMAL setzen, schlägt die Anfrage mit einem 400-Fehler fehl.}

---

Thinking-Budgets (Gemini 2.5-Modelle)

Warnung: Gemini 2.5-Modelle wurden eingestellt. Die Agent Platform Gemini API (formerly Vertex AI) wird am 20. Oktober 2026 eingestellt. Weitere Informationen

Wenn Sie festlegen möchten, wie viel ein Gemini 2.5-Modell nachdenken darf, um eine Antwort zu generieren, können Sie ein Thinking-Budget für die Anzahl der Thinking-Tokens angeben, die es verwenden darf.

Hinweis: Für Gemini Live API-Modelle unterstützt Firebase AI Logic noch nicht das Hinzufügen einer Denkprozess-Konfiguration. Diese Funktion wird jedoch demnächst verfügbar sein.

Budget für Denkprozesse festlegen (Gemini 2.5-Modelle)

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen. Gemini Developer API Agent Platform Gemini API

Legen Sie das Thinking-Budget in einer GenerationConfig fest, wenn Sie die GenerativeModel-Instanz für ein Gemini 2.5-Modell erstellen. Die Konfiguration wird für die Lebensdauer der Instanz beibehalten. Wenn Sie für verschiedene Anfragen unterschiedliche Denkbudgets verwenden möchten, erstellen Sie GenerativeModel-Instanzen, die mit dem jeweiligen Budget konfiguriert sind.

Weitere Informationen zu den unterstützten Werten für das Denkbudget finden Sie weiter unten in diesem Abschnitt.

Swift

Legen Sie das Budget für Denkprozesse in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

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

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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,
);

// ...

Einheit

Legen Sie die Werte der Parameter in einer GenerationConfig fest, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

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

// ...

Unterstützte Werte für das Denkbudget (Gemini 2.5-Modelle)

In der folgenden Tabelle sind die Werte für das Denkbudget aufgeführt, die Sie für jedes Modell festlegen können, indem Sie thinkingBudget des Modells konfigurieren.

Modell	Standardwert	Verfügbarer Bereich für das Budget für Denkprozesse		Wert zum Deaktivieren des Denkprozesses für	Wert, um dynamisches Thinking zu aktivieren
						Minimalwert	Höchstwert
Gemini 2.5 Pro	8,192	128	32,768	kann nicht deaktiviert werden	-1
Gemini 2.5 Flash	8,192	1	24,576	0	-1
Gemini 2.5 Flash‑Lite	0 (Denken ist standardmäßig deaktiviert)	512	24,576	0 (oder gar kein Budget für Denkprozesse konfigurieren)	-1

Denken deaktivieren (Gemini 2.5-Modelle)

Bei einigen einfacheren Aufgaben ist die Denkfähigkeit nicht so wichtig und die herkömmliche Inferenz reicht aus. Wenn die Reduzierung von Latenz oder Kosten Priorität hat, möchten Sie möglicherweise nicht, dass das Modell mehr Zeit oder Kosten als nötig für die Generierung einer Antwort aufwendet.

In diesen Fällen können Sie die Denkprozesse für einige Modelle deaktivieren (oder ausschalten):

• Gemini 2.5 Pro: Das Denken kann nicht deaktiviert werden.
• Gemini 2.5 Flash: Deaktivieren Sie den Thinking-Modus, indem Sie thinkingBudget auf 0 Tokens setzen.
• Gemini 2.5 Flash‑Lite: Der Denkprozess ist standardmäßig deaktiviert. Legen Sie thinkingBudget also nicht explizit fest oder setzen Sie den Wert einfach auf 0.

Hinweis: Bei allen Gemini 3.x- und späteren Modellen kann das Reasoning nicht deaktiviert werden.

Dynamisches Denken aktivieren (Gemini 2.5-Modelle)

Mit dynamischem Thinking entscheidet das Modell, wann und wie viel es denkt (bis zu einem maximalen Thinking-Budget, wie unten beschrieben).

• Aktivieren Sie das dynamische Denken, indem Sie thinkingBudget auf -1 setzen.
• Wenn dynamisches Denken aktiviert ist, beträgt die maximale Anzahl von Thinking-Tokens immer 8.192 Tokens.

Beachten Sie, dass alle Gemini 3.x- und späteren Modelle immer dynamisches Denken verwenden.

---

Aufgabenkomplexität für alle Denkmodelle

• Einfache Aufgaben – Nachdenken ist nicht so wichtig
  Einfache Anfragen, bei denen kein komplexes logisches Denken erforderlich ist, z. B. das Abrufen von Fakten oder die Klassifizierung. Beispiele:

  • „Wo wurde DeepMind gegründet?“
  • „Wird in dieser E‑Mail um ein Treffen gebeten oder werden nur Informationen bereitgestellt?“

• Aufgaben mit mittlerem Schwierigkeitsgrad – wahrscheinlich ist etwas Nachdenken erforderlich
  Häufige Anfragen, die von einer schrittweisen Verarbeitung oder einem tieferen Verständnis profitieren. Beispiele:

  • „Erstelle eine Analogie zwischen der Photosynthese und dem Erwachsenwerden.“
  • „Vergleiche Elektroautos und Hybridautos und stelle die Unterschiede heraus.“

• Schwierige Aufgaben – maximales Nachdenken kann erforderlich sein
  Wirklich komplexe Herausforderungen, z. B. das Lösen komplexer mathematischer Probleme oder Programmieraufgaben. Bei diesen Aufgaben muss das Modell seine gesamten Logik- und Planungsfunktionen nutzen, was oft viele interne Schritte erfordert, bevor eine Antwort geliefert wird. Beispiele:

  • „Löse Aufgabe 1 der AIME 2025: Finde die Summe aller ganzzahligen Basen b > 9, für die 17b ein Teiler von 97b ist.“
  • "Schreibe Python-Code für eine Webanwendung, die Echtzeit-Börsendaten visualisiert, einschließlich Nutzerauthentifizierung. Mach es so effizient wie möglich.“

---

Zusammenfassungen der Gedanken

Zusammenfassungen der Überlegungen sind synthetisierte Versionen der Überlegungen des Modells und bieten Einblicke in den internen Prozess der Problemlösung des Modells.

Hier sind einige Gründe, warum Gedankenzusammenfassungen in Antworten enthalten sein sollten:

• Sie können die Zusammenfassung der Gedanken in der Benutzeroberfläche Ihrer App anzeigen oder für Ihre Nutzer zugänglich machen. Die Zusammenfassung der Gedanken wird als separater Teil in der Antwort zurückgegeben, damit Sie mehr Kontrolle darüber haben, wie sie in Ihrer Anwendung verwendet wird.

• Wenn Sie auch das KI-Monitoring in der Firebase-Konsole aktivieren, werden die Zusammenfassungen der Gedankengänge in der Konsole angezeigt. Dort können Sie die detaillierte Argumentation des Modells einsehen, um Ihre Prompts zu debuggen und zu verfeinern.

Hier sind einige wichtige Hinweise zu Gedankenzusammenfassungen:

• Zusammenfassungen von Denkprozessen werden nicht durch Budgets für Denkprozesse gesteuert. Budgets gelten nur für die Rohgedanken des Modells. Wenn das Denken jedoch deaktiviert ist, gibt das Modell keine Zusammenfassung des Denkprozesses zurück.

• Zusammenfassungen von Gedankengängen gelten als Teil der regulären Antwort des Modells mit generiertem Text und werden als Ausgabetokens gezählt.

Hinweis: Für Gemini Live API-Modelle unterstützt Firebase AI Logic die Aktivierung von Gedankenzusammenfassungen noch nicht. Diese Funktion ist demnächst verfügbar.

Zusammenfassungen von Denkprozessen aktivieren

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen. Gemini Developer API Agent Platform Gemini API

Sie können Gedankenzusammenfassungen aktivieren, indem Sie includeThoughts in Ihrer Modellkonfiguration auf „true“ setzen. Sie können dann auf die Zusammenfassung zugreifen, indem Sie das Feld thoughtSummary in der Antwort prüfen.

Hier ein Beispiel, wie Sie Gedankenzusammenfassungen mit der Antwort aktivieren und abrufen:

Swift

Aktivieren Sie Gedankenzusammenfassungen in der GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Aktivieren Sie Gedankenzusammenfassungen in der GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Aktivieren Sie Gedankenzusammenfassungen im GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Aktivieren Sie Gedankenzusammenfassungen in der GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

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

Aktivieren Sie Gedankenzusammenfassungen im GenerationConfig im Rahmen der Erstellung einer GenerativeModel-Instanz.

// ...

// 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}');
}

Einheit

Aktivieren Sie Gedankenzusammenfassungen in der GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

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

Antwort und Zusammenfassung der Überlegungen ansehen

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

Zusammenfassungen der Gedanken streamen

Sie können sich auch Zusammenfassungen der Gedankengänge ansehen, wenn Sie eine Antwort mit generateContentStream streamen. Dadurch werden während der Antwortgenerierung rollierende, inkrementelle Zusammenfassungen zurückgegeben.

Swift

Aktivieren Sie Gedankenzusammenfassungen in der GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Aktivieren Sie Gedankenzusammenfassungen im GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Aktivieren Sie Gedankenzusammenfassungen in der GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

// 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

Aktivieren Sie Gedankenzusammenfassungen in der GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

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

Aktivieren Sie Gedankenzusammenfassungen im GenerationConfig im Rahmen der Erstellung einer GenerativeModel-Instanz.

// ...

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

Einheit

Aktivieren Sie Gedankenzusammenfassungen in der GenerationConfig, wenn Sie eine GenerativeModel-Instanz erstellen.

// ...

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

---

Gedankensignaturen

Wichtig: Die Firebase AI Logic-SDKs verarbeiten Gedankensignaturen automatisch für Sie. Beachten Sie auch, dass Sie Gedankensignaturen nicht aktivieren oder deaktivieren können. Dies ist eine Einschränkung der zugrunde liegenden Gemini API-Anbieter. Gedankensignaturen werden als Eingabetokens betrachtet.

Wenn Sie Thinking in Multi-Turn-Interaktionen verwenden, hat das Modell keinen Zugriff auf den Thought-Kontext aus vorherigen Turns. Wenn Sie jedoch Funktionsaufrufe verwenden, können Sie Gedankensignaturen nutzen, um den Gedankenkontext über mehrere Turns hinweg beizubehalten. Gedankensignaturen sind verschlüsselte Darstellungen des internen Denkprozesses des Modells und sind verfügbar, wenn Sie Thinking und Funktionsaufrufe verwenden. Gedankensignaturen werden in folgenden Fällen generiert:

• Der Denkprozess ist aktiviert und Gedanken werden generiert.
• Die Anfrage enthält Funktionsdeklarationen.

Wenn Sie Gedankensignaturen nutzen möchten, verwenden Sie Funktionsaufrufe wie gewohnt. Die Firebase AI Logic-SDKs vereinfachen den Prozess, indem sie den Status verwalten und Thought-Signaturen automatisch für Sie verarbeiten. Die SDKs übergeben automatisch alle generierten Gedankensignaturen zwischen aufeinanderfolgenden sendMessage- oder sendMessageStream-Aufrufen in einer Chat-Sitzung.

---

Preise und Zählung von Thinking-Tokens

Für Thinking-Tokens gelten dieselben Preise wie für Textausgabe-Tokens. Wenn Sie Zusammenfassungen von Gedanken aktivieren, werden diese als Thinking-Tokens betrachtet und entsprechend berechnet.

Sie können das KI-Monitoring in der Firebase-Konsole aktivieren, um die Anzahl der Thinking-Tokens für Anfragen zu überwachen, bei denen das Thinking aktiviert ist.

Die Gesamtzahl der Thinking-Tokens finden Sie im Feld thoughtsTokenCount des Attributs usageMetadata der Antwort:

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

Einheit

// ...

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

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

Weitere Informationen zu Tokens finden Sie im Leitfaden zum Zählen von Tokens.