Gemini-Denken

Die Modelle der Gemini 3- und 2.5-Serie nutzen einen internen „Denkprozess“, der ihre Fähigkeiten zum logischen Schlussfolgern und zur mehrstufigen Planung erheblich verbessert. Dadurch eignen sie sich hervorragend für komplexe Aufgaben wie Programmieren, fortgeschrittene Mathematik und Datenanalyse.

In diesem Leitfaden erfahren Sie, wie Sie die Denkfunktionen von Gemini mit der Gemini API nutzen können.

Inhalte mit „Thinking“ generieren

Eine Anfrage mit einem Denkmodell zu starten, ähnelt jeder anderen Anfrage zur Inhaltserstellung. Der Hauptunterschied besteht darin, dass Sie im Feld model eines der Modelle mit Unterstützung für das Denken angeben, wie im folgenden Beispiel für die 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-2.5-pro",
    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-2.5-pro",
    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-2.5-pro"

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

  fmt.Println(resp.Text())
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro: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 von Gedanken

Zusammenfassungen der Gedanken sind synthetisierte Versionen der Rohgedanken des Modells und bieten Einblicke in den internen Denkprozess des Modells. Die Denkebenen und Budgets gelten für die Rohgedanken des Modells und nicht für Zusammenfassungen von Gedanken.

Sie können Zusammenfassungen von Gedanken aktivieren, indem Sie includeThoughts in Ihrer Anfragekonfiguration auf true setzen. Sie können dann auf die Zusammenfassung zugreifen, indem Sie den Parameter response durchlaufen und den booleschen Wert thought prüfen.parts

Hier ist ein Beispiel dafür, wie Sie Zusammenfassungen von Gedanken ohne Streaming aktivieren und abrufen können. Dabei wird mit der Antwort eine einzelne, endgültige Zusammenfassung von 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-2.5-pro",
  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-2.5-pro",
    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-2.5-pro"
  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)
      }
    }
  }
}

Hier ist ein Beispiel für die Verwendung von „thinking with 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-2.5-pro",
    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-2.5-pro",
    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-2.5-pro"

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

Kontrolliertes Denken

Gemini-Modelle nutzen standardmäßig dynamisches Denken und passen den Aufwand für die Argumentation automatisch an die Komplexität der Nutzeranfrage an. Wenn Sie jedoch bestimmte Latenzbeschränkungen haben oder das Modell tiefergehende Überlegungen anstellen soll als üblich, können Sie optional Parameter verwenden, um das Denkverhalten zu steuern.

Denkaufwand (Gemini 3)

Mit dem Parameter thinkingLevel, der für Gemini 3-Modelle und höher empfohlen wird, können Sie das Verhalten beim Schlussfolgern steuern. Sie können die Denkebene für Gemini 3 Pro auf "low" oder "high" und für Gemini 3 Flash auf "minimal", "low", "medium" und "high" festlegen.

Denkebenen von Gemini 3 Pro und Flash:

  • low: Minimiert Latenz und Kosten. Am besten geeignet für einfache Anweisungen, Chat oder Anwendungen mit hohem Durchsatz
  • high (Standard, dynamisch): Maximiert die Tiefe der Argumentation. Es kann deutlich länger dauern, bis das Modell das erste Token ausgibt, aber die Ausgabe ist sorgfältiger durchdacht.

Gemini 3 Flash-Denkebenen

Zusätzlich zu den oben genannten Ebenen unterstützt Gemini 3 Flash auch die folgenden Denkebenen, die derzeit nicht von Gemini 3 Pro unterstützt werden:

  • medium: Ausgewogenes Denken für die meisten Aufgaben.

  • minimal: Entspricht für die meisten Anfragen der Einstellung „Kein Denken“. Das Modell denkt bei komplexen Programmieraufgaben möglicherweise nur sehr wenig nach. Minimiert die Latenz für Chat- oder Anwendungen mit hohem Durchsatz.

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-flash-preview",
    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 } from "@google/genai";

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-3-flash-preview",
    contents: "Provide a list of 3 famous physicists and their key contributions",
    config: {
      thinkingConfig: {
        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-flash-preview"
  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-flash-preview: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"
    }
  }
}'

Sie können die Denkfunktion für Gemini 3 Pro nicht deaktivieren. Gemini 3 Flash unterstützt auch nicht die vollständige Deaktivierung des Denkprozesses, aber die Einstellung minimal bedeutet, dass das Modell wahrscheinlich nicht denken wird (obwohl es das immer noch tun kann). Wenn Sie keine Denkebene angeben, verwendet Gemini die dynamische Standarddenkebene der Gemini 3-Modelle, "high".

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

Budget für Denkprozesse

Der Parameter thinkingBudget, der mit der Gemini 2.5-Reihe eingeführt wurde, gibt dem Modell die genaue Anzahl der Tokens vor, die es für Schlussfolgerungen verwenden darf.

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

Modell Standardeinstellung
(Budget für Denkprozesse ist nicht festgelegt)		 Bereich Denkprozess deaktivieren Dynamisches Denken aktivieren
2.5 Pro Dynamisches Denken: Das Modell entscheidet, wann und wie viel es denkt. 128 nach 32768 Nicht zutreffend: Das Denken kann nicht deaktiviert werden. thinkingBudget = -1
2.5 Flash Dynamisches Denken: Das Modell entscheidet, wann und wie viel es denkt. 0 nach 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash-Vorschau Dynamisches Denken: Das Modell entscheidet, wann und wie viel es denkt. 0 nach 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Lite Modell denkt nicht 512 nach 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Lite (Vorschau) Modell denkt nicht 512 nach 24576 thinkingBudget = 0 thinkingBudget = -1
Robotics-ER 1.5 (Vorschau) Dynamisches Denken: Das Modell entscheidet, wann und wie viel es denkt. 0 nach 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Live Native Audio Preview (09-2025) Dynamisches Denken: Das Modell entscheidet, wann und wie viel es denkt. 0 nach 24576 thinkingBudget = 0 thinkingBudget = -1

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 Token-Budget über- oder unterschreiten.

Gedankensignaturen

Die Gemini API ist zustandslos. Das Modell behandelt jede API-Anfrage unabhängig und hat keinen Zugriff auf den Kontext von vorherigen Runden in Multi-Turn-Interaktionen.

Damit der Kontext des Denkprozesses bei Interaktionen mit mehreren Zügen beibehalten werden kann, gibt Gemini Denkprozess-Signaturen zurück. Das sind verschlüsselte Darstellungen des internen Denkprozesses des Modells.

  • Gemini 2.5-Modelle geben Denkprozess-Signaturen zurück, wenn die Denkprozess-Funktion aktiviert ist und die Anfrage Funktionsaufrufe, insbesondere Funktionsdeklarationen, enthält.

  • Gemini 3-Modelle können für alle Arten von Teilen Gedanken-Signaturen zurückgeben. Wir empfehlen, alle Signaturen immer so zurückzugeben, wie sie empfangen wurden. Bei Signaturen für Funktionsaufrufe ist dies jedoch erforderlich. Weitere Informationen finden Sie auf der Seite Thought Signatures.

Das Google GenAI SDK verarbeitet die Rückgabe von Gedanken-Signaturen automatisch für Sie. Sie müssen Gedankensignaturen nur manuell verwalten, wenn Sie den Unterhaltungsverlauf ändern oder die REST API verwenden.

Weitere Nutzungseinschränkungen für Funktionsaufrufe:

  • Signaturen werden vom Modell in anderen Teilen der Antwort zurückgegeben, z. B. bei Funktionsaufrufen oder in Textteilen. Geben Sie die gesamte Antwort mit allen Teilen in nachfolgenden Zügen 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 „Thinking“ aktiviert ist, setzt sich der Preis für die Antwort aus der Summe der Ausgabe-Tokens und der Thinking-Tokens zusammen. Die Gesamtzahl der generierten Denk-Tokens 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

// ...
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println("Thoughts tokens:", string(usageMetadata.thoughts_token_count))
fmt.Println("Output tokens:", string(usageMetadata.candidates_token_count))

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 Gedanken-Tokens, die das Modell zum Erstellen einer Zusammenfassung generieren muss, obwohl nur die Zusammenfassung von der API ausgegeben wird.

Weitere Informationen zu Tokens finden Sie im Leitfaden Tokens zählen.

Best Practices

In diesem Abschnitt finden Sie einige Hinweise zur effizienten Verwendung von Denkmodellen. Wie immer erzielen Sie die besten Ergebnisse, wenn Sie unsere Anleitung und Best Practices für Prompts befolgen.

Debugging und Steuerung

  • Begründung prü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 gezogen wurde, und diese Informationen nutzen, um die Ergebnisse zu korrigieren.

  • Anleitung für die Argumentation geben: Wenn Sie sich eine besonders lange Antwort wünschen, können Sie in Ihrem Prompt eine Anleitung geben, um die Denkleistung des Modells einzuschränken. So können Sie mehr Token für Ihre Antwort reservieren.

Aufgabenkomplexität

  • Einfache Aufgaben (Denken kann deaktiviert sein): Bei einfachen Anfragen, bei denen keine komplexen Überlegungen erforderlich sind, z. B. beim Abrufen von Fakten oder bei der Klassifizierung, ist kein Denken erforderlich. Hier einige Beispiele:
    • „Wo wurde DeepMind gegründet?“
    • „Wird in dieser E‑Mail um ein Treffen gebeten oder werden nur Informationen bereitgestellt?“
  • Mittlere Aufgaben (Standard/etwas Nachdenken): Viele gängige Anfragen profitieren von einer schrittweisen Verarbeitung oder einem tieferen Verständnis. Gemini kann die Denkfähigkeit flexibel für Aufgaben wie die folgenden einsetzen:
    • Vergleiche die Fotosynthese mit dem Erwachsenwerden.
    • Vergleiche Elektroautos und Hybridautos und stelle sie einander gegenüber.
  • Schwierige Aufgaben (maximale Denkfähigkeit): Für wirklich komplexe Aufgaben, z. B. das Lösen komplexer mathematischer Probleme oder Programmieraufgaben, empfehlen wir, ein hohes Denkbudget festzulegen. Bei diesen Arten von Aufgaben muss das Modell seine gesamten Fähigkeiten zur Argumentation und Planung einsetzen. Oft sind viele interne Schritte erforderlich, bevor eine Antwort gegeben werden kann. Hier einige Beispiele:
    • Löse Problem 1 in AIME 2025: Finde die Summe aller ganzzahligen Basen b > 9, für die 17b ein Teiler von 97b ist.
    • Python-Code für eine Webanwendung schreiben, die Echtzeit-Börsendaten visualisiert, einschließlich der Nutzerauthentifizierung. Sorgen Sie für einen möglichst effizienten Ablauf.

Unterstützte Modelle, Tools und Funktionen

Thinking-Funktionen werden von allen Modellen der Serien 3 und 2.5 unterstützt. Alle Modellfunktionen finden Sie auf der Seite Modellübersicht.

Thinking-Modelle 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 Argumentation und endgültige Antwort einbeziehen.

Beispiele für die Verwendung von Tools mit Thinking-Modellen finden Sie im Thinking Cookbook.

Nächste Schritte