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

Myślenie

Gemini 2.5 mogą korzystać z wewnętrznego „procesu myślowego”, który znacznie poprawia ich zdolności 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.

Modele myślowe oferują te konfiguracje i opcje:

Budżet na myślenie: możesz skonfigurować, ile „myślenia” może wykonać model, korzystając z budżetu na myślenie. Ta konfiguracja jest szczególnie ważna, jeśli priorytetem jest zmniejszenie opóźnienia lub kosztów. Zapoznaj się też z porównaniem trudności zadań, aby określić, w jakim stopniu model może potrzebować swoich możliwości myślenia.
Podsumowania myśli: możesz włączyć podsumowania myśli, aby dołączyć je do wygenerowanej odpowiedzi. Te podsumowania to zsyntetyzowane wersje surowych przemyśleń modelu, które pozwalają zrozumieć jego wewnętrzny proces rozumowania.
Sygnatury myśli: pakiety SDK automatycznie obsługują sygnatury myśli, co zapewnia modelowi dostęp do kontekstu myśli z poprzednich tur, zwłaszcza podczas korzystania z wywoływania funkcji.Firebase AI Logic

Zapoznaj się ze sprawdzonymi metodami i wskazówkami dotyczącymi promptów dotyczącymi korzystania z modeli myślowych.

Używanie modelu myślowego

Użyj modelu myślowego tak samo jak każdego innego Gemini modelu (zainicjuj wybranego Gemini API dostawcę, utwórz GenerativeModel instancję itp.). Modele te mogą być używane do generowania tekstu lub kodu, np. generowania danych wyjściowych w formacie strukturalnym lub analizowania danych wejściowych w różnych formatach (np. obrazów, filmów, dźwięku lub plików PDF). Podczas przesyłania strumieniowego danych wyjściowych możesz nawet używać modeli myślowych.

Modele obsługujące tę funkcję

Ta funkcja jest obsługiwana tylko przez modele Gemini 2.5.

gemini-2.5-pro
gemini-2.5-flash
gemini-2.5-flash-lite

Sprawdzone metody i wskazówki dotyczące promptów w przypadku korzystania z modeli myślowych

Zalecamy przetestowanie promptu w Google AI Studio lub Vertex AI Studio, gdzie możesz zobaczyć cały proces myślowy. Możesz zidentyfikować obszary, w których model mógł się pomylić, aby dopracować prompty i uzyskiwać bardziej spójne i dokładne odpowiedzi.

Zacznij od ogólnego prompta opisującego oczekiwany rezultat i obserwuj wstępne przemyślenia modelu na temat tego, jak określa on swoją odpowiedź. Jeśli odpowiedź nie jest zgodna z oczekiwaniami, pomóż modelowi wygenerować lepszą odpowiedź, korzystając z jednej z tych technik promptowania:

podamy szczegółowe instrukcje;
Podaj kilka przykładów par danych wejściowych i wyjściowych.
Podaj wskazówki dotyczące sposobu formułowania i formatowania wyników oraz odpowiedzi.
Podaj konkretne kroki weryfikacji

Oprócz promptów możesz też skorzystać z tych rekomendacji:

Ustaw instrukcje systemowe, które są jak „wstęp” dodawany przed tym, jak model zostanie poddany dalszym instrukcjom z promptu lub użytkownika końcowego. Pozwalają one sterować działaniem modelu w zależności od konkretnych potrzeb i przypadków użycia.
Ustaw budżet na myślenie, aby skonfigurować, ile czasu model może poświęcić na myślenie. Jeśli ustawisz niski budżet, model nie będzie „zbyt długo” myśleć nad odpowiedzią. Jeśli ustawisz wysoki budżet, model będzie mógł w razie potrzeby dłużej się zastanawiać. Ustalenie budżetu na myślenie powoduje też zarezerwowanie większej części całkowitego limitu tokenów wyjściowych na rzeczywistą odpowiedź.
Włącz monitorowanie AI w Firebasekonsoli, aby śledzić liczbę tokenów przetwarzania i opóźnienie żądań, w których włączono przetwarzanie. Jeśli masz włączone podsumowania myśli, będą one wyświetlane w konsoli, w której możesz sprawdzić szczegółowe uzasadnienie modelu, aby debugować i dopracowywać prompty.

Kontrolowanie budżetu na myślenie

Aby kontrolować, ile czasu model może poświęcić na myślenie w celu wygenerowania odpowiedzi, możesz określić liczbę tokenów budżetu na myślenie, których może użyć.

Możesz ręcznie ustawić budżet na myślenie w sytuacjach, w których możesz potrzebować więcej lub mniej tokenów niż domyślny budżet na myślenie. Szczegółowe wskazówki dotyczące złożoności zadań i sugerowanych budżetów znajdziesz w dalszej części tej sekcji. Oto kilka ogólnych wskazówek:

Ustaw niski budżet na myślenie, jeśli czas oczekiwania jest ważny lub w przypadku mniej złożonych zadań.
Ustaw wysoki budżet na myślenie w przypadku bardziej złożonych zadań

Ustawianie budżetu na myślenie

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod dostawcy.

Ustaw budżet na myślenie w GenerationConfig podczas tworzenia instancji GenerativeModel. Konfiguracja jest utrzymywana przez cały okres istnienia instancji. Jeśli chcesz używać różnych budżetów na myślenie w przypadku różnych żądań, utwórz instancje GenerativeModel skonfigurowane z każdym budżetem.

Więcej informacji o obsługiwanych wartościach budżetu na myślenie znajdziesz w dalszej części tej sekcji.

Swift

Ustaw budżet na myślenie w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(thinkingBudget: 1024)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      thinkingBudget = 1024
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_MODEL_NAME",
  generationConfig,
)

// ...

Java

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setThinkingBudget(1024)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
const generationConfig = {
  thinkingConfig: {
    thinkingBudget: 1024
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_MODEL_NAME", generationConfig });

// ...

Dart

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
final thinkingConfig = ThinkingConfig(thinkingBudget: 1024);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  config: generationConfig,
);

// ...

Unity

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
var thinkingConfig = new ThinkingConfig(thinkingBudget: 1024);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

Obsługiwane wartości budżetu na myślenie

W tabeli poniżej znajdziesz wartości budżetu na myślenie, które możesz ustawić dla każdego modelu, konfigurując thinkingBudget modelu.

Model	Wartość domyślna	Dostępny zakres budżetu na myślenie		Wartość, która wyłącza myślenie	Wartość umożliwiająca dynamiczne myślenie
Model	Wartość domyślna			Wartość, która wyłącza myślenie	Wartość umożliwiająca dynamiczne myślenie	Wartość minimalna	Wartość maksymalna
Gemini 2.5 Pro	`8,192`	`128`	`32,768`	Nie można wyłączyć	`-1`
Gemini 2.5 Flash	`8,192`	`1`	`24,576`	`0`	`-1`
Gemini 2.5 Flash‑Lite	`0` (myślenie jest domyślnie wyłączone)	`512`	`24,576`	`0` (lub w ogóle nie konfiguruj budżetu na myślenie)	`-1`

Wyłącz przebieg rozumowania

W przypadku niektórych łatwiejszych zadań zdolność myślenia nie jest konieczna i wystarczy tradycyjne wnioskowanie. Jeśli priorytetem jest zmniejszenie opóźnienia, możesz nie chcieć, aby model poświęcał więcej czasu niż to konieczne na wygenerowanie odpowiedzi.

W takich sytuacjach możesz wyłączyć (lub zatrzymać) myślenie:

Gemini 2.5 Pro: myślenie nie może być wyłączone
Gemini 2.5 Flash: ustaw thinkingBudget na 0 tokenów
Gemini 2.5 Flash‑Lite: myślenie jest domyślnie wyłączone

Włączanie dynamicznego myślenia

Możesz pozwolić modelowi decydować, kiedy i ile czasu poświęca na myślenie (tzw. dynamiczne myślenie), ustawiając thinkingBudget na -1. Model może używać dowolnej liczby tokenów, jaką uzna za odpowiednią, aż do maksymalnej wartości tokena wymienionej powyżej.

Złożoność zadania

Łatwe zadania – myślenie można wyłączyć
Proste żądania, które nie wymagają złożonego rozumowania, np. wyszukiwanie faktów lub klasyfikacja. Przykłady:
- „Gdzie powstała firma DeepMind?”
- „Czy ten e-mail zawiera prośbę o spotkanie, czy tylko informacje?”
Średnie zadania – wymagany budżet domyślny lub dodatkowy budżet na przemyślenia
Typowe prośby, które wymagają pewnego stopnia przetwarzania krok po kroku lub głębszego zrozumienia. Przykłady:
- „Utwórz analogię między fotosyntezą a dorastaniem”.
- „Porównaj samochody elektryczne i hybrydowe”.
Trudne zadania – może być potrzebny maksymalny budżet na myślenie
Naprawdę złożone wyzwania, takie jak rozwiązywanie skomplikowanych zadań matematycznych lub pisanie kodu. Tego typu zadania wymagają od modelu pełnego zaangażowania możliwości rozumowania i planowania, często obejmują wiele wewnętrznych kroków, zanim zostanie udzielona odpowiedź. Przykłady:
- „Rozwiąż zadanie 1 z 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 rynku akcji w czasie rzeczywistym, w tym uwierzytelnianie użytkowników. Zadbaj o to, aby była jak najbardziej wydajna”.

Uwzględnianie w odpowiedziach podsumowań myśli

Podsumowania myśli to zsyntetyzowane wersje surowych myśli modelu, które dostarczają informacji o wewnętrznym procesie rozumowania modelu.

Oto kilka powodów, dla których warto uwzględniać podsumowania myśli w odpowiedziach:

Podsumowanie przemyśleń możesz wyświetlać w interfejsie aplikacji lub udostępniać użytkownikom. Podsumowanie jest zwracane jako osobna część odpowiedzi, dzięki czemu masz większą kontrolę nad tym, jak jest ono wykorzystywane w Twojej aplikacji.
Jeśli włączysz też monitorowanie AI w Firebasekonsoli, w konsoli będą wyświetlane podsumowania myśli, w których możesz sprawdzić szczegółowe uzasadnienie modelu, aby debugować i dopracowywać prompty.

Oto kilka najważniejszych informacji o podsumowaniach myśli:

Podsumowania myśli nie są kontrolowane przez budżety na myślenie (budżety mają zastosowanie tylko do surowych myśli modelu). Jeśli jednak myślenie jest wyłączone, model nie zwróci podsumowania myśli.
Podsumowania myśli są traktowane jako część zwykłej odpowiedzi w formie wygenerowanego tekstu i są liczone jako tokeny wyjściowe.

Włącz podsumowania myśli

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod dostawcy.

Podsumowania myśli możesz włączyć, ustawiając wartość includeThoughts na true w konfiguracji modelu. Podsumowanie możesz wyświetlić, sprawdzając pole thoughtSummary w odpowiedzi.

Oto przykład, który pokazuje, jak włączyć i pobrać podsumowania myśli w odpowiedzi:

Swift

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(includeThoughts: true)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
)

let response = try await model.generateContent("solve x^2 + 4x + 4 = 0")

// Handle the response that includes thought summaries
if let thoughtSummary = response.thoughtSummary {
  print("Thought Summary: \(thoughtSummary)")
}
guard let text = response.text else {
  fatalError("No text in response.")
}
print("Answer: \(text)")

Kotlin

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      includeThoughts = true
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_MODEL_NAME",
  generationConfig,
)

val response = model.generateContent("solve x^2 + 4x + 4 = 0")

// Handle the response that includes thought summaries
response.thoughtSummary?.let {
    println("Thought Summary: $it")
}
response.text?.let {
    println("Answer: $it")
}

Java

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setIncludeThoughts(true)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// Handle the response that includes thought summaries
ListenableFuture responseFuture = model.generateContent("solve x^2 + 4x + 4 = 0");
Futures.addCallback(responseFuture, new FutureCallback() {
    @Override
    public void onSuccess(GenerateContentResponse response) {
        if (response.getThoughtSummary() != null) {
            System.out.println("Thought Summary: " + response.getThoughtSummary());
        }
        if (response.getText() != null) {
            System.out.println("Answer: " + response.getText());
        }
    }

    @Override
    public void onFailure(Throwable t) {
        // Handle error
    }
}, MoreExecutors.directExecutor());

Web

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
const generationConfig = {
  thinkingConfig: {
    includeThoughts: true
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_MODEL_NAME", generationConfig });

const result = await model.generateContent("solve x^2 + 4x + 4 = 0");
const response = result.response;

// Handle the response that includes thought summaries
if (response.thoughtSummary()) {
    console.log(`Thought Summary: ${response.thoughtSummary()}`);
}
const text = response.text();
console.log(`Answer: ${text}`);

Dart

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
final thinkingConfig = ThinkingConfig(includeThoughts: true);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  generationConfig: generationConfig,
);

final response = await model.generateContent('solve x^2 + 4x + 4 = 0');

// Handle the response that includes thought summaries
if (response.thoughtSummary != null) {
  print('Thought Summary: ${response.thoughtSummary}');
}
if (response.text != null) {
  print('Answer: ${response.text}');
}

Unity

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
var thinkingConfig = new ThinkingConfig(includeThoughts: true);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
);

var response = await model.GenerateContentAsync("solve x^2 + 4x + 4 = 0");

// Handle the response that includes thought summaries
if (response.ThoughtSummary != null) {
    Debug.Log($"Thought Summary: {response.ThoughtSummary}");
}
if (response.Text != null) {
    Debug.Log($"Answer: {response.Text}");
}

Wyświetlanie odpowiedzi i podsumowania procesu myślowego

# Example Response:
#     Okay, let's solve the quadratic equation x² + 4x + 4 = 0.
#     ...
#     **Answer:**
#     The solution to the equation x² + 4x + 4 = 0 is x = -2. This is a repeated root (or a root with multiplicity 2).

# Example Thought Summary:
#     **My Thought Process for Solving the Quadratic Equation**
#
#     Alright, let's break down this quadratic, x² + 4x + 4 = 0. First things first:
#     it's a quadratic; the x² term gives it away, and we know the general form is
#     ax² + bx + c = 0.
#
#     So, let's identify the coefficients: a = 1, b = 4, and c = 4. Now, what's the
#     most efficient path to the solution? My gut tells me to try factoring; it's
#     often the fastest route if it works. If that fails, I'll default to the quadratic
#     formula, which is foolproof. Completing the square? It's good for deriving the
#     formula or when factoring is difficult, but not usually my first choice for
#     direct solving, but it can't hurt to keep it as an option.
#
#     Factoring, then. I need to find two numbers that multiply to 'c' (4) and add
#     up to 'b' (4). Let's see... 1 and 4 don't work (add up to 5). 2 and 2? Bingo!
#     They multiply to 4 and add up to 4. This means I can rewrite the equation as
#     (x + 2)(x + 2) = 0, or more concisely, (x + 2)² = 0. Solving for x is now
#     trivial: x + 2 = 0, thus x = -2.
#
#     Okay, just to be absolutely certain, I'll run the quadratic formula just to
#     double-check. x = [-b ± √(b² - 4ac)] / 2a. Plugging in the values, x = [-4 ±
#     √(4² - 4 * 1 * 4)] / (2 * 1). That simplifies to x = [-4 ± √0] / 2. So, x =
#     -2 again - a repeated root. Nice.
#
#     Now, let's check via completing the square. Starting from the same equation,
#     (x² + 4x) = -4. Take half of the b-value (4/2 = 2), square it (2² = 4), and
#     add it to both sides, so x² + 4x + 4 = -4 + 4. Which simplifies into (x + 2)²
#     = 0. The square root on both sides gives us x + 2 = 0, therefore x = -2, as
#      expected.
#
#     Always, *always* confirm! Let's substitute x = -2 back into the original
#     equation: (-2)² + 4(-2) + 4 = 0. That's 4 - 8 + 4 = 0. It checks out.
#
#     Conclusion: the solution is x = -2. Confirmed.

Wyświetlanie podsumowań myśli

Możesz też wyświetlić podsumowania myśli, jeśli zdecydujesz się przesyłać strumieniowo odpowiedź za pomocą generateContentStream. Podczas generowania odpowiedzi będą zwracane bieżące, przyrostowe podsumowania.

Swift

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(includeThoughts: true)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
)

let stream = try model.generateContentStream("solve x^2 + 4x + 4 = 0")

// Handle the streamed response that includes thought summaries
var thoughts = ""
var answer = ""
for try await response in stream {
  if let thought = response.thoughtSummary {
    if thoughts.isEmpty {
      print("--- Thoughts Summary ---")
    }
    print(thought)
    thoughts += thought
  }

  if let text = response.text {
    if answer.isEmpty {
      print("--- Answer ---")
    }
    print(text)
    answer += text
  }
}

Kotlin

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      includeThoughts = true
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_MODEL_NAME",
  generationConfig,
)

// Handle the streamed response that includes thought summaries
var thoughts = ""
var answer = ""
model.generateContentStream("solve x^2 + 4x + 4 = 0").collect { response ->
    response.thoughtSummary?.let {
        if (thoughts.isEmpty()) {
            println("--- Thoughts Summary ---")
        }
        print(it)
        thoughts += it
    }
    response.text?.let {
        if (answer.isEmpty()) {
            println("--- Answer ---")
        }
        print(it)
        answer += it
    }
}

Java

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setIncludeThoughts(true)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// Streaming with Java is complex and depends on the async library used.
// This is a conceptual example using a reactive stream.
Flowable responseStream = model.generateContentStream("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
StringBuilder thoughts = new StringBuilder();
StringBuilder answer = new StringBuilder();

responseStream.subscribe(response -> {
    if (response.getThoughtSummary() != null) {
        if (thoughts.length() == 0) {
            System.out.println("--- Thoughts Summary ---");
        }
        System.out.print(response.getThoughtSummary());
        thoughts.append(response.getThoughtSummary());
    }
    if (response.getText() != null) {
        if (answer.length() == 0) {
            System.out.println("--- Answer ---");
        }
        System.out.print(response.getText());
        answer.append(response.getText());
    }
}, throwable -> {
    // Handle error
});

Web

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
const generationConfig = {
  thinkingConfig: {
    includeThoughts: true
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_MODEL_NAME", generationConfig });

const result = await model.generateContentStream("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
let thoughts = "";
let answer = "";
for await (const chunk of result.stream) {
  if (chunk.thoughtSummary()) {
    if (thoughts === "") {
      console.log("--- Thoughts Summary ---");
    }
    // In Node.js, process.stdout.write(chunk.thoughtSummary()) could be used
    // to avoid extra newlines.
    console.log(chunk.thoughtSummary());
    thoughts += chunk.thoughtSummary();
  }

  const text = chunk.text();
  if (text) {
    if (answer === "") {
      console.log("--- Answer ---");
    }
    // In Node.js, process.stdout.write(text) could be used.
    console.log(text);
    answer += text;
  }
}

Dart

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
final thinkingConfig = ThinkingConfig(includeThoughts: true);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  generationConfig: generationConfig,
);

final responses = model.generateContentStream('solve x^2 + 4x + 4 = 0');

// Handle the streamed response that includes thought summaries
var thoughts = '';
var answer = '';
await for (final response in responses) {
  if (response.thoughtSummary != null) {
    if (thoughts.isEmpty) {
      print('--- Thoughts Summary ---');
    }
    thoughts += response.thoughtSummary!;
  }
  if (response.text != null) {
    if (answer.isEmpty) {
      print('--- Answer ---');
    }
    answer += response.text!;
  }
}

Unity

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
var thinkingConfig = new ThinkingConfig(includeThoughts: true);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
);

var stream = model.GenerateContentStreamAsync("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
var thoughts = "";
var answer = "";
await foreach (var response in stream)
{
    if (response.ThoughtSummary != null)
    {
        if (string.IsNullOrEmpty(thoughts))
        {
            Debug.Log("--- Thoughts Summary ---");
        }
        Debug.Log(response.ThoughtSummary);
        thoughts += response.ThoughtSummary;
    }
    if (response.Text != null)
    {
        if (string.IsNullOrEmpty(answer))
        {
            Debug.Log("--- Answer ---");
        }
        Debug.Log(response.Text);
        answer += response.Text;
    }
}

Informacje o podpisach myśli

Podczas korzystania z funkcji myślenia w interakcjach wieloetapowych model nie ma dostępu do kontekstu myślenia z poprzednich etapów. Jeśli jednak korzystasz z wywoływania funkcji, możesz używać sygnatur myśli, aby zachować kontekst myślowy w kolejnych turach. Podpisy myśli to zaszyfrowane reprezentacje wewnętrznego procesu myślowego modelu. Są one dostępne podczas korzystania z myślenia i wywoływania funkcji. Sygnatury myśli są generowane, gdy:

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

Aby korzystać z sygnatur myśli, używaj wywoływania funkcji w normalny sposób. Pakiety Firebase AI Logic SDK upraszczają ten proces, zarządzając stanem i automatycznie obsługując podpisy myśli. Zestawy SDK automatycznie przekazują wygenerowane sygnatury myśli między kolejnymi wywołaniami funkcji sendMessage lub sendMessageStream w ramach Chat sesji.

Ceny i zliczanie tokenów myślowych

Tokeny myślenia mają takie same ceny jak tokeny wyjściowe tekstu. Jeśli włączysz podsumowania myśli, będą one traktowane jako tokeny myślenia i odpowiednio wyceniane.

Możesz włączyć monitorowanie AI w Firebasekonsoli, aby śledzić liczbę tokenów przetwarzania w przypadku żądań, w których włączono przetwarzanie.

Łączną liczbę tokenów myślenia możesz uzyskać z pola thoughtsTokenCount w atrybucie usageMetadata odpowiedzi:

Swift

// ...

let response = try await model.generateContent("Why is the sky blue?")

if let usageMetadata = response.usageMetadata {
  print("Thoughts Token Count: \(usageMetadata.thoughtsTokenCount)")
}

Kotlin

// ...

val response = model.generateContent("Why is the sky blue?")

response.usageMetadata?.let { usageMetadata ->
    println("Thoughts Token Count: ${usageMetadata.thoughtsTokenCount}")
}

Java

// ...

ListenableFuture<GenerateContentResponse> response =
    model.generateContent("Why is the sky blue?");

Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String usageMetadata = result.getUsageMetadata();
        if (usageMetadata != null) {
            System.out.println("Thoughts Token Count: " +
                usageMetadata.getThoughtsTokenCount());
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web

// ...

const response = await model.generateContent("Why is the sky blue?");

if (response?.usageMetadata?.thoughtsTokenCount != null) {
    console.log(`Thoughts Token Count: ${response.usageMetadata.thoughtsTokenCount}`);
}

Dart

// ...

final response = await model.generateContent(
  Content.text("Why is the sky blue?"),
]);

if (response?.usageMetadata case final usageMetadata?) {
  print("Thoughts Token Count: ${usageMetadata.thoughtsTokenCount}");
}

Unity

// ...

var response = await model.GenerateContentAsync("Why is the sky blue?");

if (response.UsageMetadata != null)
{
    UnityEngine.Debug.Log($"Thoughts Token Count: {response.UsageMetadata?.ThoughtsTokenCount}");
}

Więcej informacji o tokenach znajdziesz w przewodniku po tokenach.

Myślenie Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Używanie modelu myślowego

Modele obsługujące tę funkcję

Sprawdzone metody i wskazówki dotyczące promptów w przypadku korzystania z modeli myślowych

Kontrolowanie budżetu na myślenie

Ustawianie budżetu na myślenie

Swift

Kotlin

Java

Web

Dart

Unity

Obsługiwane wartości budżetu na myślenie

Wyłącz przebieg rozumowania

Włączanie dynamicznego myślenia

Złożoność zadania

Uwzględnianie w odpowiedziach podsumowań myśli

Włącz podsumowania myśli

Swift

Kotlin

Java

Web

Dart

Unity

Wyświetlanie podsumowań myśli

Swift

Kotlin

Java

Web

Dart

Unity

Informacje o podpisach myśli

Ceny i zliczanie tokenów myślowych

Swift

Kotlin

Java

Web

Dart

Unity

Myślenie