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 wird beschrieben, 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 Denkprozesse angeben müssen, wie im folgenden Beispiel zur Textgenerierung gezeigt wird:

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 Ü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 Rohgedanken des Modells und nicht für Zusammenfassungen von Gedanken.

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

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

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.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 verwenden 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 eine tiefere Argumentation als gewöhnlich erfordert, 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 des Modells beim Schlussfolgern steuern.

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

Denkaufwand Gemini 3.8 Flash Gemini 3.6 Flash Gemini 3.1. Pro Gemini 3.5 und 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 Unterstützt (Standard) Unterstützt (Standard) Unterstützt Unterstützt Entspricht für die meisten Anfragen der Einstellung „Kein Denken“. minimal garantiert nicht, dass das Thinking-Modell deaktiviert ist. Das Modell kann bei komplexen Aufgaben sehr wenig Reasoning durchführen.
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 Unterstützt Nicht unterstützt Unterstützt Unterstützt Ausgewogenes Denken für die meisten Aufgaben.
high Unterstützt (dynamisch) Unterstützt (dynamisch) Unterstützt (Standard, dynamisch) Unterstützt (dynamisch) Unterstützt (dynamisch) Unterstützt (Standard, dynamisch) Unterstützt (Standard, dynamisch) Maximiert die Tiefe der Argumentation. Es kann deutlich länger dauern, bis das Modell das erste Ausgabetoken (nicht „thinking“) erreicht, aber die Ausgabe ist sorgfältiger durchdacht.

Das folgende Beispiel zeigt, 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.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"
    }
  }
}'

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 des Thinking-Modus. 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.8 Flash und Gemini 3.6 Flash).

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

Tokenlimits und max_output_tokens

Mit dem Generierungsparameter max_output_tokens wird die maximale Anzahl an Tokens festgelegt, die in einer Antwort generiert werden können, einschließlich der Denk-Tokens.

Wenn dieser Parameter festgelegt ist, fungiert er als harter Grenzwert, der von der Infrastruktur erzwungen wird, ohne dass sich ändert, wie das Modell sein Denkbudget (thinking_level) zuweist.

Wenn das Modell dieses Limit während der Argumentation erreicht, wird die Generierung mit finish_reason: MAX_TOKENS beendet und eine gekürzte oder leere Ausgabe zurückgegeben. Die generierten Denk-Tokens werden jedoch weiterhin abgerechnet. Wenn Sie die Kosten oder die Latenz verringern möchten, ohne Antworten zu kürzen, sollten Sie thinking_level (low oder medium) senken, anstatt einen kleinen Wert für max_output_tokens festzulegen.

Budgets für Denkprozesse

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

Im Folgenden finden Sie thinkingBudget-Konfigurationsdetails für die einzelnen Modelltypen. 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 128 nach 32768 –: Denkprozess 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 Denkkontext 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 Denk-Signaturen zurück, wenn die Denkfunktion 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 Nutzungslimits, die bei Funktionsaufrufen zu beachten sind:

  • Signaturen werden vom Modell in anderen Teilen der Antwort zurückgegeben, z. B. bei Funktionsaufrufen oder 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. Wie immer erzielen Sie die besten Ergebnisse, wenn Sie unsere Anleitung und Best Practices für Prompts befolgen.

Debugging und Steuerung

  • Schlussfolgerung ü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 wurde und wie das Modell zu seiner Schlussfolgerung gelangt ist. Diese Informationen können Sie nutzen, um die Ergebnisse zu korrigieren.

  • Anleitung für die Argumentation geben: Wenn Sie sich einen besonders langen Output 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 werden): 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:
    • „Where was DeepMind founded?“ (Wo wurde DeepMind gegründet?)
    • „Wird in dieser E-Mail um ein Meeting 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 Thinking-Funktion 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, 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 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.
    • Schreibe Python-Code für eine Webanwendung, die Echtzeit-Börsendaten visualisiert, einschließlich der Nutzerauthentifizierung. So effizient wie möglich sein.

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.

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

Nächste Schritte

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