Gemini-Denken

Die Modelle der Gemini 3- und 2.5-Serie nutzen einen internen „Denkprozess“, der ihre Fähigkeiten zum logischen Denken 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 im Feld model eines der Modelle mit Unterstützung für das Denken angegeben wird, 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-3.5-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.5-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.5-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.5-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 Überlegungen sind zusammengefasste Versionen der rohen Überlegungen des Modells und bieten Einblicke in den internen Prozess der Problemlösung des Modells. Hinweis: Denkebenen und Budgets gelten für die rohen Gedanken 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 eine einzelne, endgültige Zusammenfassung von Gedanken mit der Antwort 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.5-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.5-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.5-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)
      }
    }
  }
}

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-3.5-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.5-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.5-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)
      }
    }
  }
}

Kontrolliertes Denken

Gemini-Modelle verwenden standardmäßig dynamisches Denken und passen den Aufwand für das Reasoning automatisch an die Komplexität der Nutzeranfrage an. Wenn Sie jedoch bestimmte Latenzbeschränkungen haben oder das Modell tiefergehende Überlegungen anstellen soll, 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.

In der folgenden Tabelle finden Sie die thinkingLevel-Einstellungen für die einzelnen Modelltypen:

Denkaufwand Gemini 3.1. Pro Gemini 3.1 Flash Lite Gemini 3 Flash Gemini 3.5 Flash Beschreibung
minimal Nicht unterstützt Unterstützt (Standard) Unterstützt Unterstützt 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. Hinweis: minimal garantiert nicht, dass die Funktion zum Überlegen deaktiviert ist.
low Unterstützt Unterstützt Unterstützt Unterstützt Minimiert Latenz und Kosten. Am besten geeignet für einfache Anweisungen, Chats oder Anwendungen mit hohem Durchsatz.
medium Unterstützt Unterstützt Unterstützt Unterstützt (Standard) Ausgewogenes Denken bei den meisten Aufgaben.
high Unterstützt (Standard, dynamisch) Unterstützt (dynamisch) Unterstützt (Standard, dynamisch) Unterstützt (dynamisch) Maximiert die Tiefe des logischen Schlussfolgerns. Es kann deutlich länger dauern, bis das Modell das erste Ausgabetoken (nicht „thinking“) ausgibt, aber die Ausgabe ist sorgfältiger durchdacht.

Im folgenden Beispiel wird gezeigt, wie die Denkebene festgelegt wird.

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.5-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.5-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.5-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.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": {
          "thinkingLevel": "low"
    }
  }
}'

Die Denkphase kann für Gemini 3.1 Pro nicht deaktiviert werden. Gemini 3 Flash und Flash-Lite unterstützen auch nicht das vollständige Deaktivieren der Denkfunktion. Die Einstellung minimal bedeutet jedoch, dass das Modell wahrscheinlich nicht nachdenkt (obwohl es das immer noch tun kann). Wenn Sie keine Thinking-Stufe angeben, verwendet Gemini die Standard-Thinking-Stufe der Gemini 3-Modelle (z.B. "high" für Gemini 3.1 Pro und "medium" für Gemini 3.5 Flash).

Die 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-Serie eingeführt wurde, gibt dem Modell die genaue Anzahl der Tokens für den Thinking-Modus vor, die es für Schlussfolgerungen verwenden soll.

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 Begründung deaktivieren Dynamisches Denken aktivieren
2.5 Pro Dynamisches Denken 128 nach 32768 N/A: Das Denken kann nicht deaktiviert werden. thinkingBudget = -1 (Standard)
2.5 Flash Dynamisches Denken 0 nach 24576 thinkingBudget = 0 thinkingBudget = -1 (Standard)
2.5 Flash-Vorschau Dynamisches Denken 0 nach 24576 thinkingBudget = 0 thinkingBudget = -1 (Standard)
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.6 (Vorabversion) Dynamisches Denken 0 nach 24576 thinkingBudget = 0 thinkingBudget = -1 (Standard)
2.5 Flash Live Native Audio Preview (09-2025) Dynamisches Denken 0 nach 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 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 über mehrere Interaktionen hinweg 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 der Denkprozess 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 Gedankensignaturen.

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.
  • Fügen Sie keine Teile mit Signaturen zusammen.
  • Führen Sie keinen Teil mit einer Signatur mit einem anderen Teil ohne Signatur zusammen.

Preise

Wenn der Thinking-Modus 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

// ...
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 Denk-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. Wenn Sie unsere Anleitung und Best Practices für Prompts befolgen, erzielen Sie wie immer die besten Ergebnisse.

Debugging und Steuerung

  • Schlussfolgerung 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 eine besonders lange Ausgabe wünschen, sollten 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.

Komplexität der Aufgabe

  • Einfache Aufgaben (Denken kann deaktiviert sein): Bei einfachen Anfragen, bei denen kein komplexes Reasoning erforderlich ist, 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 eine Besprechung 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 Funktion für logisches Schlussfolgern flexibel für Aufgaben wie die folgenden nutzen:
    • 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 wie 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 Problemlösung und Planung einsetzen. Oft sind viele interne Schritte erforderlich, bevor eine Antwort gegeben wird. 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-Aktienmarktdaten visualisiert, einschließlich der Nutzerauthentifizierung Sorgen Sie für eine möglichst effiziente Nutzung.

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 sind mit allen Tools und Funktionen von Gemini kompatibel. 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.

Im [Thinking Cookbook][Colab] finden Sie Beispiele für die Verwendung von Tools mit Denkmodellen.

Nächste Schritte

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