Myślenie Gemini

Modele z serii Gemini 3 i 2.5 korzystają z wewnętrznego „procesu myślowego”, który znacznie poprawia ich zdolność do rozumowania i planowania wieloetapowego, dzięki czemu są bardzo skuteczne w złożonych zadaniach, takich jak kodowanie, zaawansowana matematyka i analiza danych.

Z tego przewodnika dowiesz się, jak korzystać z funkcji myślenia Gemini za pomocą interfejsu Gemini API.

Generowanie treści z wykorzystaniem myślenia

Wysyłanie żądania do modelu myślącego jest podobne do każdego innego żądania generowania treści. Kluczowa różnica polega na określeniu w polu model jednego z modeli obsługujących myślenie, jak pokazano w tym przykładzie generowania tekstu:

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

  console.log(response.text);
}

main();

Go

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-flash-preview"

  resp, _ := client.Models.GenerateContent(ctx, model, genai.Text(prompt), nil)

  fmt.Println(resp.Text())
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview: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."
         }
       ]
     }
   ]
 }'
 ```

Podsumowania procesu myślowego

Podsumowania procesu myślowego to skrócone wersje surowych myśli modelu, które pozwalają zrozumieć wewnętrzny proces rozumowania modelu. Pamiętaj, że poziomy i budżety myślenia dotyczą surowych myśli modelu, a nie podsumowań procesu myślowego.

Aby włączyć podsumowania procesu myślowego, ustaw w konfiguracji żądania wartość includeThoughts na true. Następnie możesz uzyskać dostęp do podsumowania, iterując po parts parametru response i sprawdzając wartość logiczną thought.

Oto przykład pokazujący, jak włączyć i pobrać podsumowania procesu myślowego bez przesyłania strumieniowego. W odpowiedzi otrzymasz jedno końcowe podsumowanie procesu myślowego:

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

Go

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-flash-preview"
  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)
      }
    }
  }
}

A oto przykład użycia myślenia z przesyłaniem strumieniowym, który podczas generowania zwraca stopniowe podsumowania:

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

Go

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-flash-preview"

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

Kontrolowanie myślenia

Modele Gemini domyślnie korzystają z myślenia dynamicznego, automatycznie dostosowując ilość wysiłku związanego z rozumowaniem do złożoności żądania użytkownika. Jeśli jednak masz konkretne ograniczenia dotyczące opóźnienia lub chcesz, aby model przeprowadzał bardziej szczegółowe rozumowanie niż zwykle, możesz opcjonalnie użyć parametrów do kontrolowania zachowania myślenia.

Poziomy myślenia (Gemini 3)

Parametr thinkingLevel, zalecany w przypadku modeli Gemini 3 i nowszych, umożliwia kontrolowanie zachowania rozumowania.

W tabeli poniżej znajdziesz szczegółowe informacje o ustawieniach thinkingLevel dla każdego typu modelu:

Poziom myślenia Gemini 3.1 Pro Gemini 3.1 Flash-Lite Gemini 3 Flash Opis
minimal Nieobsługiwane Obsługiwane (domyślnie) Obsługiwane W przypadku większości zapytań odpowiada ustawieniu „bez myślenia”. W przypadku złożonych zadań związanych z kodowaniem model może myśleć bardzo mało. Minimalizuje opóźnienie w przypadku aplikacji do czatu lub aplikacji o wysokiej przepustowości. Pamiętaj, że minimal nie gwarantuje, że myślenie jest wyłączone.
low Obsługiwane Obsługiwane Obsługiwane Minimalizuje opóźnienie i koszty. Najlepsze rozwiązanie w przypadku prostych instrukcji, czatu lub aplikacji o wysokiej przepustowości.
medium Obsługiwane Obsługiwane Obsługiwane Zrównoważone myślenie w przypadku większości zadań.
high Obsługiwane (domyślnie, dynamiczne) Obsługiwane (dynamiczne) Obsługiwane (domyślnie, dynamiczne) Maksymalizuje głębokość rozumowania. Model może znacznie dłużej generować pierwszy token wyjściowy (nie wymagający myślenia), ale wynik będzie bardziej przemyślany.

Poniższy przykład pokazuje, jak ustawić poziom myślenia.

Python

from google import genai
from google.genai import types

client = genai.Client()

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

const ai = new GoogleGenAI({});

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

  console.log(response.text);
}

main();

Go

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-flash-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-flash-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"
    }
  }
}'

Nie możesz wyłączyć myślenia w przypadku modelu Gemini 3.1 Pro. Modele Gemini 3 Flash i Flash-Lite również nie obsługują pełnego wyłączenia myślenia, ale ustawienie minimal oznacza, że model prawdopodobnie nie będzie myśleć (chociaż nadal może). Jeśli nie określisz poziomu myślenia, Gemini użyje domyślnego dynamicznego poziomu myślenia modeli Gemini 3, "high".

Modele z serii Gemini 2.5 nie obsługują parametru thinkingLevel. Zamiast niego użyj parametru thinkingBudget.

Budżety na myślenie

Parametr thinkingBudget, wprowadzony w serii Gemini 2.5, informuje model o konkretnej liczbie tokenów myślenia, które mają być używane do rozumowania.

Poniżej znajdziesz szczegóły konfiguracji parametru thinkingBudget dla każdego typu modelu. Aby wyłączyć myślenie, ustaw wartość thinkingBudget na 0. Ustawienie wartości thinkingBudget na -1 włącza myślenie dynamiczne, co oznacza, że model dostosuje budżet do złożoności żądania.

Model Ustawienie domyślne
(budżet na myślenie nie jest ustawiony)		 Zakres Wyłącz myślenie Włącz myślenie dynamiczne
2.5 Pro Myślenie dynamiczne 128 do 32768 Nie dotyczy: nie można wyłączyć myślenia thinkingBudget = -1 (domyślnie)
2.5 Flash Myślenie dynamiczne 0 do 24576 thinkingBudget = 0 thinkingBudget = -1 (domyślnie)
2.5 Flash (wersja testowa) Myślenie dynamiczne 0 do 24576 thinkingBudget = 0 thinkingBudget = -1 (domyślnie)
2.5 Flash Lite Model nie myśli 512 do 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Lite (wersja testowa) Model nie myśli 512 do 24576 thinkingBudget = 0 thinkingBudget = -1
Robotics-ER 1.6 (wersja testowa) Myślenie dynamiczne 0 do 24576 thinkingBudget = 0 thinkingBudget = -1 (domyślnie)
2.5 Flash Live Native Audio (wersja testowa) (09-2025) Myślenie dynamiczne 0 do 24576 thinkingBudget = 0 thinkingBudget = -1 (domyślnie)

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();

Go

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

W zależności od prompta model może przekroczyć lub nie wykorzystać w pełni budżetu tokenów.

Podpisy procesu myślowego

Interfejs Gemini API jest bezstanowy, więc model traktuje każde żądanie do interfejsu API niezależnie i nie ma dostępu do kontekstu procesu myślowego z poprzednich tur interakcji wieloetapowych.

Aby umożliwić zachowanie kontekstu procesu myślowego w interakcjach wieloetapowych, Gemini zwraca podpisy procesu myślowego, które są zaszyfrowanymi reprezentacjami wewnętrznego procesu myślowego modelu.

  • Modele Gemini 2.5 zwracają podpisy procesu myślowego, gdy myślenie jest włączone i żądanie obejmuje wywoływanie funkcji, w szczególności deklaracje funkcji.
  • Modele Gemini 3 mogą zwracać podpisy procesu myślowego dla wszystkich typów części. Zalecamy, aby zawsze przekazywać wszystkie podpisy w takiej postaci, w jakiej zostały otrzymane, ale w przypadku podpisów wywoływania funkcji jest to wymagane. Więcej informacji znajdziesz na stronie Podpisy procesu myślowego.

Inne ograniczenia dotyczące użycia, które należy wziąć pod uwagę w przypadku wywoływania funkcji:

  • Podpisy są zwracane przez model w innych częściach odpowiedzi, np. w częściach wywoływania funkcji lub tekstowych. Przekaż modelowi całą odpowiedź ze wszystkimi częściami w kolejnych turach.
  • Nie łącz części z podpisami.
  • Nie łącz części z podpisem z inną częścią bez podpisu.

Ceny

Gdy myślenie jest włączone, cena odpowiedzi jest sumą tokenów wyjściowych i tokenów myślenia. Łączną liczbę wygenerowanych tokenów myślenia możesz uzyskać z pola 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}`);

Go

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

Modele myślące generują pełne myśli, aby poprawić jakość ostatecznej odpowiedzi, a następnie podsumowania aby zapewnić wgląd w proces myślowy. Dlatego cena jest oparta na pełnych tokenach myślenia, które model musi wygenerować, aby utworzyć podsumowanie, mimo że z interfejsu API jest zwracane tylko podsumowanie.

Więcej informacji o tokenach znajdziesz w przewodniku Liczenie tokenów.

Sprawdzone metody

W tej sekcji znajdziesz wskazówki dotyczące efektywnego korzystania z modeli myślących. Jak zawsze, najlepsze wyniki uzyskasz, jeśli będziesz postępować zgodnie z naszymi wskazówkami dotyczącymi promptów i sprawdzonymi metodami.

Debugowanie i sterowanie

  • Sprawdzanie rozumowania: jeśli nie otrzymujesz oczekiwanej odpowiedzi od modeli myślących, warto dokładnie przeanalizować podsumowania procesu myślowego Gemini. Możesz zobaczyć, jak model podzielił zadanie i doszedł do wniosku, oraz wykorzystać te informacje, aby poprawić wyniki.

  • Wskazówki dotyczące rozumowania: jeśli oczekujesz szczególnie długiego wyniku, możesz podać w prompcie wskazówki, aby ograniczyć ilość myślenia, z której korzysta model. Dzięki temu możesz zarezerwować więcej tokenów wyjściowych na swoją odpowiedź.

Złożoność zadania

  • Proste zadania (myślenie może być wyłączone): w przypadku prostych żądań, które nie wymagają złożonego rozumowania, takich jak wyszukiwanie faktów lub klasyfikacja, myślenie nie jest wymagane. Przykłady:
    • „Gdzie założono DeepMind?”
    • „Czy ten e-mail zawiera prośbę o spotkanie, czy tylko informacje?”
  • Średnio złożone zadania (domyślne/częściowe myślenie): wiele typowych żądań wymaga pewnego stopnia przetwarzania krok po kroku lub głębszego zrozumienia. Gemini może elastycznie korzystać z funkcji myślenia w przypadku takich zadań jak:
    • Porównanie fotosyntezy i dorastania.
    • Porównanie samochodów elektrycznych i hybrydowych.
  • Trudne zadania (maksymalna zdolność myślenia): w przypadku naprawdę złożonych wyzwań, takich jak rozwiązywanie złożonych problemów matematycznych lub zadań związanych z kodowaniem, zalecamy ustawienie wysokiego budżetu na myślenie. Tego typu zadania wymagają od modelu pełnego wykorzystania możliwości rozumowania i planowania, często obejmującego wiele wewnętrznych etapów przed udzieleniem odpowiedzi. Przykłady:
    • Rozwiąż zadanie 1 w AIME 2025: znajdź sumę wszystkich podstaw całkowitych b > 9, dla których 17b jest dzielnikiem 97b.
    • Napisz kod w Pythonie dla aplikacji internetowej, która wizualizuje dane z giełdy w czasie rzeczywistym, w tym uwierzytelnianie użytkowników. Zadbaj o jak największą wydajność.

Obsługiwane modele, narzędzia i funkcje

Funkcje myślenia są obsługiwane we wszystkich modelach z serii 3 i 2.5. Wszystkie możliwości modelu znajdziesz na stronie przeglądu modelu.

Modele myślące współpracują ze wszystkimi narzędziami i funkcjami Gemini. Dzięki temu modele mogą wchodzić w interakcje z systemami zewnętrznymi, wykonywać kod lub uzyskiwać dostęp do informacji w czasie rzeczywistym, włączając wyniki do swojego rozumowania i ostatecznej odpowiedzi.

Przykłady użycia narzędzi z modelami myślącymi znajdziesz w przewodniku Thinking cookbook.

Co dalej?