Se usó la API de Cloud Translation para traducir esta página.

Pensando

Los modelos de Gemini 2.5 pueden usar un "proceso de pensamiento" interno que mejora significativamente sus capacidades de razonamiento y planificación de varios pasos, lo que los hace muy eficaces para tareas complejas, como la programación, las matemáticas avanzadas y el análisis de datos.

Los modelos de pensamiento ofrecen las siguientes configuraciones y opciones:

Presupuesto de pensamiento: Puedes configurar la cantidad de "pensamiento" que puede realizar un modelo con un presupuesto de pensamiento. Esta configuración es especialmente importante si reducir la latencia o el costo es una prioridad. Además, revisa la comparación de las dificultades de las tareas para decidir cuánto podría necesitar un modelo su capacidad de pensamiento.
Resúmenes de pensamientos: Puedes habilitar los resúmenes de pensamientos para incluirlos en la respuesta generada. Estos resúmenes son versiones sintetizadas de las reflexiones sin procesar del modelo y ofrecen estadísticas sobre el proceso de razonamiento interno del modelo.
Firmas de pensamiento: Los SDKs de Firebase AI Logic manejan automáticamente las firmas de pensamiento por ti, lo que garantiza que el modelo tenga acceso al contexto de pensamiento de los turnos anteriores, en especial cuando se usa la llamada a función.

Asegúrate de revisar las prácticas recomendadas y la orientación para la generación de instrucciones para usar modelos de pensamiento.

Usa un modelo de pensamiento

Usa un modelo de pensamiento como usarías cualquier otro modelo Gemini (inicializa el proveedor Gemini API que elegiste, crea una instancia GenerativeModel, etcétera). Estos modelos se pueden usar para tareas de generación de texto o código, como generar resultados estructurados o analizar entradas multimodales (como imágenes, videos, audio o PDFs). Incluso puedes usar modelos de pensamiento cuando transmites el resultado.

Modelos que admiten esta capacidad

Solo los modelos Gemini 2.5 admiten esta capacidad.

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

Prácticas recomendadas y orientación para usar modelos de pensamiento

Te recomendamos que pruebes tu instrucción en Google AI Studio o Vertex AI Studio, donde puedes ver el proceso de pensamiento completo. Puedes identificar las áreas en las que el modelo se haya desviado para que puedas definir mejor tus instrucciones y obtener respuestas más coherentes y precisas.

Comienza con una instrucción general que describa el resultado deseado y observa las ideas iniciales del modelo sobre cómo determina su respuesta. Si la respuesta no es la esperada, ayuda al modelo a generar una mejor respuesta con cualquiera de las siguientes técnicas de instrucciones:

Proporcionar instrucciones paso a paso
Proporciona varios ejemplos de pares de entrada-salida
Proporciona orientación sobre cómo se deben redactar y dar formato a las respuestas y los resultados.
Proporciona pasos de verificación específicos

Además de las instrucciones, considera usar estas recomendaciones:

Establece instrucciones del sistema, que son como un "preámbulo" que agregas antes de que el modelo se exponga a otras instrucciones de la instrucción o del usuario final. Te permiten dirigir el comportamiento del modelo según tus necesidades y casos de uso específicos.
Establece un presupuesto de pensamiento para configurar la cantidad de razonamiento que puede realizar el modelo. Si estableces un presupuesto bajo, el modelo no "pensará demasiado" su respuesta. Si estableces un presupuesto alto, el modelo puede pensar más si es necesario. Establecer un presupuesto de pensamiento también reserva una mayor parte del límite total de tokens de salida para la respuesta real.
Habilita la Supervisión de la IA en la consola de Firebase para supervisar el recuento de tokens de pensamiento y la latencia de tus solicitudes que tienen habilitado el pensamiento. Además, si tienes habilitados los resúmenes de pensamientos, se mostrarán en la consola, donde podrás inspeccionar el razonamiento detallado del modelo para ayudarte a depurar y perfeccionar tus instrucciones.

Controla el presupuesto de pensamiento

Para controlar la cantidad de razonamiento que el modelo puede realizar para generar su respuesta, puedes especificar la cantidad de tokens del presupuesto de pensamiento que se le permite usar.

Puedes establecer manualmente el presupuesto de pensamiento en situaciones en las que necesites más o menos tokens que el presupuesto de pensamiento predeterminado. Más adelante en esta sección, encontrarás una guía más detallada sobre la complejidad de las tareas y los presupuestos sugeridos. A continuación, se incluyen algunas orientaciones generales:

Establece un presupuesto de pensamiento bajo si la latencia es importante o para tareas menos complejas.
Establece un presupuesto de pensamiento alto para las tareas más complejas

Cómo establecer el presupuesto de pensamiento

Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página.

Establece el presupuesto de pensamiento en un GenerationConfig como parte de la creación de la instancia de GenerativeModel. La configuración se mantiene durante la vida útil de la instancia. Si deseas usar diferentes presupuestos de pensamiento para diferentes solicitudes, crea instancias de GenerativeModel configuradas con cada presupuesto.

Obtén más información sobre los valores de presupuesto de pensamiento admitidos más adelante en esta sección.

Swift

Establece el presupuesto de pensamiento en un GenerationConfig como parte de la creación de una instancia de 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

Establece los valores de los parámetros en un GenerationConfig como parte de la creación de una instancia de 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

Establece los valores de los parámetros en un GenerationConfig como parte de la creación de una instancia de 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

Establece los valores de los parámetros en un GenerationConfig como parte de la creación de una instancia de 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

Establece los valores de los parámetros en un GenerationConfig como parte de la creación de una instancia de 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

Establece los valores de los parámetros en un GenerationConfig como parte de la creación de una instancia de 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
);

// ...

Valores admitidos para el presupuesto de pensamiento

En la siguiente tabla, se enumeran los valores del presupuesto de procesamiento que puedes establecer para cada modelo configurando el thinkingBudget del modelo.

Modelo	Valor predeterminado	Rango disponible para el presupuesto de pensamiento		Valor para inhabilitar el pensamiento	Valor para fomentar el pensamiento dinámico
Modelo	Valor predeterminado			Valor para inhabilitar el pensamiento	Valor para fomentar el pensamiento dinámico	Valor mínimo	Valor máximo
Gemini 2.5 Pro	`8,192`	`128`	`32,768`	No se puede desactivar	`-1`
Gemini 2.5 Flash	`8,192`	`1`	`24,576`	`0`	`-1`
Gemini 2.5 Flash‑Lite	`0` (el pensamiento está inhabilitado de forma predeterminada)	`512`	`24,576`	`0` (o no configures el presupuesto de pensamiento)	`-1`

Inhabilita el razonamiento

Para algunas tareas más sencillas, no es necesaria la capacidad de pensamiento, y la inferencia tradicional es suficiente. O bien, si reducir la latencia es una prioridad, es posible que no quieras que el modelo tarde más tiempo del necesario en generar una respuesta.

En estas situaciones, puedes inhabilitar (o desactivar) el pensamiento:

Gemini 2.5 Pro: El pensamiento no se puede inhabilitar
Gemini 2.5 Flash: Establece thinkingBudget en tokens de 0
Gemini 2.5 Flash‑Lite: El pensamiento está inhabilitado de forma predeterminada.

Fomentar el pensamiento dinámico

Puedes dejar que el modelo decida cuándo y cuánto pensar (lo que se denomina pensamiento dinámico) configurando thinkingBudget como -1. El modelo puede usar tantos tokens como considere apropiado, hasta el valor máximo de tokens que se indicó anteriormente.

Complejidad de la tarea

Tareas fáciles: Se puede desactivar el pensamiento
Solicitudes sencillas en las que no se requiere un razonamiento complejo, como la recuperación de hechos o la clasificación. Ejemplos:
- "¿Dónde se fundó DeepMind?"
- "¿Este correo electrónico solicita una reunión o solo proporciona información?"
Tareas medianas: Se necesita el presupuesto predeterminado o un presupuesto adicional para pensar
Solicitudes comunes que se benefician de un cierto grado de procesamiento paso a paso o de una comprensión más profunda. Ejemplos:
- "Crea una analogía entre la fotosíntesis y el crecimiento".
- "Compara y contrasta los automóviles eléctricos y los automóviles híbridos".
Tareas difíciles: Es posible que se necesite un presupuesto de pensamiento máximo
Desafíos verdaderamente complejos, como resolver problemas matemáticos complejos o tareas de programación Estos tipos de tareas requieren que el modelo utilice todas sus capacidades de razonamiento y planificación, lo que a menudo implica muchos pasos internos antes de proporcionar una respuesta. Ejemplos:
- "Resuelve el problema 1 de AIME 2025: Encuentra la suma de todas las bases enteras b > 9 para las que 17b es un divisor de 97b".
- "Escribe código en Python para una aplicación web que visualice datos del mercado de valores en tiempo real, incluida la autenticación de usuarios. Hazlo lo más eficiente posible".

Incluir resúmenes de pensamiento en las respuestas

Los resúmenes de pensamientos son versiones sintetizadas de los pensamientos sin procesar del modelo y ofrecen estadísticas sobre el proceso de razonamiento interno del modelo.

Estos son algunos motivos para incluir resúmenes de pensamiento en las respuestas:

Puedes mostrar el resumen de pensamientos en la IU de tu app o hacer que estén disponibles para tus usuarios. El resumen del pensamiento se devuelve como una parte separada en la respuesta para que tengas más control sobre cómo se usa en tu app.
Si también habilitas la Supervisión de la IA en Firebase console, los resúmenes de pensamiento se mostrarán en la consola, donde podrás inspeccionar el razonamiento detallado del modelo para ayudarte a depurar y perfeccionar tus instrucciones.

Estas son algunas notas clave sobre los resúmenes de pensamientos:

Los resúmenes de pensamiento no se controlan con presupuestos de pensamiento (los presupuestos solo se aplican a los pensamientos sin procesar del modelo). Sin embargo, si la función de pensamiento está inhabilitada, el modelo no devolverá un resumen de pensamiento.
Los resúmenes de pensamientos se consideran parte de la respuesta de texto generado normal del modelo y se cuentan como tokens de salida.

Habilita los resúmenes de pensamientos

Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página.

Para habilitar los resúmenes de pensamientos, configura includeThoughts como verdadero en la configuración del modelo. Luego, puedes acceder al resumen verificando el campo thoughtSummary de la respuesta.

A continuación, se incluye un ejemplo que muestra cómo habilitar y recuperar resúmenes de pensamiento con la respuesta:

Swift

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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}");
}

Cómo ver el resumen de la respuesta y el pensamiento

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

Resúmenes de pensamientos de la transmisión

También puedes ver resúmenes de los pensamientos si eliges transmitir una respuesta con generateContentStream. Esto devolverá resúmenes acumulativos e incrementales durante la generación de la respuesta.

Swift

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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

Habilita los resúmenes de pensamientos en GenerationConfig como parte de la creación de una instancia de 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;
    }
}

Comprende las firmas de pensamiento

Cuando se usa el pensamiento en interacciones de varios turnos, el modelo no tiene acceso al contexto de pensamiento de los turnos anteriores. Sin embargo, si usas la llamada a función, puedes aprovechar las firmas de pensamiento para mantener el contexto del pensamiento en cada turno. Las firmas de pensamiento son representaciones encriptadas del proceso de pensamiento interno del modelo y están disponibles cuando se usan las funciones de pensamiento y de llamada a función. Específicamente, las firmas de pensamiento se generan en los siguientes casos:

El pensamiento está habilitado y se generan ideas.
La solicitud incluye declaraciones de funciones.

Para aprovechar las firmas de pensamiento, usa la llamada a función como de costumbre. Los SDKs de Firebase AI Logic simplifican el proceso, ya que administran el estado y controlan automáticamente las firmas de pensamiento por ti. Los SDKs pasan automáticamente cualquier firma de pensamiento generada entre las llamadas posteriores de sendMessage o sendMessageStream en una sesión de Chat.

Precios y conteo de tokens de pensamiento

Los tokens de pensamiento usan los mismos precios que los tokens de salida de texto. Si habilitas los resúmenes de pensamiento, se consideran tokens de pensamiento y se les aplica el precio correspondiente.

Puedes habilitar la Supervisión de la IA en la consola de Firebase para supervisar el recuento de tokens de pensamiento para las solicitudes que tienen habilitado el pensamiento.

Puedes obtener la cantidad total de tokens de pensamiento del campo thoughtsTokenCount en el atributo usageMetadata de la respuesta:

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

Obtén más información sobre los tokens en la guía de recuento de tokens.

Pensando Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Usa un modelo de pensamiento

Modelos que admiten esta capacidad

Prácticas recomendadas y orientación para usar modelos de pensamiento

Controla el presupuesto de pensamiento

Cómo establecer el presupuesto de pensamiento

Swift

Kotlin

Java

Web

Dart

Unity

Valores admitidos para el presupuesto de pensamiento

Inhabilita el razonamiento

Fomentar el pensamiento dinámico

Complejidad de la tarea

Incluir resúmenes de pensamiento en las respuestas

Habilita los resúmenes de pensamientos

Swift

Kotlin

Java

Web

Dart

Unity

Resúmenes de pensamientos de la transmisión

Swift

Kotlin

Java

Web

Dart

Unity

Comprende las firmas de pensamiento

Precios y conteo de tokens de pensamiento

Swift

Kotlin

Java

Web

Dart

Unity

Pensando