Model Gemini 2.5 Flash Image (znany też jako Nano Banana) jest już dostępny w Gemini API. Więcej informacji

Ta strona została przetłumaczona przez Cloud Translation API.

Gemini

Modele z serii Gemini 2.5 wykorzystują wewnętrzny „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.

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

Zanim zaczniesz

Używaj obsługiwanego modelu z serii 2.5 do generowania odpowiedzi. Przed rozpoczęciem korzystania z interfejsu API warto zapoznać się z tymi modelami w AI Studio:

Generowanie treści z myśleniem

Inicjowanie prośby za pomocą modelu myślowego jest podobne do każdej innej prośby o wygenerowanie treści. Główna różnica polega na określeniu w polu model jednego z modeli z obsługą myślenia, 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-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();

Przeczytaj

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

Budżety na myślenie

Parametr thinkingBudget określa liczbę tokenów myślenia, których model ma użyć podczas generowania odpowiedzi. Większa liczba tokenów zwykle pozwala na bardziej szczegółowe rozumowanie, co może być korzystne w przypadku bardziej złożonych zadań. Jeśli ważniejsze jest opóźnienie, użyj niższego budżetu lub wyłącz myślenie, ustawiając wartość thinkingBudget na 0. Ustawienie wartości thinkingBudget na -1 włącza dynamiczne myślenie, co oznacza, że model dostosuje budżet do złożoności żądania.

Funkcja thinkingBudget jest obsługiwana tylko w modelach Gemini 2.5 Flash, 2.5 Pro i 2.5 Flash-Lite. W zależności od promptu model może przekroczyć lub nie wykorzystać w pełni budżetu tokenów.

Poniżej znajdziesz thinkingBudget szczegóły konfiguracji każdego typu modelu.

Model	Ustawienie domyślne (budżet na myślenie nie jest ustawiony)	Zakres	Wyłącz przebieg rozumowania	Włącz myślenie dynamiczne
2.5 Pro	Dynamiczne myślenie: model decyduje, kiedy i ile myśleć	Od `128` do `32768`	Nie dotyczy: nie można wyłączyć myślenia	`thinkingBudget = -1`
2.5 Flash	Dynamiczne myślenie: model decyduje, kiedy i ile myśleć	Od `0` do `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`
2.5 Flash Lite	Model nie myśli	Od `512` do `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();

Przeczytaj

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
          # Thinking off:
          # "thinkingBudget": 0
          # Turn on dynamic thinking:
          # "thinkingBudget": -1
    }
  }
}'

Podsumowania przemyśleń

Podsumowania procesu myślowego to zsyntetyzowane wersje pierwotnych myśli modelu, które pozwalają zrozumieć jego wewnętrzny proces rozumowania. Pamiętaj, że budżety na myślenie dotyczą surowych myśli modelu, a nie podsumowań myśli.

Możesz włączyć podsumowania myśli, ustawiając w konfiguracji żądania wartość includeThoughts na true. Następnie możesz uzyskać dostęp do podsumowania, przeglądając parametr response i sprawdzając wartość logiczną thought.parts

Oto przykład pokazujący, jak włączyć i pobrać podsumowania myśli bez przesyłania strumieniowego, co zwraca jedno końcowe podsumowanie myśli w odpowiedzi:

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

Przeczytaj

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

A oto przykład użycia funkcji myślenia strumieniowego, która podczas generowania zwraca podsumowania kroczące i przyrostowe:

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

Przeczytaj

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

Podpisy myśli

Standardowe wywołania interfejsu Gemini API do generowania tekstu i treści są bezstanowe, więc podczas korzystania z funkcji myślenia w interakcjach wieloetapowych (np. na czacie) model nie ma dostępu do kontekstu myślenia z poprzednich etapów.

Możesz zachować kontekst myślowy za pomocą sygnatur myśli, które są zaszyfrowanymi reprezentacjami wewnętrznego procesu myślowego modelu. Gdy włączone są funkcje myślenia i wywoływania funkcji, model zwraca w obiekcie odpowiedzi sygnatury myślenia. Aby mieć pewność, że model zachowuje kontekst w wielu turach rozmowy, musisz przekazywać sygnatury myśli z powrotem do modelu w kolejnych żądaniach.

Podpisy myśli otrzymasz, gdy:

Myślenie jest włączone i generowane są myśli.
Żądanie zawiera deklaracje funkcji.

Przykład myślenia z wykorzystaniem wywołań funkcji znajdziesz na stronie Wywoływanie funkcji.

Inne ograniczenia dotyczące wywoływania funkcji, o których warto pamiętać:

Sygnatury są zwracane przez model w innych częściach odpowiedzi, np. w wywołaniach funkcji lub częściach tekstowych. W kolejnych turach zwróć modelowi całą odpowiedź ze wszystkimi częściami.
Nie łącz części z sygnaturami.
Nie łącz części z podpisem z częścią bez podpisu.

Ceny

Gdy myślenie jest włączone, cena odpowiedzi to suma 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}`);

Przeczytaj

// ...
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ślowe generują pełne myśli, aby poprawić jakość ostatecznej odpowiedzi, a następnie wyświetlają podsumowania, które pozwalają zrozumieć proces myślowy. Cena jest więc oparta na pełnych tokenach myśli, których model potrzebuje do wygenerowania podsumowania, mimo że z interfejsu API wychodzi tylko podsumowanie.

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

Obsługiwane modele

Funkcje myślenia są obsługiwane na wszystkich modelach z serii 2.5. Wszystkie możliwości modelu znajdziesz na stronie informacji o modelu.

Sprawdzone metody

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

Debugowanie i sterowanie

Sprawdzanie uzasadnienia: jeśli modele myślowe nie dają oczekiwanych odpowiedzi, warto dokładnie przeanalizować podsumowania myśli Gemini. Możesz zobaczyć, jak podzielił zadanie i doszedł do wniosku, a także wykorzystać te informacje, aby poprawić wyniki.
Podaj wskazówki dotyczące uzasadnienia: jeśli oczekujesz szczególnie długiego wyniku, możesz podać w prompcie wskazówki, aby ograniczyć ilość myślenia, jakiej używa 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, np. wyszukiwania faktów lub klasyfikacji, myślenie nie jest wymagane. Przykłady:
- „Gdzie powstała firma DeepMind?”
- „Czy ten e-mail zawiera prośbę o spotkanie, czy tylko informacje?”
Średnio złożone zadania (domyślne/wymagające pewnego zastanowienia): wiele typowych próśb wymaga przetwarzania krok po kroku lub głębszego zrozumienia. Gemini może elastycznie wykorzystywać funkcje myślenia do wykonywania takich zadań jak:
- Porównaj fotosyntezę i dorastanie.
- Porównaj samochody elektryczne i hybrydowe.
Trudne zadania (maksymalne możliwości rozumowania): w przypadku naprawdę złożonych zadań, takich jak rozwiązywanie skomplikowanych problemów matematycznych lub zadań związanych z kodowaniem, zalecamy ustawienie wysokiego budżetu na rozumowanie. Tego typu zadania wymagają od modelu pełnego wykorzystania możliwości rozumowania i planowania, często obejmują wiele wewnętrznych kroków przed udzieleniem odpowiedzi. Przykłady:
- Rozwiąż zadanie 1 z AIME 2025: znajdź sumę wszystkich podstaw całkowitych b > 9, dla których 17_b jest dzielnikiem liczby 97_b.
- Napisz kod w Pythonie dla aplikacji internetowej, która wizualizuje dane giełdowe w czasie rzeczywistym, w tym uwierzytelnianie użytkowników. Zadbaj o jak największą wydajność.

Myślenie z wykorzystaniem narzędzi i możliwości

Modele myślowe działają ze wszystkimi narzędziami i funkcjami Gemini. Umożliwia to modelom interakcję z systemami zewnętrznymi, wykonywanie kodu i dostęp do informacji w czasie rzeczywistym oraz uwzględnianie wyników w procesie wnioskowania i odpowiedzi końcowej.

Narzędzie wyszukiwania umożliwia modelowi wysyłanie zapytań do wyszukiwarki Google w celu znajdowania aktualnych informacji lub informacji wykraczających poza dane treningowe. Jest to przydatne w przypadku pytań dotyczących ostatnich wydarzeń lub bardzo szczegółowych tematów.
Narzędzie do wykonywania kodu umożliwia modelowi generowanie i uruchamianie kodu w Pythonie w celu wykonywania obliczeń, manipulowania danymi lub rozwiązywania problemów, które najlepiej rozwiązywać algorytmicznie. Model otrzymuje dane wyjściowe kodu i może ich użyć w swojej odpowiedzi.
Dzięki uporządkowanym danym wyjściowym możesz ograniczyć Gemini do odpowiadania w formacie JSON. Jest to szczególnie przydatne w przypadku integrowania danych wyjściowych modelu z aplikacjami.
Wywoływanie funkcji łączy model myślenia z narzędziami zewnętrznymi i interfejsami API, dzięki czemu może on określać, kiedy wywołać odpowiednią funkcję i jakie parametry podać.
Kontekst URL dostarcza modelowi adresy URL jako dodatkowy kontekst dla promptu. Model może następnie pobrać treści z adresów URL i wykorzystać je do udzielenia odpowiedzi.

Przykłady użycia narzędzi z modelami myślowymi znajdziesz w książce kucharskiej dotyczącej myślenia.

Co dalej?

Aby zapoznać się ze szczegółowymi przykładami, takimi jak:
- Korzystanie z narzędzi w połączeniu z myśleniem
- Streaming z przebiegiem rozumowania
- Dostosowywanie budżetu na myślenie do różnych wyników
i inne, wypróbuj naszą Książkę kucharską myślenia.
Informacje o zakresie są teraz dostępne w naszym przewodniku Zgodność z OpenAI.
Więcej informacji o modelach Gemini 2.5 Pro, Gemini Flash 2.5 i Gemini 2.5 Flash-Lite znajdziesz na stronie modelu.