Testen Sie Lyria 3, unser neues Modell zur Musikgenerierung, das aus Text- und Bildeingaben Hi-Fi-Stereo-Audio erzeugen kann.

Gemini-Denken

Die Modelle der Gemini 3- und 2.5-Serie verwenden einen internen "Denkprozess", der ihre Fähigkeiten zur logischen Schlussfolgerung und mehrstufigen Planung erheblich verbessert. Dadurch sind sie sehr effektiv 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.

Inhalte mit Denkfunktionen generieren

Das Initiieren einer Anfrage mit einem Denkmodell ähnelt jeder anderen Anfrage zur Inhaltserstellung. Der Hauptunterschied besteht darin, dass Sie im Feld model eines der Modelle mit Unterstützung für Denkfunktionen angeben müssen, 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-flash-preview",
    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-flash-preview",
    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-flash-preview"

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

  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": "Explain the concept of Occam'\''s Razor and provide a simple, everyday example."
         }
       ]
     }
   ]
 }'
 ```

Zusammenfassungen von Gedanken

Zusammenfassungen von Gedanken sind zusammengefasste 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 in der Anfragekonfiguration includeThoughts 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 von Gedanken ohne Streaming aktivieren und abrufen. In diesem Fall 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-3-flash-preview",
  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-flash-preview",
    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-flash-preview"
  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 Denkfunktionen mit Streaming. Dabei werden während der Generierung fortlaufende, inkrementelle Zusammenfassungen zurückgegeben:

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-flash-preview",
    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-flash-preview",
    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-flash-preview"

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

Denkfunktionen steuern

Gemini-Modelle verwenden standardmäßig dynamische Denkfunktionen. Dabei wird der Aufwand für die logische Schlussfolgerung automatisch an die Komplexität der Nutzeranfrage angepasst. Wenn Sie jedoch bestimmte Latenzbeschränkungen haben oder das Modell eine tiefere logische Schlussfolgerung als üblich durchführen soll, können Sie optional Parameter verwenden, um das Denkverhalten zu steuern.

Denkebenen (Gemini 3)

Mit dem Parameter thinkingLevel, der für Gemini 3-Modelle und höher empfohlen wird, können Sie das Verhalten bei der logischen Schlussfolgerung steuern.

In der folgenden Tabelle sind die Einstellungen für thinkingLevel für die einzelnen Modelltypen aufgeführt:

Denkebene	Gemini 3.1 Pro	Gemini 3.1 Flash-Lite	Gemini 3 Flash	Beschreibung
`minimal`	Nicht unterstützt	Unterstützt (Standardeinstellung)	Unterstützt	Entspricht für die meisten Abfragen der Einstellung „Keine Denkfunktionen“. Das Modell führt möglicherweise nur sehr wenige Denkprozesse für komplexe Programmieraufgaben durch. Minimiert die Latenz für Chat- oder Anwendungen mit hohem Durchsatz. Hinweis: `minimal` garantiert nicht, dass die Denkfunktionen deaktiviert sind.
`low`	Unterstützt	Unterstützt	Unterstützt	Minimiert Latenz und Kosten. Am besten geeignet für einfache Anweisungen, Chat- oder Anwendungen mit hohem Durchsatz.
`medium`	Unterstützt	Unterstützt	Unterstützt	Ausgewogene Denkfunktionen für die meisten Aufgaben.
`high`	Unterstützt (Standardeinstellung, dynamisch)	Unterstützt (dynamisch)	Unterstützt (Standardeinstellung, dynamisch)	Maximiert die Tiefe der logischen Schlussfolgerung. Es kann deutlich länger dauern, bis das Modell das erste Ausgabetoken (ohne Denkfunktionen) erreicht, aber die Ausgabe ist sorgfältiger durchdacht.

Das folgende Beispiel zeigt, wie Sie die Denkebene festlegen.

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, ThinkingLevel } 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: 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 Denkfunktionen für Gemini 3.1 Pro nicht deaktivieren. Gemini 3 Flash und Flash-Lite unterstützen auch keine vollständige Deaktivierung der Denkfunktionen. Die Einstellung minimal bedeutet jedoch, dass das Modell wahrscheinlich nicht nachdenkt (obwohl es dies potenziell tun kann). Wenn Sie keine Denkebene angeben, verwendet Gemini die Standardeinstellung für die dynamische Denkebene der Gemini 3-Modelle, "high".

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

Denkbudgets

Der Parameter thinkingBudget, der mit der Gemini 2.5-Serie eingeführt wurde, gibt dem Modell die spezifische Anzahl der Tokens vor, die für die logische Schlussfolgerung verwendet werden sollen.

Im Folgenden finden Sie Details zur Konfiguration von thinkingBudget für die einzelnen Modelltypen. Sie können die Denkfunktionen deaktivieren, indem Sie thinkingBudget auf 0 setzen. Wenn Sie thinkingBudget auf -1 setzen, wird dynamisches Denken aktiviert. Das bedeutet, dass das Modell das Budget an die Komplexität der Anfrage anpasst.

Modell	Standardeinstellung (Denkbudget ist nicht festgelegt)	Bereich	Denkfunktionen deaktivieren	Dynamische Denkfunktionen aktivieren
2.5 Pro	Dynamische Denkfunktionen	`128` bis `32768`	Nicht zutreffend: Denkfunktionen können nicht deaktiviert werden	`thinkingBudget = -1` (Standardeinstellung)
2.5 Flash	Dynamische Denkfunktionen	`0` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1` (Standardeinstellung)
2.5 Flash (Vorabversion)	Dynamische Denkfunktionen	`0` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1` (Standardeinstellung)
2.5 Flash Lite	Das Modell denkt nicht	`512` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`
2.5 Flash Lite (Vorabversion)	Das Modell denkt nicht	`512` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`
Robotics-ER 1.5 (Vorabversion)	Dynamische Denkfunktionen	`0` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1` (Standardeinstellung)
2.5 Flash Live Native Audio (Vorabversion, 09/2025)	Dynamische Denkfunktionen	`0` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1` (Standardeinstellung)

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.

Bedrohungssignaturen

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

Damit der Denkkontext bei Multi-Turn-Interaktionen beibehalten werden kann, gibt Gemini Bedrohungssignaturen zurück. Das sind verschlüsselte Darstellungen des internen Denkprozesses des Modells.

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

Weitere Nutzungsbeschränkungen, 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 Denkfunktionen aktiviert sind, setzt sich der Preis für die Antwort aus den Ausgabetokens und den Denk-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 Denk-Tokens, die das Modell zum Erstellen einer Zusammenfassung benötigt, obwohl nur die Zusammenfassung von der API ausgegeben wird.

Weitere Informationen zu Tokens finden Sie im Leitfaden 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.

Fehlerbehebung und Steuerung

Logische Schlussfolgerung überprüfen: Wenn Sie nicht die erwartete Antwort von den Denkmodellen erhalten, kann es hilfreich sein, die Zusammenfassungen von 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 zur logischen Schlussfolgerung geben: Wenn Sie eine besonders lange Ausgabe wünschen, können Sie in Ihrem Prompt eine Anleitung geben, um die Menge der Denkprozesse zu begrenzen, die das Modell verwendet. So können Sie mehr Ausgabetokens für Ihre Antwort reservieren.

Aufgabenkomplexität

Einfache Aufgaben (Denkfunktionen können deaktiviert werden) : Für einfache Anfragen, bei denen keine komplexe logische Schlussfolgerung erforderlich ist, z. B. das Abrufen von Fakten oder die Klassifizierung, sind Denkfunktionen nicht erforderlich. Beispiele:
- Wo wurde DeepMind gegründet?
- Wird in dieser E‑Mail um ein Meeting gebeten oder werden nur Informationen bereitgestellt?
Mittelgroße Aufgaben (Standardeinstellung/einige Denkfunktionen) : Viele häufige Anfragen profitieren von einer schrittweisen Verarbeitung oder einem tieferen Verständnis. Gemini kann Denkfunktionen flexibel für Aufgaben wie die folgenden verwenden:
- Analogie zwischen Photosynthese und Erwachsenwerden.
- Vergleich und Gegenüberstellung von Elektroautos und Hybridautos.
Schwierige Aufgaben (maximale Denkfunktionen) : Für wirklich komplexe Aufgaben wie das Lösen komplexer mathematischer Probleme oder Programmieraufgaben empfehlen wir, ein hohes Denkbudget festzulegen. Bei diesen Aufgaben muss das Modell seine gesamten Fähigkeiten zur logischen Schlussfolgerung und Planung 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 17_b ein Teiler von 97_b ist.
- Schreiben Sie Python-Code für eine Webanwendung, die Echtzeit-Aktienmarktdaten visualisiert, einschließlich der Nutzerauthentifizierung. Machen Sie sie so effizient wie möglich.

Unterstützte Modelle, Tools und Funktionen

Denkfunktionen werden von allen Modellen der 3- und 2.5-Serie 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 logische Schlussfolgerung und endgültige Antwort einbeziehen.

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

Nächste Schritte

Informationen zur Abdeckung von Denkfunktionen finden Sie in unserem Leitfaden zur OpenAI-Kompatibilität.