Testen Sie das neue Modell Gemini 3.1 Flash TTS Preview für die expressive, mehrsprachige Sprachgenerierung.

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 und sie so für komplexe Aufgaben wie Programmieren, fortgeschrittene Mathematik und Datenanalyse sehr effektiv macht.

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

Inhalte mit Denkprozess generieren

Das Initiieren einer Anfrage mit einem Denkmodell ähnelt jeder anderen Anfrage zur Inhaltserstellung. 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-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 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 von Gedanken ohne Streaming aktivieren und abrufen. 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-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 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-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)
      }
    }
  }
}

Denkprozesse steuern

Gemini-Modelle führen standardmäßig dynamische Denkprozesse durch und passen den Aufwand für die logische Schlussfolgerung automatisch an die Komplexität der Anfrage des Nutzers an. 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 (Standard)	Unterstützt	Entspricht der Einstellung „Kein Denkprozess“ für die meisten Anfragen. Das Modell führt möglicherweise nur sehr minimale Denkprozesse für komplexe Programmieraufgaben durch. Minimiert die Latenz für Chat- oder Anwendungen mit hohem Durchsatz. Hinweis: `minimal` garantiert nicht, dass Denkprozesse 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 Denkprozesse für die meisten Aufgaben.
`high`	Unterstützt (Standard, dynamisch)	Unterstützt (dynamisch)	Unterstützt (Standard, dynamisch)	Maximiert die Tiefe der logischen Schlussfolgerung. Es kann deutlich länger dauern, bis das Modell ein erstes Ausgabetoken (ohne Denkprozess) erreicht, aber die Ausgabe ist sorgfältiger durchdacht.

Im folgenden Beispiel wird gezeigt, 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 Denkprozesse für Gemini 3.1 Pro nicht deaktivieren. Gemini 3 Flash und Flash Lite unterstützen auch keine vollständige Deaktivierung von Denkprozessen. Die Einstellung minimal bedeutet jedoch, dass das Modell wahrscheinlich keine Denkprozesse durchführt (obwohl dies weiterhin möglich ist). Wenn Sie keine Denkebene angeben, verwendet Gemini die standardmäßige dynamische Denkebene der Gemini 3-Modelle, "high".

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

Budgets 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 Denkprozesse 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 Denkprozesse 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 (Budget für Denkprozesse ist nicht festgelegt)	Bereich	Denkprozesse deaktivieren	Dynamische Denkprozesse aktivieren
2.5 Pro	Dynamische Denkprozesse	`128` bis `32768`	Nicht zutreffend: Denkprozesse können nicht deaktiviert werden	`thinkingBudget = -1` (Standard)
2.5 Flash	Dynamische Denkprozesse	`0` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1` (Standard)
2.5 Flash (Vorabversion)	Dynamische Denkprozesse	`0` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1` (Standard)
2.5 Flash Lite	Das Modell führt keine Denkprozesse durch	`512` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`
2.5 Flash Lite (Vorabversion)	Das Modell führt keine Denkprozesse durch	`512` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`
Robotics-ER 1.6 (Vorabversion)	Dynamische Denkprozesse	`0` bis `24576`	`thinkingBudget = 0`	`thinkingBudget = -1` (Standard)
2.5 Flash Live Native Audio (Vorabversion, 09/2025)	Dynamische Denkprozesse	`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.

Thought Signatures

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

Damit der Kontext von Gedanken über mehrere Runden hinweg beibehalten werden kann, gibt Gemini Thought Signatures zurück. Das sind verschlüsselte Darstellungen des internen Denkprozesses des Modells.

Gemini 2.5-Modelle geben Thought Signatures zurück, wenn Denkprozesse aktiviert sind und die Anfrage Funktionsaufrufe enthält, insbesondere Funktionsdeklarationen.
Gemini 3-Modelle können Thought Signatures für alle Arten von Teilen zurückgeben. Wir empfehlen, alle Signaturen immer so zurückzugeben, wie sie empfangen wurden. Für Signaturen von Funktionsaufrufen ist dies erforderlich. Weitere Informationen finden Sie auf der Seite Thought Signatures to learn more.

Weitere Nutzungsbeschränkungen für Funktionsaufrufe:

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 Denkprozesse aktiviert sind, setzen sich die Kosten für die Antwort aus den Ausgabetokens und den Tokens für Denkprozesse zusammen. Die Gesamtzahl der generierten Tokens für Denkprozesse 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 Tokens für Denkprozesse, 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 für 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 für die logische Schlussfolgerung geben: Wenn Sie eine besonders lange Ausgabe erwarten, 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 (Denkprozesse 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 Denkprozesse nicht erforderlich. Beispiele:
- „Wo wurde DeepMind gegründet?“
- „Wird in dieser E‑Mail um ein Meeting gebeten oder werden nur Informationen bereitgestellt?“
Mittelschwere Aufgaben (Standard/einige Denkprozesse) : Viele häufige Anfragen profitieren von einer schrittweisen Verarbeitung oder einem tieferen Verständnis. Gemini kann Denkprozesse 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 Denkprozesse 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-Börsendaten visualisiert, einschließlich der Nutzerauthentifizierung. Die Anwendung soll so effizient wie möglich sein.

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 Cookbook für Denkprozesse.

Nächste Schritte

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