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:

PythonJavaScriptOkREST 
from google import genai

client = genai.Client(api_key="GOOGLE_API_KEY")
prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example."
response = client.models.generate_content(
    model="gemini-2.5-flash-preview-05-20",
    contents=prompt
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

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-flash-preview-05-20",  
    contents: prompt,
  });

  console.log(response.text);
}

main();

// import packages here

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GOOGLE_API_KEY")))
  if err != nil {
    log.Fatal(err)
  }
  defer client.Close()

  model := client.GenerativeModel("gemini-2.5-flash-preview-05-20")  
  resp, err := model.GenerateContent(ctx, genai.Text("Explain the concept of Occam's Razor and provide a simple, everyday example."))
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Text())
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-05-20:generateContent?key=$GOOGLE_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."
         }
       ]
     }
   ]
 }'
 ```

Gedankenzusammenfassungen (experimentell)

Gedankenzusammenfassungen bieten Einblicke in den internen Argumentationsvorgang des Modells. Diese Funktion kann hilfreich sein, um den Ansatz des Modells zu überprüfen und Nutzer bei längeren Aufgaben auf dem Laufenden zu halten, insbesondere in Kombination mit Streaming.

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:

PythonJavaScriptOk 
from google import genai
from google.genai import types

client = genai.Client(api_key="GOOGLE_API_KEY")
prompt = "What is the sum of the first 50 prime numbers?"
response = client.models.generate_content(
  model="gemini-2.5-flash-preview-05-20",
  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()

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash-preview-05-20",
    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();

package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
    APIKey:  os.Getenv("GOOGLE_API_KEY"),
    Backend: genai.BackendGeminiAPI,
  })

  contents := genai.Text("What is the sum of the first 50 prime numbers?")
  model := "gemini-2.5-flash-preview-05-20"
  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:

PythonJavaScript 
from google import genai
from google.genai import types

client = genai.Client(api_key="GOOGLE_API_KEY")

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

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

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-flash-preview-05-20",
    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();

Budgets für Denkprozesse

Mit dem Parameter thinkingBudget können Sie dem Modell die Anzahl der Tokens vorgeben, die es beim Generieren einer Antwort verwenden darf. Eine höhere Tokenanzahl ermöglicht in der Regel eine detailliertere Argumentation, was sich für die Bewältigung komplexerer Aufgaben als vorteilhaft erweisen kann. Wenn Sie thinkingBudget nicht festlegen, passt das Modell das Budget dynamisch an die Komplexität der Anfrage an.

  • thinkingBudget muss eine Ganzzahl zwischen 0 und 24576 sein.
  • Wenn Sie das Thinking-Budget auf 0 festlegen, wird das Thinking deaktiviert.
  • Je nach Prompt kann das Modell das Token-Budget über- oder unterschreiten.
PythonJavaScriptOkREST 
from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-flash-preview-05-20",
    contents="Provide a list of 3 famous physicists and their key contributions",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_budget=1024)
    ),
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash-preview-05-20",
    contents: "Provide a list of 3 famous physicists and their key contributions",
    config: {
      thinkingConfig: {
        thinkingBudget: 1024,
      },
    },
  });

  console.log(response.text);
}

main();

package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
    APIKey:  os.Getenv("GOOGLE_API_KEY"),
    Backend: genai.BackendGeminiAPI,
  })

  thinkingBudgetVal := int32(1024)

  contents := genai.Text("Provide a list of 3 famous physicists and their key contributions")
  model := "gemini-2.5-flash-preview-05-20"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      ThinkingBudget: &thinkingBudgetVal,
    },
  })

fmt.Println(resp.Text())
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-05-20:generateContent?key=$GOOGLE_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
    }
  }
}'

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.

PythonJavaScriptOk 
# ...
print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
print("Output tokens:",response.usage_metadata.candidates_token_count)

// ...
console.log(`Thoughts tokens: ${response.usageMetadata.thoughtsTokenCount}`);
console.log(`Output tokens: ${response.usageMetadata.candidatesTokenCount}`);

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

Alle Modellfunktionen finden Sie auf der Seite Modellübersicht.

Modell Zusammenfassungen von Denkprozessen Budget für Denkprozesse
Gemini 2.5 Flash ✔️ ✔️
Gemini 2.5 Pro ✔️ X

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 prüfen: Wenn Sie von den denkenden Modellen nicht die erwartete Antwort erhalten, kann es hilfreich sein, den Argumentationsvorgang 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 muss das Modell seine gesamten Denk- 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 17b ein Teiler von 97b 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 strukturierter Ausgabe können Sie Gemini dazu zwingen, mit JSON zu antworten. Das 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.

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 OpenAI-Kompatibilität verfügbar.

  • Weitere Informationen zu Gemini 2.5 Pro Preview und Gemini Flash 2.5 Thinking finden Sie auf der Modellseite.