Gemini-Denken

Gemini-Modelle verwenden einen internen „Denkprozess“, der ihre Fähigkeiten zum Schlussfolgern und zur mehrstufigen Planung erheblich verbessert. Dadurch sind sie sehr effektiv für komplexe Aufgaben wie Programmieren, fortgeschrittene Mathematik und Datenanalyse.

In dieser Anleitung erfahren Sie, wie Sie die Denkfunktionen von Gemini mit der Gemini API verwenden.

Inhalte mit Denkprozess generieren

Das Initiieren einer Anfrage mit einem Denkmodell ähnelt jeder anderen Generierungsanfrage. Der Hauptunterschied besteht darin, eines der Modelle mit Unterstützung für Denkprozesse im model Feld anzugeben, wie im folgenden Beispiel zur Textgenerierung gezeigt:

Python

from google import genai

client = genai.Client()
prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example."
response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=prompt
)

print(response.text)

JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

async function main() {
  const prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example.";

  const response = await ai.models.generateContent({
    model: "gemini-3.8-flash",
    contents: prompt,
  });

  console.log(response.text);
}

main();

Ok

package main

import (
  "context"
  "fmt"
  "log"
  "os"
  "google.golang.org/genai"
)

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  prompt := "Explain the concept of Occam's Razor and provide a simple, everyday example."
  model := "gemini-3.8-flash"

  resp, _ := client.Models.GenerateContent(ctx, model, genai.Text(prompt), nil)

  fmt.Println(resp.Text())
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
 -H "x-goog-api-key: $GEMINI_API_KEY" \
 -H 'Content-Type: application/json' \
 -X POST \
 -d '{
   "contents": [
     {
       "parts": [
         {
           "text": "Explain the concept of Occam'\''s Razor and provide a simple, everyday example."
         }
       ]
     }
   ]
 }'
 ```

Zusammenfassungen der Gedanken

Zusammenfassungen der Gedanken sind zusammengefasste Versionen der Rohgedanken des Modells und bieten Einblicke in den internen Denkprozess des Modells. Beachten Sie, dass Denkaufwand und Budget für die Rohgedanken des Modells und nicht für Zusammenfassungen der Gedanken gelten.

Sie können Zusammenfassungen der Gedanken aktivieren, indem Sie includeThoughts in der Anfragekonfiguration auf true setzen. Anschließend können Sie auf die Zusammenfassung zugreifen, indem Sie die parts des Parameters response durchlaufen und den booleschen Wert thought prüfen.

Hier ein Beispiel, wie Sie Zusammenfassungen der Gedanken ohne Streaming aktivieren und abrufen. Dabei wird mit der Antwort eine einzelne, endgültige Zusammenfassung der Gedanken zurückgegeben:

Python

from google import genai
from google.genai import types

client = genai.Client()
prompt = "What is the sum of the first 50 prime numbers?"
response = client.models.generate_content(
  model="gemini-3.8-flash",
  contents=prompt,
  config=types.GenerateContentConfig(
    thinking_config=types.ThinkingConfig(
      include_thoughts=True
    )
  )
)

for part in response.candidates[0].content.parts:
  if not part.text:
    continue
  if part.thought:
    print("Thought summary:")
    print(part.text)
    print()
  else:
    print("Answer:")
    print(part.text)
    print()

JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-3.8-flash",
    contents: "What is the sum of the first 50 prime numbers?",
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  for (const part of response.candidates[0].content.parts) {
    if (!part.text) {
      continue;
    }
    else if (part.thought) {
      console.log("Thoughts summary:");
      console.log(part.text);
    }
    else {
      console.log("Answer:");
      console.log(part.text);
    }
  }
}

main();

Ok

package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  contents := genai.Text("What is the sum of the first 50 prime numbers?")
  model := "gemini-3.8-flash"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      IncludeThoughts: true,
    },
  })

  for _, part := range resp.Candidates[0].Content.Parts {
    if part.Text != "" {
      if part.Thought {
        fmt.Println("Thoughts Summary:")
        fmt.Println(part.Text)
      } else {
        fmt.Println("Answer:")
        fmt.Println(part.Text)
      }
    }
  }
}

Und hier ein Beispiel für die Verwendung von Denkprozessen mit Streaming, bei dem während der Generierung fortlaufende, inkrementelle Zusammenfassungen zurückgegeben werden:

Python

from google import genai
from google.genai import types

client = genai.Client()

prompt = """
Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue.
The person who lives in the red house owns a cat.
Bob does not live in the green house.
Carol owns a dog.
The green house is to the left of the red house.
Alice does not own a cat.
Who lives in each house, and what pet do they own?
"""

thoughts = ""
answer = ""

for chunk in client.models.generate_content_stream(
    model="gemini-3.8-flash",
    contents=prompt,
    config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
        include_thoughts=True
      )
    )
):
  for part in chunk.candidates[0].content.parts:
    if not part.text:
      continue
    elif part.thought:
      if not thoughts:
        print("Thoughts summary:")
      print(part.text)
      thoughts += part.text
    else:
      if not answer:
        print("Answer:")
      print(part.text)
      answer += part.text

JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

const prompt = `Alice, Bob, and Carol each live in a different house on the same
street: red, green, and blue. The person who lives in the red house owns a cat.
Bob does not live in the green house. Carol owns a dog. The green house is to
the left of the red house. Alice does not own a cat. Who lives in each house,
and what pet do they own?`;

let thoughts = "";
let answer = "";

async function main() {
  const response = await ai.models.generateContentStream({
    model: "gemini-3.8-flash",
    contents: prompt,
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  for await (const chunk of response) {
    for (const part of chunk.candidates[0].content.parts) {
      if (!part.text) {
        continue;
      } else if (part.thought) {
        if (!thoughts) {
          console.log("Thoughts summary:");
        }
        console.log(part.text);
        thoughts = thoughts + part.text;
      } else {
        if (!answer) {
          console.log("Answer:");
        }
        console.log(part.text);
        answer = answer + part.text;
      }
    }
  }
}

await main();

Ok

package main

import (
  "context"
  "fmt"
  "log"
  "os"
  "google.golang.org/genai"
)

const prompt = `
Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue.
The person who lives in the red house owns a cat.
Bob does not live in the green house.
Carol owns a dog.
The green house is to the left of the red house.
Alice does not own a cat.
Who lives in each house, and what pet do they own?
`

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  contents := genai.Text(prompt)
  model := "gemini-3.8-flash"

  resp := client.Models.GenerateContentStream(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      IncludeThoughts: true,
    },
  })

  for chunk := range resp {
    for _, part := range chunk.Candidates[0].Content.Parts {
      if len(part.Text) == 0 {
        continue
      }

      if part.Thought {
        fmt.Printf("Thought: %s\n", part.Text)
      } else {
        fmt.Printf("Answer: %s\n", part.Text)
      }
    }
  }
}

Denkprozess steuern

Gemini-Modelle führen standardmäßig dynamische Denkprozesse durch und passen den Aufwand für die Schlussfolgerungen automatisch an die Komplexität der Nutzeranfrage an. Wenn Sie jedoch bestimmte Latenzbeschränkungen haben oder das Modell komplexere Schlussfolgerungen als üblich ziehen soll, können Sie optional Parameter verwenden, um das Denkverhalten zu steuern.

Denkaufwand (Gemini 4 und Gemini 3)

Mit dem Parameter thinkingLevel, der für Gemini 4 erforderlich und für Gemini 3-Modelle empfohlen wird, können Sie das Verhalten beim Schlussfolgern steuern. Gemini 4 (gemini-4-argon) unterstützt low, medium (Standard) und high.

In der folgenden Tabelle sind die Einstellungen für thinkingLevel für jeden Modelltyp aufgeführt:

Denkaufwand Gemini 3.8 Flash Gemini 3.6 Flash Gemini 4 Argon Gemini 3.5 &3.1 Flash-Lite Gemini 3.1 Flash-Lite Image Gemini 3 Flash Gemini Robotics ER 2 Beschreibung
minimal Nicht unterstützt (Fehler) Unterstützt Nicht unterstützt (Fehler) Unterstützt (Standard) Unterstützt (Standard) Unterstützt Unterstützt Entspricht für die meisten Anfragen der Einstellung „Kein Denkprozess“. Beachten Sie, dass minimal nicht garantiert, dass der Denkprozess deaktiviert ist. Das Modell kann für komplexe Aufgaben sehr wenig Schlussfolgern.
low Unterstützt Unterstützt Unterstützt Unterstützt Nicht unterstützt Unterstützt Unterstützt Minimiert Latenz und Kosten.
medium Unterstützt (Standard) Unterstützt (Standard) Unterstützt (Standard) Unterstützt Nicht unterstützt Unterstützt Unterstützt Ausgewogener Denkprozess für die meisten Aufgaben.
high Unterstützt (dynamisch) Unterstützt (dynamisch) Unterstützt (dynamisch) Unterstützt (dynamisch) Unterstützt (dynamisch) Unterstützt (Standard, dynamisch) Unterstützt (Standard, dynamisch) Maximiert die Tiefe der Schlussfolgerungen. Es kann deutlich länger dauern, bis das Modell das erste Ausgabetoken (ohne Denkprozess) erreicht, aber die Ausgabe ist sorgfältiger durchdacht.

Das folgende Beispiel zeigt, wie Sie den Denkaufwand festlegen.

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="Provide a list of 3 famous physicists and their key contributions",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="low")
    ),
)

print(response.text)

JavaScript

import { GoogleGenAI, ThinkingLevel } from "@google/genai";

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-3.8-flash",
    contents: "Provide a list of 3 famous physicists and their key contributions",
    config: {
      thinkingConfig: {
        thinkingLevel: ThinkingLevel.LOW,
      },
    },
  });

  console.log(response.text);
}

main();

Ok

package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  thinkingLevelVal := "low"

  contents := genai.Text("Provide a list of 3 famous physicists and their key contributions")
  model := "gemini-3.8-flash"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      ThinkingLevel: &thinkingLevelVal,
    },
  })

fmt.Println(resp.Text())
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-X POST \
-d '{
  "contents": [
    {
      "parts": [
        {
          "text": "Provide a list of 3 famous physicists and their key contributions"
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
          "thinkingLevel": "low"
    }
  }
}'

Der Denkprozess kann für Gemini 4 Argon nicht deaktiviert werden. Gemini 3 Flash und Flash-Lite unterstützen ebenfalls keine vollständige Deaktivierung des Denkprozesses. Wenn Sie keinen Denkaufwand angeben, verwendet Gemini den Standard-Denkaufwand des Modells (z.B. "medium" für Gemini 4 Argon, Gemini 3.8 Flash und Gemini 3.6 Flash).

Modelle der Gemini 2.5-Reihe unterstützen thinkingLevel nicht. Verwenden Sie stattdessen thinkingBudget.

Tokenlimits und max_output_tokens

Mit dem max_output_tokens Generierungsparameter wird die maximale Anzahl von Tokens festgelegt, die eine Antwort generieren kann, einschließlich der Tokens für den Denkprozess.

Wenn dieser Parameter festgelegt ist, fungiert er als harte Begrenzung, die von der Infrastruktur erzwungen wird, ohne dass sich ändert, wie das Modell sein Budget für Denkprozesse (thinking_level) zuweist.

Wenn das Modell diese Grenze beim Schlussfolgern erreicht, wird die Generierung mit finish_reason: MAX_TOKENS beendet und eine gekürzte oder leere Ausgabe zurückgegeben (wobei alle generierten Tokens für den Denkprozess weiterhin in Rechnung gestellt werden). Wenn Sie Kosten oder Latenz reduzieren möchten, ohne Antworten zu kürzen, senken Sie stattdessen thinking_level (low oder medium), anstatt einen kleinen Wert für max_output_tokens festzulegen.

Beachten Sie für Gemini 4-Modelle (gemini-4-argon) die folgenden Kontext- und Ausgabelimits:

  • Gemeinsames Kontextfenster mit 1 Mio. Tokens: Eingabe-, Denk- und Ausgabetokens teilen sich ein gemeinsames Kontextfenster mit 1 Mio. Tokens (1,048,576 Tokens). Wenn Ihre Eingabetokens plus max_output_tokens 1.048.576 Tokens überschreiten, begrenzt die API das Ausgabelimit automatisch auf den verbleibenden Platz im Kontextfenster (1,048,576 minus Ihre Eingabetokens).
  • Ausgabelimits pro Anfrage (64.000 für Streaming / 32.000 für Nicht-Streaming) und lange Decodierung (bis zu 1 Mio. Tokens): Eine einzelne Streaminganfrage (streamGenerateContent) gibt bis zu 65,536 Tokens zurück und eine einzelne Nicht-Streaminganfrage (generateContent) bis zu 32,768 Tokens. Wenn Sie mehr als das Limit pro Anfrage generieren möchten (bis zu 1,048,576 Tokens minus Ihre Eingabe), legen Sie für max_output_tokens einen Wert über dem Limit fest. Die neuesten Google GenAI SDKs werden standardmäßig automatisch über Hops hinweg fortgesetzt (automatic_continuation=True). Alternativ können Sie eine Clientschleife mit dem continuation_token ausführen, das zurückgegeben wird, wenn ein Hop mit finish_reason: "CONTINUATION" beendet wird. Codebeispiele finden Sie unter Lange Decodierung.

Thinking-Budgets

Mit dem Parameter thinkingBudget, der mit der Gemini 2.5-Reihe eingeführt wurde, wird dem Modell die genaue Anzahl der Thinking-Tokens vorgegeben, die für die Schlussfolgerungen verwendet werden sollen.

Im Folgenden finden Sie Konfigurationsdetails für thinkingBudget für jeden Modelltyp. Sie können den Denkprozess deaktivieren, indem Sie thinkingBudget auf 0 setzen. Wenn Sie das thinkingBudget auf -1 setzen, wird der dynamische Denkprozess aktiviert. Das bedeutet, dass das Modell das Budget an die Komplexität der Anfrage anpasst.

Modell Standardeinstellung
(Thinking-Budget ist nicht festgelegt)		 Bereich Denkprozess deaktivieren Dynamischen Denkprozess aktivieren
2.5 Pro Dynamischer Denkprozess 128 bis 32768 Nicht zutreffend: Denkprozess kann nicht deaktiviert werden thinkingBudget = -1 (Standard)
2.5 Flash Dynamischer Denkprozess 0 bis 24576 thinkingBudget = 0 thinkingBudget = -1 (Standard)
2.5 Flash (Vorschau) Dynamischer Denkprozess 0 bis 24576 thinkingBudget = 0 thinkingBudget = -1 (Standard)
2.5 Flash Lite Modell denkt nicht 512 bis 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Lite (Vorschau) Modell denkt nicht 512 bis 24576 thinkingBudget = 0 thinkingBudget = -1
Robotics-ER 1.6 (Vorschau) Dynamischer Denkprozess 0 bis 24576 thinkingBudget = 0 thinkingBudget = -1 (Standard)
2.5 Flash Live Native Audio (Vorschau, 09/2025) Dynamischer Denkprozess 0 bis 24576 thinkingBudget = 0 thinkingBudget = -1 (Standard)

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Provide a list of 3 famous physicists and their key contributions",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_budget=1024)
        # Turn off thinking:
        # thinking_config=types.ThinkingConfig(thinking_budget=0)
        # Turn on dynamic thinking:
        # thinking_config=types.ThinkingConfig(thinking_budget=-1)
    ),
)

print(response.text)

JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: "Provide a list of 3 famous physicists and their key contributions",
    config: {
      thinkingConfig: {
        thinkingBudget: 1024,
        // Turn off thinking:
        // thinkingBudget: 0
        // Turn on dynamic thinking:
        // thinkingBudget: -1
      },
    },
  });

  console.log(response.text);
}

main();

Ok

package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  thinkingBudgetVal := int32(1024)

  contents := genai.Text("Provide a list of 3 famous physicists and their key contributions")
  model := "gemini-2.5-flash"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      ThinkingBudget: &thinkingBudgetVal,
      // Turn off thinking:
      // ThinkingBudget: int32(0),
      // Turn on dynamic thinking:
      // ThinkingBudget: int32(-1),
    },
  })

fmt.Println(resp.Text())
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-X POST \
-d '{
  "contents": [
    {
      "parts": [
        {
          "text": "Provide a list of 3 famous physicists and their key contributions"
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
          "thinkingBudget": 1024
    }
  }
}'

Je nach Prompt kann das Modell das Tokenbudget über- oder unterschreiten.

Gedankensignaturen

Die Gemini API ist zustandslos. Das Modell behandelt jede API-Anfrage unabhängig und hat keinen Zugriff auf den Denkkontext aus früheren Runden in Multi-Turn-Interaktionen.

Um den Denkkontext über mehrere Runden hinweg beizubehalten, gibt Gemini Gedankensignaturen zurück. Das sind verschlüsselte Darstellungen des internen Denkprozesses des Modells.

  • Gemini 2.5-Modelle geben Gedankensignaturen zurück, wenn der Denkprozess aktiviert ist und die Anfrage Funktionsaufrufe enthält, insbesondere Funktionsdeklarationen.
  • Gemini 4- und Gemini 3-Modelle können Gedankensignaturen für alle Arten von Teilen zurückgeben. Wir empfehlen, alle Signaturen so zurückzugeben, wie sie empfangen wurden. Für Funktionsaufrufsignaturen ist dies jedoch erforderlich. Weitere Informationen finden Sie auf der Seite Gedankensignaturen.

Weitere Nutzungslimits, die bei Funktionsaufrufen zu beachten sind:

  • Signaturen werden vom Modell innerhalb anderer Teile in der Antwort zurückgegeben, z. B. Funktionsaufrufe oder Textteile. Geben Sie die gesamte Antwort mit allen Teilen in nachfolgenden Runden an das Modell zurück.
  • Verketten Sie keine Teile mit Signaturen.
  • Führen Sie keinen Teil mit einer Signatur mit einem anderen Teil ohne Signatur zusammen.

Preise

Wenn die Thinking-Funktion aktiviert ist, setzt sich der Preis für die Antwort aus den Ausgabetokens und den Thinking-Tokens zusammen. Die Gesamtzahl der generierten Tokens für den Denkprozess finden Sie im Feld thoughtsTokenCount.

Python

# ...
print("Thoughts tokens:", response.usage_metadata.thoughts_token_count)
print("Output tokens:", response.usage_metadata.candidates_token_count)

JavaScript

// ...
console.log(`Thoughts tokens: ${response.usageMetadata.thoughtsTokenCount}`);
console.log(`Output tokens: ${response.usageMetadata.candidatesTokenCount}`);

Ok

// ...
fmt.Println("Thoughts tokens:", response.UsageMetadata.ThoughtsTokenCount)
fmt.Println("Output tokens:", response.UsageMetadata.CandidatesTokenCount)

Denkmodelle generieren vollständige Gedanken, um die Qualität der endgültigen Antwort zu verbessern, und geben dann Zusammenfassungen aus, um Einblicke in den Denkprozess zu geben. Die Preise basieren also auf den vollständigen Tokens für den Denkprozess, die das Modell zum Erstellen einer Zusammenfassung benötigt, obwohl nur die Zusammenfassung von der API ausgegeben wird.

Weitere Informationen zu Tokens finden Sie in der Anleitung zum Zählen von Tokens.

Best Practices

Dieser Abschnitt enthält einige Hinweise zur effizienten Verwendung von Denkmodellen. Wie immer erzielen Sie die besten Ergebnisse, wenn Sie unsere Anleitung zu Prompts und Best Practices befolgen.

Debugging und Steuerung

  • Schlussfolgerungen überprüfen: Wenn Sie nicht die erwartete Antwort von den Denkmodellen erhalten, kann es hilfreich sein, die Zusammenfassungen der Gedanken von Gemini sorgfältig zu analysieren. Sie können sehen, wie die Aufgabe aufgeschlüsselt und die Schlussfolgerung erreicht wurde, und diese Informationen verwenden, um die Ergebnisse zu korrigieren.

  • Anleitung für Schlussfolgerungen geben: Wenn Sie eine besonders lange Ausgabe erwarten, können Sie in Ihrem Prompt eine Anleitung geben, um den Aufwand für den Denkprozess des Modells zu begrenzen. So können Sie mehr Ausgabetokens für Ihre Antwort reservieren.

Aufgabenkomplexität

  • Einfache Aufgaben (Denkprozess kann deaktiviert werden) : Für einfache Anfragen, bei denen keine komplexen Schlussfolgerungen erforderlich sind, z. B. beim Abrufen von Fakten oder bei der Klassifizierung, ist kein Denkprozess erforderlich. Beispiele:
    • „Wo wurde DeepMind gegründet?“
    • „Wird in dieser E‑Mail um ein Meeting gebeten oder werden nur Informationen bereitgestellt?“
  • Mittelschwere Aufgaben (Standard/teilweise Denkprozess) : Bei vielen häufigen Anfragen ist eine schrittweise Verarbeitung oder ein tieferes Verständnis hilfreich. Gemini kann die Denkfunktion flexibel für Aufgaben wie die folgenden verwenden:
    • Analogie zwischen Photosynthese und Erwachsenwerden.
    • Vergleich und Gegenüberstellung von Elektroautos und Hybridautos.
  • Schwierige Aufgaben (maximale Denkfähigkeit) : Für wirklich komplexe Aufgaben wie das Lösen komplexer mathematischer Probleme oder Programmieraufgaben empfehlen wir, ein hohes Budget für den Denkprozess festzulegen. Bei diesen Aufgaben muss das Modell seine gesamten Fähigkeiten zum Schlussfolgern und Planen einsetzen. Oft sind viele interne Schritte erforderlich, bevor eine Antwort gegeben wird. Beispiele:
    • Lösen Sie Aufgabe 1 in AIME 2025: Ermitteln Sie die Summe aller ganzzahligen Basen b > 9 für die 17b ein Teiler von 97b ist.
    • Schreiben Sie Python-Code für eine Webanwendung, die Echtzeit-Börsendaten visualisiert, einschließlich der Nutzerauthentifizierung. Machen Sie sie so effizient wie möglich.

Unterstützte Modelle, Tools und Funktionen

Denkfunktionen werden für alle Modelle der Reihen 4, 3 und 2.5 unterstützt. Alle Modellfunktionen finden Sie auf der Seite Modellübersicht.

Denkmodelle funktionieren mit allen Tools und Funktionen von Gemini. So können die Modelle mit externen Systemen interagieren, Code ausführen oder auf Echtzeitinformationen zugreifen und die Ergebnisse in ihre Schlussfolgerungen und die endgültige Antwort einbeziehen.

Beispiele für die Verwendung von Tools mit Denkmodellen finden Sie im [Thinking-Kochbuch][Colab].

Nächste Schritte

[Colab]: https://colab.sandbox.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started_thinking.ipynb