Veo 3 ist jetzt in der Gemini API verfügbar. Weitere Informationen

Diese Seite wurde von der Cloud Translation API übersetzt.

Gemini-Denken

Die Modelle der Gemini 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, anspruchsvolle Mathematik und Datenanalyse.

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

Hinweis

Achten Sie darauf, dass Sie ein unterstütztes Modell der 2.5-Serie für die Ideenfindung verwenden. Es kann hilfreich sein, diese Modelle in AI Studio zu testen, bevor Sie sich mit der API beschäftigen:

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 Denkprozesse 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-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."
         }
       ]
     }
   ]
 }'
 ```

Budgets für Denkprozesse

Der Parameter thinkingBudget gibt dem Modell vor, wie viele Thinking-Tokens beim Generieren einer Antwort verwendet werden sollen. Eine höhere Anzahl von Tokens ermöglicht in der Regel eine detailliertere Argumentation, was bei der Bewältigung komplexerer Aufgaben von Vorteil sein kann. Wenn die Latenz wichtiger ist, verwenden Sie ein niedrigeres Budget oder deaktivieren Sie die Denkphase, 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.

Die thinkingBudget wird nur in Gemini 2.5 Flash, 2.5 Pro und 2.5 Flash-Lite unterstützt. Je nach Prompt kann das Modell das Token-Budget überschreiten oder unterschreiten.

Im Folgenden finden Sie thinkingBudget-Konfigurationsdetails für jeden Modelltyp.

Modell	Standardeinstellung (Budget für Denkprozesse ist nicht festgelegt)	Bereich	Gedankengang 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 Lite	Das Modell denkt nicht	`512` 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-pro",
    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-pro",
    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-pro"
  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-pro: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
          # Thinking off:
          # "thinkingBudget": 0
          # Turn on dynamic thinking:
          # "thinkingBudget": -1
    }
  }
}'

Zusammenfassungen von Gedanken

Zusammenfassungen der Gedanken sind synthetisierte Versionen der Rohgedanken des Modells und bieten Einblicke in den internen Denkprozess des Modells. Thinking-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 parts-Parameter von response durchlaufen und den booleschen Wert thought prüfen.

Hier ein Beispiel dafür, wie Sie Zusammenfassungen von Gedanken ohne Streaming aktivieren und abrufen können. In der Antwort wird dann 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)
      }
    }
  }
}

Gedankensignaturen

Da Standardaufrufe zur Text- und Inhaltsgenerierung der Gemini API zustandslos sind, hat das Modell bei der Verwendung von „Thinking“ in Multi-Turn-Interaktionen (z. B. Chat) keinen Zugriff auf den Kontext von Gedanken aus früheren Runden.

Sie können den Kontext des Gedankens mithilfe von Gedankensignaturen beibehalten. Dabei handelt es sich um verschlüsselte Darstellungen des internen Denkprozesses des Modells. Das Modell gibt Denksignaturen im Antwortobjekt zurück, wenn Denken und Funktionsaufrufe aktiviert sind. Damit das Modell den Kontext über mehrere Gesprächsrunden hinweg beibehält, müssen Sie die Gedanken-Signaturen in den nachfolgenden Anfragen an das Modell zurückgeben.

Sie erhalten Gedanken-Signaturen, wenn:

Die Denkfunktion ist aktiviert und es werden Gedanken generiert.
Die Anfrage enthält Funktionsdeklarationen.

Ein Beispiel für das Denken mit Funktionsaufrufen finden Sie auf der Seite Funktionsaufrufe.

Weitere Nutzungseinschränkungen für Funktionsaufrufe:

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.
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- und 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.

Unterstützte Modelle

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

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

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:
- „Where was DeepMind founded?“ (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 Denkfunktion 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 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 Denk- und Planungsfähigkeiten 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 17_b ein Teiler von 97_b ist.
- Python-Code für eine Webanwendung schreiben, die Echtzeit-Aktienmarktdaten visualisiert, einschließlich der Nutzerauthentifizierung Gestalten Sie den Prozess so effizient wie möglich.

Mit Tools und Funktionen denken

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.

Mit dem Suchtool kann das Modell Google Search abfragen, um aktuelle Informationen oder Informationen zu finden, die über die Trainingsdaten hinausgehen. Das ist nützlich bei Fragen zu aktuellen Ereignissen oder sehr spezifischen Themen.
Mit dem Codeausführungstool kann das Modell Python-Code generieren und ausführen, um Berechnungen durchzuführen, Daten zu bearbeiten oder Probleme zu lösen, die sich am besten algorithmisch lösen lassen. Das Modell empfängt die Ausgabe des Codes und kann sie in seiner Antwort verwenden.
Mit der strukturierten Ausgabe können Sie Gemini dazu zwingen, mit JSON zu antworten. Dies ist besonders nützlich, wenn Sie die Ausgabe des Modells in Anwendungen einbinden möchten.
Funktionsaufrufe verbinden das Denkmodell mit externen Tools und APIs, sodass es überlegen kann, wann die richtige Funktion aufgerufen werden soll und welche Parameter angegeben werden müssen.
Mit URL-Kontext werden dem Modell URLs als zusätzlicher Kontext für Ihren Prompt zur Verfügung gestellt. Das Modell kann dann Inhalte von den URLs abrufen und diese verwenden, um seine Antwort zu gestalten.

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

Nächste Schritte

Weitere ausführliche Beispiele:
- Tools mit Denkprozess verwenden
- Streaming mit Köpfchen
- „Thinking“-Budget für unterschiedliche Ergebnisse anpassen
Thinking Cookbook
Informationen zur Abdeckung finden Sie jetzt in unserem Leitfaden zur OpenAI-Kompatibilität.
Weitere Informationen zu Gemini 2.5 Pro, Gemini Flash 2.5 und Gemini 2.5 Flash-Lite finden Sie auf der Modellseite.