Wir haben unsere 2.5-Thinking-Modellfamilie aktualisiert. Weitere Informationen

Diese Seite wurde von der Cloud Translation API übersetzt.

Gemini-Denken

Die Modelle der Gemini 2.5-Reihe nutzen einen internen „Denkprozess“, der ihre Fähigkeit zum logischen Denken und zur mehrstufigen Planung erheblich verbessert. Dadurch sind sie für komplexe Aufgaben wie Programmieren, fortgeschrittene Mathematik und Datenanalyse äußerst effektiv.

In diesem Leitfaden erfahren Sie, wie Sie mit der Gemini API die Denkfähigkeiten von Gemini nutzen.

Hinweis

Verwenden Sie ein unterstütztes 2.5-Serienmodell für das Denken. Es kann hilfreich sein, sich diese Modelle in AI Studio anzusehen, bevor Sie sich mit der API vertraut machen:

Inhalte durch Nachdenken generieren

Das Starten einer Anfrage mit einem Denkmodell ähnelt jeder anderen Anfrage zur Inhaltsgenerierung. 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-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 die Anzahl der Tokens vor, die es beim Generieren einer Antwort verwenden darf. Eine höhere Tokenanzahl ermöglicht in der Regel eine detailliertere Argumentation, was sich für komplexere Aufgaben als vorteilhaft erweisen kann. Wenn die Latenz wichtiger ist, verwenden Sie ein niedrigeres Budget oder deaktivieren Sie das Nachdenken, indem Sie thinkingBudget auf 0 setzen. Wenn Sie thinkingBudget auf „-1“ festlegen, wird das dynamische Denken aktiviert. Das Modell passt das Budget dann an die Komplexität der Anfrage an.

Das Zeichen 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 über- oder unterschreiten.

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

Modell	Standardeinstellung (Budget für Denkprozesse nicht festgelegt)	Bereich	Denken deaktivieren	Dynamisches Denken aktivieren
2.5 Pro	Dynamisches Denken: Das Modell entscheidet, wann und wie viel es nachdenken soll	`128` nach `32768`	–: Denken kann nicht deaktiviert werden	`thinkingBudget = -1`
2,5-facher Blitz	Dynamisches Denken: Das Modell entscheidet, wann und wie viel es nachdenken soll	`0` nach `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`
2.5 Flash Lite	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

Gedankenzusammenfassungen sind synthetisierte Versionen der Rohgedanken des Modells und bieten Einblicke in den internen Denkprozess des Modells. Denkensbudgets gelten für die Rohgedanken des Modells und nicht für Gedankenzusammenfassungen.

Sie können Zusammenfassungen von Gedanken aktivieren, indem Sie in der Anfragekonfiguration includeThoughts auf true festlegen. Sie können dann auf die Zusammenfassung zugreifen, indem Sie die parts des Parameters response durchgehen und den booleschen Wert thought prüfen.

Hier ein Beispiel, das zeigt, wie Sie Gedankenzusammenfassungen ohne Streaming aktivieren und abrufen. Dabei wird eine einzelne endgültige Gedankenzusammenfassung 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-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 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("Thoughts summary:")
      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)
      }
    }
  }
}

Preise

Wenn das Denken aktiviert ist, entspricht der Antwortpreis der Summe der Ausgabe- und Denk-Tokens. Die Gesamtzahl der generierten Denktokens 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 einen Einblick in den Denkprozess zu geben. Die Preise basieren also auf den vollständigen Gedanken-Tokens, die das Modell generieren muss, um eine Zusammenfassung zu erstellen, obwohl nur die Zusammenfassung von der API ausgegeben wird.

Weitere Informationen zu Tokens finden Sie im Leitfaden zur Tokenzählung.

Unterstützte Modelle

Die Denkfunktionen werden von allen Modellen der 2.5er-Reihe unterstützt. Alle Modellfunktionen finden Sie auf der Seite Modellübersicht.

Best Practices

Dieser Abschnitt enthält einige Hinweise zur effizienten Verwendung von Denkmodellen. Wie immer erzielen Sie die besten Ergebnisse, wenn Sie unseren Hinweisen und Best Practices für Prompts folgen.

Fehlerbehebung und Steuerung

Argumentation überprüfen: Wenn Sie von den Denkmodellen nicht die erwartete Antwort erhalten, kann es hilfreich sein, die Gedankenzusammenfassungen von Gemini sorgfältig zu analysieren. Sie können sehen, wie die Aufgabe in einzelne Schritte unterteilt und zu einer Schlussfolgerung gekommen ist. Anhand dieser Informationen können Sie die richtigen Ergebnisse erzielen.
Leitfaden für die Argumentation bereitstellen: Wenn Sie sich einen besonders langen Output wünschen, können Sie in Ihrem Prompt eine Anleitung geben, um den Grad der Denkleistung des Modells einzuschränken. So kannst du mehr der Tokenausgabe für deine Antwort reservieren.

Aufgabenkomplexität

Einfache Aufgaben (Denken kann deaktiviert sein): Bei einfachen Anfragen, bei denen keine komplexe Argumentation erforderlich ist, z. B. bei der Abrufung von Fakten oder der Klassifizierung, ist kein Denken erforderlich. Hier einige Beispiele:
- „Wo wurde DeepMind gegründet?“
- „Werden in dieser E-Mail ein Treffen angefragt oder nur Informationen zur Verfügung gestellt?“
Mittelschwere Aufgaben (Standardeinstellung/einige Überlegungen): Viele häufige Anfragen profitieren von einer gewissen Schritt-für-Schritt-Verarbeitung oder einem tieferen Verständnis. Gemini kann die Denkfunktion flexibel für Aufgaben wie die folgenden verwenden:
- Stellen Sie eine Analogie zwischen der Photosynthese und dem Erwachsenwerden her.
- Vergleichen Sie Elektro- und Hybridautos.
Schwierige Aufgaben (maximale Denkleistung): Bei wirklich komplexen Herausforderungen, wie dem Lösen komplexer mathematischer Probleme oder Programmieraufgaben, empfehlen wir ein hohes Denkbudget. Bei diesen Arten von Aufgaben muss das Modell seine gesamten Argumentations- und Planungsfunktionen nutzen. Oft sind viele interne Schritte erforderlich, bevor eine Antwort geliefert wird. Hier einige Beispiele:
- Lösen Sie Problem 1 in AIME 2025: Bestimmen Sie die Summe aller Ganzzahlbasen b > 9, für die 17_b ein Teiler von 97_b ist.
- Python-Code für eine Webanwendung schreiben, die Echtzeitdaten des Aktienmarkts visualisiert, einschließlich Nutzerauthentifizierung Machen Sie es 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 die Google Suche abfragen, um aktuelle Informationen oder Informationen zu finden, die über die Trainingsdaten hinausgehen. Das ist nützlich für 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 manipulieren oder Probleme zu lösen, die sich am besten algorithmisch bearbeiten lassen. Das Modell empfängt die Ausgabe des Codes und kann sie in seiner Antwort verwenden.
Mit einer strukturierten Ausgabe können Sie Gemini dazu zwingen, mit JSON zu antworten. Dies ist besonders nützlich, um die Ausgabe des Modells in Anwendungen einzubinden.
Der Funktionsaufruf verbindet das Denkmodell mit externen Tools und APIs, damit es entscheiden kann, wann die richtige Funktion aufgerufen werden soll und welche Parameter angegeben werden müssen.
Der URL-Kontext liefert dem Modell URLs als zusätzlichen Kontext für Ihren Prompt. Das Modell kann dann Inhalte aus den URLs abrufen und diese Inhalte verwenden, um seine Antwort zu informieren und zu gestalten.

Im Kochbuch für das Denken finden Sie Beispiele für die Verwendung von Tools mit Denkmodellen.

Nächste Schritte

Hier finden Sie weitere ausführliche Beispiele:
- Tools mit dem Denken kombinieren
- Streaming mit Nachdenken
- Denkbudget für unterschiedliche Ergebnisse anpassen
und mehr finden Sie in unserem Kochbuch fürs Denken.
Informationen zur Abdeckung von Gedanken sind jetzt in unserem Leitfaden zur Kompatibilität mit OpenAI verfügbar.
Weitere Informationen zu Gemini 2.5 Pro, Gemini Flash 2.5 und Gemini 2.5 Flash-Lite finden Sie auf der Modellseite.