Wypróbuj nowy model Gemini 3.1 Flash TTS Preview, który umożliwia ekspresywną generację mowy w wielu językach.

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 przypadku złożonych zadań, 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 myśleniem

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 myśli

Podsumowania myśli 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ń myśli.

Aby włączyć podsumowania myśli, ustaw w konfiguracji żądania parametr 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 myśli bez przesyłania strumieniowego, co powoduje zwrócenie w odpowiedzi pojedynczego, końcowego podsumowania myśli:

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óre podczas generowania zwraca stopniowe, przyrostowe 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 określone ograniczenia dotyczące opóźnienia lub chcesz, aby model angażował się w głębsze 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 minimalnie. 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 koszt. 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, dynamicznie)	Obsługiwane (dynamicznie)	Obsługiwane (domyślnie, dynamicznie)	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 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 parametr thinkingBudget na 0. Ustawienie parametru 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 myśli

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

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

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

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łania funkcji lub tekstu. 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 tworzą podsumowania, aby zapewnić wgląd w proces myślowy. Dlatego cena jest oparta na pełnych tokenach myśli, które model musi wygenerować, aby utworzyć podsumowanie, mimo że z interfejsu API wychodzi tylko podsumowanie.

Więcej informacji o tokenach znajdziesz w przewodniku po zliczaniu 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 uzyskujesz oczekiwanej odpowiedzi od modeli myślących, warto dokładnie przeanalizować podsumowania myśli 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, które ograniczą ilość myślenia używanego przez 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 konieczne. 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 17_b jest dzielnikiem 97_b.
- 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 po myśleniu.

Co dalej?

Informacje o myśleniu znajdziesz w przewodniku po zgodności z OpenAI.