Gemini 3 Pro ist da. Kostenlos in Google AI Studio ausprobieren

Diese Seite wurde von der Cloud Translation API übersetzt.

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 erfahren Sie, 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 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."
         }
       ]
     }
   ]
 }'
 ```

Zusammenfassungen von Gedanken

Zusammenfassungen der Gedanken sind synthetisierte Versionen der Rohgedanken des Modells und bieten Einblicke in den internen Denkprozess des Modells. Die Denkebenen und Budgets beziehen sich auf die Rohgedanken des Modells und nicht auf 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 Parameter response durchlaufen und den booleschen Wert thought prüfen.parts

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

Denken kontrollieren

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 tiefergehende Überlegungen anstellen soll als üblich, können Sie optional Parameter verwenden, um das Denkverhalten zu steuern.

Denkaufwand (Gemini 3 Pro)

Mit dem Parameter thinkingLevel, der für Gemini 3-Modelle und höher empfohlen wird, können Sie das Verhalten des Modells steuern. Sie können die Denkebene auf "low" oder "high" festlegen. Wenn Sie keine Denkebene angeben, verwendet Gemini die dynamische Standarddenkebene des Modells, "high", für Gemini 3 Pro Preview.

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-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 } from "@google/genai";

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-3-pro-preview",
    contents: "Provide a list of 3 famous physicists and their key contributions",
    config: {
      thinkingConfig: {
        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-pro-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-pro-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"
    }
  }
}'

Die Denkphase kann für Gemini 3 Pro nicht deaktiviert werden. Modelle der Gemini 2.5-Reihe unterstützen thinkingLevel nicht. Verwenden Sie stattdessen thinkingBudget.

Budgets für Denkprozesse

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

Im Folgenden finden Sie thinkingBudget-Konfigurationsdetails für jeden Modelltyp. 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 an die Komplexität der Anfrage anpasst.

Modell	Standardeinstellung (Budget für Denkprozesse ist nicht festgelegt)	Bereich	Begründung 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 (Vorschau)	Dynamisches Denken: Das Modell entscheidet, wann und wie viel es denkt.	`0` nach `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`
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.5 (Vorschau)	Dynamisches Denken: Das Modell entscheidet, wann und wie viel es denkt.	`0` nach `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`
2.5 Flash Live Native Audio Preview (09-2025)	Dynamisches Denken: Das Modell entscheidet, wann und wie viel es denkt.	`0` 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
    }
  }
}'

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 Kontext des Denkprozesses 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 Denkprozess-Signaturen zurück, wenn die Denkprozess-Funktion 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 Thought Signatures.

Das Google GenAI SDK verarbeitet die Rückgabe von Gedanken-Signaturen automatisch für Sie. Sie müssen Gedankensignaturen nur manuell verwalten, wenn Sie den Unterhaltungsverlauf ändern oder die REST API verwenden.

Weitere Nutzungseinschränkungen für Funktionsaufrufe:

Signaturen werden vom Modell in anderen Teilen der Antwort zurückgegeben, z. B. bei Funktionsaufrufen oder Textteilen. Gib 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 die Funktion „Thinking“ 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

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

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 wurde und wie die KI zu ihrer Schlussfolgerung gelangt ist. Anhand dieser Informationen können Sie die Ergebnisse 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 Denkfähigkeit 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, 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 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-Börsendaten visualisiert, einschließlich der Nutzerauthentifizierung Sorgen Sie für einen möglichst effizienten Ablauf.

Unterstützte Modelle, Tools und Funktionen

Denkfunktionen werden auf allen Modellen der 3er- und 2.5er-Serie unterstützt. Alle Modellfunktionen finden Sie auf der Seite Modellübersicht.

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.

Beispiele für die Verwendung von Tools mit Thinking-Modellen finden Sie im Thinking-Kochbuch.

Nächste Schritte

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