Gemini się zastanawia

Modele z serii Gemini 3 i 2.5 wykorzystują „proces myślowy”, 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.

Gdy używasz modelu myślenia, Gemini przeprowadza wewnętrzne rozumowanie przed udzieleniem odpowiedzi. Interfejs API interakcji udostępnia to rozumowanie za pomocą thought kroków, czyli specjalnych kroków, które pojawiają się chronologicznie obok wywołań funkcji, danych wejściowych użytkownika lub danych wyjściowych modelu w steps tablicy.

Każdy krok myślowy zawiera 2 pola:

Pole Wymagane Opis
signature ✅ Tak zaszyfrowana reprezentacja wewnętrznego stanu rozumowania modelu. Zawsze obecne, nawet gdy model wykonuje minimalne rozumowanie.
summary ❌ Nie Tablica treści (tekst lub obrazy) podsumowująca uzasadnienie. Może być pusta w zależności od konfiguracji thinking_summaries, tego, czy model przeprowadził wystarczającą ilość rozumowania, lub typu treści (np. latentne obrazy mogą nie mieć podsumowań tekstowych).

Interakcje z myśleniem

Rozpoczęcie interakcji z modelem myślowym jest podobne do każdego innego żądania interakcji. W polu model określ jeden z modeli z obsługą myślenia:

Python

# This will only work for SDK newer than 2.0.0
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="Explain the concept of Occam's Razor and provide a simple, everyday example."
)
print(interaction.steps[-1].content[0].text)

JavaScript

// This will only work for SDK newer than 2.0.0
import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    model: "gemini-3-flash-preview",
    input: "Explain the concept of Occam's Razor and provide a simple, everyday example."
});
console.log(interaction.steps.at(-1).content[0].text);

REST

# Specifies the API revision to avoid breaking changes when they become default
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Api-Revision: 2026-05-20" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3-flash-preview",
    "input": "Explain the concept of Occam'\''s Razor and provide a simple example."
  }'

Podsumowania myśli

Podsumowania myśli zawierają informacje o wewnętrznym procesie rozumowania modelu. Domyślnie zwracany jest tylko wynik końcowy. Podsumowania myśli możesz włączyć, klikając thinking_summaries:

Python

# This will only work for SDK newer than 2.0.0
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="What is the sum of the first 50 prime numbers?",
    generation_config={
        "thinking_summaries": "auto"
    }
)

for step in interaction.steps:
    if step.type == "thought":
        print("Thought summary:")
        if step.summary:
            for content_block in step.summary:
                if content_block.type == "text":
                    print(content_block.text)
        print()
    elif step.type == "model_output":
        for content_block in step.content:
            if content_block.type == "text":
                print("Answer:")
                print(content_block.text)
                print()

JavaScript

// This will only work for SDK newer than 2.0.0
import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    model: "gemini-3-flash-preview",
    input: "What is the sum of the first 50 prime numbers?",
    generation_config: {
        thinking_summaries: "auto"
    }
});

for (const step of interaction.steps) {
    if (step.type === "thought") {
        console.log("Thought summary:");
        if (step.summary) {
            for (const contentBlock of step.summary) {
                if (contentBlock.type === "text") console.log(contentBlock.text);
            }
        }
    } else if (step.type === "model_output") {
        for (const contentBlock of step.content) {
            if (contentBlock.type === "text") {
                console.log("Answer:");
                console.log(contentBlock.text);
            }
        }
    }
}

REST

# Specifies the API revision to avoid breaking changes when they become default
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Api-Revision: 2026-05-20" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3-flash-preview",
    "input": "What is the sum of the first 50 prime numbers?",
    "generation_config": {
      "thinking_summaries": "auto"
    }
  }'

Blok myśli może zawierać tylko podpis bez podsumowania w tych przypadkach:

  • Proste żądania, w przypadku których model nie przeprowadził wystarczającego rozumowania, aby wygenerować podsumowanie
  • thinking_summaries: "none", w przypadku których podsumowania są wyraźnie wyłączone.
  • Niektóre typy treści, np. obrazy, mogą nie mieć podsumowań tekstowych.

Kod powinien zawsze obsługiwać bloki myślowe, w których pole summary jest puste lub nie występuje.

Streaming z myśleniem

Użyj przesyłania strumieniowego, aby otrzymywać przyrostowe podsumowania myśli podczas generowania. Bloki myśli są dostarczane za pomocą zdarzeń wysyłanych przez serwer (SSE) z 2 różnymi typami zmian:

Typ delty Zawiera Kiedy wysłano
thought_summary treści podsumowujące w formie tekstu lub obrazu; Co najmniej 1 zmiana z przyrostowym podsumowaniem
thought_signature Podpis kryptograficzny ostatnia zmiana przed step.stop

Python

# This will only work for SDK newer than 2.0.0
from google import genai

client = genai.Client()

prompt = """
Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue.
Alice does not live in the red house.
Bob does not live in the green house.
Carol does not live in the red or green house.
Which house does each person live in?
"""

thoughts = ""
answer = ""

stream = client.interactions.create(
    model="gemini-3-flash-preview",
    input=prompt,
    generation_config={
        "thinking_summaries": "auto"
    },
    stream=True
)

for event in stream:
    if event.event_type == "step.delta":
        if event.delta.type == "thought_summary":
            if not thoughts:
                print("Thinking...")
            summary_text = event.delta.content.text
            print(f"[Thought] {summary_text}", end="")
            thoughts += summary_text
        elif event.delta.type == "text" and event.delta.text:
            if not answer:
                print("\nAnswer:")
            print(event.delta.text, end="")
            answer += event.delta.text

JavaScript

// This will only work for SDK newer than 2.0.0
import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const prompt = `Alice, Bob, and Carol each live in a different house on the same
street: red, green, and blue. Alice does not live in the red house.
Bob does not live in the green house.
Carol does not live in the red or green house.
Which house does each person live in?`;

let thoughts = "";
let answer = "";

const stream = await client.interactions.create({
    model: "gemini-3-flash-preview",
    input: prompt,
    generation_config: {
        thinking_summaries: "auto"
    },
    stream: true
});

for await (const event of stream) {
    if (event.event_type === "step.delta") {
        if (event.delta.type === "thought_summary") {
            if (!thoughts) console.log("Thinking...");
            const text = event.delta.content?.text || "";
            process.stdout.write(`[Thought] ${text}`);
            thoughts += text;
        } else if (event.delta.type === "text" && event.delta.text) {
            if (!answer) console.log("\nAnswer:");
            process.stdout.write(event.delta.text);
            answer += event.delta.text;
        }
    }
}

REST

# Specifies the API revision to avoid breaking changes when they become default
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Api-Revision: 2026-05-20" \
  -H 'Content-Type: application/json' \
  --no-buffer \
  -d '{
    "model": "gemini-3-flash-preview",
    "input": "Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue. Alice does not live in the red house. Bob does not live in the green house. Carol does not live in the red or green house. Which house does each person live in?",
    "generation_config": {
      "thinking_summaries": "auto"
    },
    "stream": true
  }'

Odpowiedź strumieniowa korzysta ze zdarzeń wysyłanych przez serwer (SSE) i składa się z kroków i zdarzeń. Zobacz przykład poniżej.

event: interaction.created
data: {"interaction":{"id":"v1_xxx","status":"in_progress","object":"interaction","model":"gemini-3-flash-preview"},"event_type":"interaction.created"}

event: step.start
data: {"index":0,"step":{"signature":"","summary":[{"text":"**Evaluating the clues**\n\nI'm considering...","type":"text"}],"type":"thought"},"event_type":"step.start"}

event: step.delta
data: {"index":0,"delta":{"signature":"EpoGCpcGAXLI2nx/...","type":"thought_signature"},"event_type":"step.delta"}

event: step.stop
data: {"index":0,"event_type":"step.stop"}

event: step.start
data: {"index":1,"step":{"content":[{"text":"Based on the clues provided, here","type":"text"}],"type":"model_output"},"event_type":"step.start"}

event: step.delta
data: {"index":1,"delta":{"text":" is the answer to your question...","type":"text"},"event_type":"step.delta"}

event: step.stop
data: {"index":1,"event_type":"step.stop"}

event: interaction.completed
data: {"interaction":{"id":"v1_xxx","status":"completed","usage":{"total_tokens":530,"total_input_tokens":62,"total_output_tokens":171,"total_thought_tokens":297}},"event_type":"interaction.completed"}

event: done
data: [DONE]

Kontrolowanie myślenia

Modele Gemini domyślnie stosują dynamiczne myślenie, automatycznie dostosowując poziom rozumowania do złożoności żądania. Możesz kontrolować to zachowanie za pomocą parametru thinking_level.

Model Domyślne myślenie Obsługiwane poziomy
gemini-3.1-pro-preview Włączone (wysokie) niski, średni, wysoki
gemini-3-flash-preview Włączone (wysokie) minimalny, niski, średni, wysoki
gemini-3-pro-preview Włączone (wysokie) niski, wysoki
gemini-2.5-pro Wł. niski, średni, wysoki
gemini-2.5-flash Wł. niski, średni, wysoki
gemini-2.5-flash-lite Wył. niski, średni, wysoki

Python

# This will only work for SDK newer than 2.0.0
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="Provide a list of 3 famous physicists and their key contributions",
    generation_config={
        "thinking_level": "low"
    }
)
print(interaction.steps[-1].content[0].text)

JavaScript

// This will only work for SDK newer than 2.0.0
import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    model: "gemini-3-flash-preview",
    input: "Provide a list of 3 famous physicists and their key contributions",
    generation_config: {
        thinking_level: "low"
    }
});
console.log(interaction.steps.at(-1).content[0].text);

REST

# Specifies the API revision to avoid breaking changes when they become default
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Api-Revision: 2026-05-20" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3-flash-preview",
    "input": "Provide a list of 3 famous physicists and their key contributions",
    "generation_config": {
      "thinking_level": "low"
    }
  }'

Podpisy myśli

Sygnatury myśli to zaszyfrowane reprezentacje wewnętrznego rozumowania modelu. Muszą one zachowywać ciągłość rozumowania w interakcjach wieloetapowych.

Interfejs Interactions API znacznie upraszcza obsługę podpisów myśli w porównaniu z interfejsem generateContent API.

Domyślnie, gdy używasz interfejsu API interakcji w trybie stanowym (ustawiając store: true i przekazując previous_interaction_id w kolejnych turach), serwer automatycznie zarządza stanem rozmowy, w tym wszystkimi blokami myśli i sygnaturami. W tym trybie nie musisz nic robić w związku z podpisami. Są one obsługiwane w całości po stronie serwera.

Tryb bezstanowy

Jeśli zarządzasz stanem rozmowy samodzielnie (tryb bezstanowy) i w każdym żądaniu przekazujesz pełną historię danych wejściowych i wyjściowych:

  • MUSISZ zawsze ponownie wysyłać wszystkie bloki thought dokładnie w takiej postaci, w jakiej zostały otrzymane z modelu.
  • Nie należy usuwać ani modyfikować bloków myślowych z historii, ponieważ zawierają one sygnatury wymagane do dalszego wnioskowania przez model.
  • Podczas przełączania modeli w ramach sesji nadal należy ponownie wysyłać bloki myślowe poprzedniego modelu. Zgodnością zarządza backend.

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

Python

# This will only work for SDK newer than 2.0.0
# ...
print("Thoughts tokens:", interaction.usage.total_thought_tokens)
print("Output tokens:", interaction.usage.total_output_tokens)

JavaScript

// This will only work for SDK newer than 2.0.0
// ...
console.log(`Thoughts tokens: ${interaction.usage.total_thought_tokens}`);
console.log(`Output tokens: ${interaction.usage.total_output_tokens}`);

Modele myślowe generują pełne myśli, aby poprawić jakość ostatecznej odpowiedzi, a następnie wyświetlają podsumowania, które pozwalają zrozumieć proces myślowy. Ceny są oparte na pełnych tokenach myśli, które model musi wygenerować, mimo że interfejs API zwraca tylko podsumowanie.

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

Sprawdzone metody

Skutecznie korzystaj z modeli myślowych, postępując zgodnie z tymi wskazówkami.

  • Sprawdzanie uzasadnienia: analizuj podsumowania myśli, aby zrozumieć przyczyny niepowodzeń i ulepszyć prompty.
  • Kontrolowanie budżetu na myślenie: poproś model, aby mniej myślał w przypadku długich wyników, aby zaoszczędzić tokeny.
  • Proste zadania: wymagają minimalnego wysiłku umysłowego w zakresie wyszukiwania faktów lub klasyfikacji (np. „Gdzie powstała firma DeepMind?”).
  • Moderowanie zadań: używaj domyślnego sposobu myślenia do porównywania koncepcji lub kreatywnego rozumowania (np. porównywania samochodów elektrycznych i hybrydowych).
  • Złożone zadania: używaj maksymalnego poziomu myślenia do zaawansowanego kodowania, rozwiązywania problemów matematycznych lub planowania wieloetapowego (np. rozwiązywania problemów matematycznych z AIME).

Co dalej?