Lección 34 · 10 min · Gratis

Primeros pasos con los modelos de pensamiento de Gemini

Copyright 2026 Google LLC.

#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Nota: Este notebook utiliza la API de Interacciones, la forma más reciente de interactuar con los modelos Gemini. ¿Buscas la versión generateContent? Consulta la rama de archivo.

Todos los modelos Gemini están entrenados para realizar un proceso de pensamiento (o razonamiento) antes de llegar a una respuesta final. Como resultado, estos modelos suelen obtener mejores resultados en tareas más difíciles que requieren múltiples pasos de procesamiento: matemáticas complejas, codificación, razonamiento sobre instrucciones de varios pasos y comprensión multimodal.

Aunque el pensamiento siempre está activado, puedes configurar la cantidad de pensamiento que realiza el modelo utilizando niveles de pensamiento (minimal, low, medium, high). Esto te permite equilibrar la velocidad/costo de la respuesta y la profundidad del razonamiento según tu caso de uso.

Comprendiendo los modelos de pensamiento

Los modelos de pensamiento están optimizados para tareas complejas que necesitan múltiples rondas de estrategia y resolución iterativa.

Puedes controlar el esfuerzo de pensamiento utilizando niveles de pensamiento:

Nivel de pensamiento	Caso de uso
Alto (predeterminado)	Razonamiento complejo, matemáticas, codificación, problemas de varios pasos
Medio	Buen equilibrio entre velocidad y razonamiento
Bajo	Respuestas más rápidas con algo de razonamiento
Mínimo	Respuestas más rápidas, razonamiento mínimo (aproximadamente equivalente a "desactivado")

Puedes establecer el nivel de pensamiento usando types.ThinkingConfig(thinking_level=types.ThinkingLevel.HIGH).

Configuración

Esta sección instala el SDK, lo configura usando tu clave de API, importa las bibliotecas relevantes, descarga los videos de muestra y los sube a Gemini.

Simplemente colapsa (haz clic en la pequeña flecha a la izquierda del título) y ejecuta esta sección si quieres ir directamente a los ejemplos (solo no olvides ejecutarla, de lo contrario nada funcionará).

Instalar el SDK

El SDK de Google Gen AI proporciona acceso programático a los modelos Gemini utilizando las API de Google AI for Developers y Vertex AI. Con algunas excepciones, el código que se ejecuta en una plataforma se ejecutará en ambas. Esto significa que puedes prototipar una aplicación utilizando la API de desarrollador y luego migrar la aplicación a Vertex AI sin reescribir tu código.

Más detalles sobre este nuevo SDK en la documentación o en el notebook Primeros pasos .

%pip install -U -q "google-genai>=2.9.0" # 2.0 is needed to use the interactions API

Configura tu clave de API

Para ejecutar la siguiente celda, tu clave de API debe estar almacenada en un Secreto de Colab llamado GEMINI_API_KEY. Si aún no tienes una clave de API, o no estás seguro de cómo crear un Secreto de Colab, consulta Autenticación para ver un tutorial.

from google.colab import userdata

GEMINI_API_KEY=userdata.get('GEMINI_API_KEY')

Inicializar el cliente SDK

Con el nuevo SDK, ahora solo necesitas inicializar un cliente con tu clave de API (o OAuth si usas Vertex AI). El modelo ahora se configura en cada llamada.

from google import genai
from google.genai import types

client = genai.Client(api_key=GEMINI_API_KEY)

MODEL_ID = "gemini-3.7-flash" # @param ["gemini-3.1-pro-preview", "gemini-3.7-flash", "gemini-3.5-flash-lite", "gemini-2.5-pro"] {"allow-input":true, isTemplate: true}

Importaciones

import json
from PIL import Image
from IPython.display import display, Markdown

Uso de modelos de pensamiento

Aquí tienes algunos ejemplos complejos de lo que los modelos de pensamiento de Gemini pueden resolver.

En cada uno de ellos puedes seleccionar diferentes modelos para ver cómo se comparan.

En algunos casos, seguirás obteniendo una buena respuesta incluso con niveles de pensamiento más bajos. En ese caso, vuelve a ejecutar el ejemplo con pensamiento minimal para ver cuánto se beneficia el modelo de un razonamiento más profundo.

Uso de niveles de pensamiento

Puedes empezar pidiéndole al modelo que explique un concepto y ver cómo razona antes de responder.

Por defecto, el modelo utiliza el nivel de pensamiento high, lo que le permite ajustar dinámicamente su profundidad de razonamiento en función de la complejidad de la solicitud.

prompt = """
    You are playing the 20 question game. You know that what you are looking for
    is a aquatic mammal that doesn't live in the sea, is venomous and that's
    smaller than a cat. What could that be and how could you make sure?
"""

interaction = client.interactions.create(
    model=MODEL_ID,
    input=prompt
)

Markdown(interaction.steps[-1].content[0].text)

Al observar los metadatos de la respuesta, puedes ver no solo la cantidad de tokens en tu entrada y la cantidad de tokens utilizados para la respuesta, sino también la cantidad de tokens utilizados para el paso de pensamiento. Como puedes ver aquí, el modelo utilizó alrededor de 1400 tokens en los pasos de pensamiento:

print("Prompt tokens:",response.usage_metadata.prompt_token_count)
print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
print("Output tokens:",response.usage_metadata.candidates_token_count)
print("Total tokens:",response.usage_metadata.total_token_count)

Prompt tokens: 62
Thoughts tokens: 710
Output tokens: 522
Total tokens: 1294

Pensamiento mínimo

Puedes establecer el pensamiento en minimal para obtener respuestas más rápidas con casi ningún razonamiento. Verás que, en este caso, el modelo no reflexiona sobre el problema tan profundamente.

if "-pro" not in MODEL_ID:
  prompt = """
      You are playing the 20 question game. You know that what you are looking for
      is a aquatic mammal that doesn't live in the sea, is venomous and that's
      smaller than a cat. What could that be and how could you make sure?
  """

  interaction = client.interactions.create(
    model=MODEL_ID,
    input=prompt,
    config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
        thinking_level="none"
      )
    )
  )

  Markdown(interaction.steps[-1].content[0].text)

else:
  print("You can't disable thinking for pro models.")

Ahora puedes ver que la respuesta es más rápida, ya que el modelo no realizó ningún paso de pensamiento. También puedes ver que no se utilizaron tokens para el paso de pensamiento:

print("Prompt tokens:",response.usage_metadata.prompt_token_count)
print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
print("Output tokens:",response.usage_metadata.candidates_token_count)
print("Total tokens:",response.usage_metadata.total_token_count)

Prompt tokens: 63
Thoughts tokens: None
Output tokens: 393
Total tokens: 456

Resolviendo un problema de física

Ahora, intenta con un problema de física complejo. Primero con pensamiento minimal para ver cómo se desempeña el modelo:

if "-pro" not in MODEL_ID:
    prompt = """
            A cantilever beam of length L=3m has a rectangular cross-section (width b=0.1m, height h=0.2m) and is made of steel (E=200 GPa).
            It is subjected to a uniformly distributed load w=5 kN/m along its entire length and a point load P=10 kN at its free end.
            Calculate the maximum bending stress (σ_max).
    """

    interaction = client.interactions.create(
            model=MODEL_ID,
            input=prompt,
            config=types.GenerateContentConfig(
                    thinking_config=types.ThinkingConfig(
                            thinking_level="none"
                    )
            )
    )

    Markdown(interaction.steps[-1].content[0].text)

else:
    print("You can't disable thinking for pro models.")

Puedes ver que con un pensamiento mínimo, el modelo utiliza muy pocos tokens para el razonamiento:

print("Prompt tokens:",response.usage_metadata.prompt_token_count)
print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
print("Output tokens:",response.usage_metadata.candidates_token_count)
print("Total tokens:",response.usage_metadata.total_token_count)

Prompt tokens: 97
Thoughts tokens: None
Output tokens: 735
Total tokens: 832

Luego puedes usar el pensamiento high para ver cómo se desempeña el modelo con razonamiento completo.

Puedes ver que, incluso para el mismo prompt, la profundidad y la consistencia de la respuesta mejoran significativamente cuando se permite al modelo pensar más profundamente.

NOTA: Siempre puedes ver cuántos tokens se utilizaron para el paso de pensamiento en el usage_metadata.

prompt = """
    A cantilever beam of length L=3m has a rectangular cross-section (width b=0.1m, height h=0.2m) and is made of steel (E=200 GPa).
    It is subjected to a uniformly distributed load w=5 kN/m along its entire length and a point load P=10 kN at its free end.
    Calculate the maximum bending stress (σ_max).
"""

interaction = client.interactions.create(
    model=MODEL_ID,
    input=prompt,
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level=types.ThinkingLevel.HIGH
        )
    )
)

Markdown(interaction.steps[-1].content[0].text)

Ahora puedes ver que el modelo utilizó significativamente más tokens para el razonamiento:

print("Prompt tokens:",response.usage_metadata.prompt_token_count)
print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
print("Output tokens:",response.usage_metadata.candidates_token_count)
print("Total tokens:",response.usage_metadata.total_token_count)

Prompt tokens: 96
Thoughts tokens: 1116 / 4096
Output tokens: 758
Total tokens: 1970

Ten en cuenta que los niveles de pensamiento más altos significan que el modelo dedicará más tiempo a razonar, lo que se traduce en un mayor tiempo de cálculo y una solicitud más costosa.

Trabajando con problemas multimodales

Este problema de geometría requiere un razonamiento complejo y también utiliza las capacidades multimodales de Gemini para leer la imagen.

!wget https://storage.googleapis.com/generativeai-downloads/images/geometry.png -O geometry.png -q

geometry_image = Image.open("geometry.png").resize((256,256))
geometry_image

prompt = "What's the area of the overlapping region?"

interaction = client.interactions.create(
    model=MODEL_ID,
    input=[geometry_image, prompt],
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level=types.ThinkingLevel.HIGH
        )
    )
)

Markdown(interaction.steps[-1].content[0].text)

Resolviendo acertijos

Aquí hay otro acertijo basado en una imagen, esta vez parece un problema matemático, pero en realidad no se puede resolver matemáticamente. Si revisas los pensamientos del modelo, verás que se dará cuenta y propondrá una solución innovadora.

!wget https://storage.googleapis.com/generativeai-downloads/images/pool.png -O pool.png -q

pool_image = Image.open("pool.png").resize((256,256))
pool_image

Primero puedes verificar cómo se desempeña el modelo con pensamiento minimal:

interaction = client.interactions.create(
    model=MODEL_ID,
    input=[
        pool_image,
        "How do I use those three pool balls to sum up to 30?"
    ],
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level=types.ThinkingLevel.MINIMAL
        )
    )
)

Markdown(interaction.steps[-1].content[0].text)

Como puedes notar, el modelo tuvo dificultades para encontrar una manera de llegar al resultado, y terminó sugiriendo usar diferentes bolas de billar.

Ahora puedes usar el pensamiento high para resolver el acertijo:

prompt = "How do I use those three pool balls to sum up to 30?"

interaction = client.interactions.create(
    model=MODEL_ID,
    input=[
        pool_image,
        prompt,
    ],
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level=types.ThinkingLevel.HIGH
        )
    )
)

Markdown(interaction.steps[-1].content[0].text)

Resolviendo un rompecabezas matemático con pensamiento elevado

Este es típicamente un caso en el que querrás usar el pensamiento high, ya que el modelo necesita explorar muchas direcciones antes de encontrar la respuesta correcta.

prompt = """
   How can you obtain 565 with 10 8 3 7 1 and 5 and the common operations?
   You can only use a number once.
"""

interaction = client.interactions.create(
    model=MODEL_ID,
    input=prompt,
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level=types.ThinkingLevel.HIGH
        )
    )
)

display(Markdown(interaction.steps[-1].content[0].text))

<IPython.core.display.Markdown object>

Resúmenes de pensamientos de trabajo

Los resúmenes del pensamiento del modelo revelan su camino interno de resolución de problemas. Los usuarios pueden aprovechar esta característica para verificar la estrategia del modelo y mantenerse informados durante tareas complejas.

Para más detalles sobre las capacidades de pensamiento de Gemini, consulta la guía de pensamiento de los modelos Gemini.

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?
"""

interaction = client.interactions.create(
  model=MODEL_ID,
  input=prompt,
  config=types.GenerateContentConfig(
    thinking_config=types.ThinkingConfig(
      include_thoughts=True
    )
  )
)

Puedes consultar tanto los resúmenes de los pensamientos como la respuesta final del modelo:

for step in interaction.steps:
    if step.type == "model_output":
        for content in step.content:
            if hasattr(content, 'thought') and content.thought:
                display(Markdown("## **Thoughts summary:**"))
                display(Markdown(content.text))
                print()
            elif content.text:
                display(Markdown("## **Answer:**"))
                display(Markdown(content.text))

<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>

<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>

También puedes ver los resúmenes de los pensamientos en experiencias de streaming:

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 event in client.interactions.create(
    model=MODEL_ID,
    input=prompt,
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level=types.ThinkingLevel.HIGH
        )
    ),
    stream=True,
):
    if hasattr(event, 'delta'):
        if hasattr(event.delta, 'thought') and event.delta.thought:
            thoughts += event.delta.text or ""
        elif hasattr(event.delta, 'text') and event.delta.text:
            answer += event.delta.text

display(Markdown("## **Thoughts summary:**"))
display(Markdown(thoughts))
print()
display(Markdown("## **Answer:**"))
display(Markdown(answer))

<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>

Trabajando con modelos de pensamiento Gemini y herramientas

Los modelos de pensamiento Gemini son compatibles con las herramientas y capacidades inherentes al ecosistema Gemini. Esta compatibilidad les permite interactuar con entornos externos, ejecutar código computacional o recuperar datos en tiempo real, incorporando posteriormente dicha información en su marco analítico y declaraciones finales.

Resolviendo un problema usando la herramienta de ejecución de código

Este ejemplo muestra cómo usar la herramienta de ejecución de código para resolver un problema. El modelo generará el código y luego lo ejecutará para obtener la respuesta final.

prompt = """
    What are the best ways to sort a list of n numbers from 0 to m?
    Generate and run Python code for three different sort algorithms.
    Provide the final comparison between algorithm clearly.
    Is one of them linear?
"""

code_execution_tool = types.Tool(
    code_execution=types.ToolCodeExecution()
)

interaction = client.interactions.create(
    model=MODEL_ID,
    input=prompt,
    config=types.GenerateContentConfig(
        tools=[code_execution_tool],
        thinking_config=types.ThinkingConfig(
            thinking_level=thinking_level,
        )
    ),
)

Verificando la respuesta del modelo, incluyendo el código generado y el resultado de la ejecución:

from IPython.display import display, HTML, Markdown

for step in interaction.steps:
    if step.type == "model_output":
        for content in step.content:
            if content.text is not None:
                display(Markdown(content.text))
    elif step.type == "code_execution":
        display(HTML(f'<pre style="background-color: #1a1a2e; color: #16c60c; padding: 10px;">{step.code}</pre>'))
        if hasattr(step, 'result') and step.result:
            display(HTML(f'<pre style="background-color: #2d2d44; color: white; padding: 10px;">{step.result}</pre>'))

<IPython.core.display.HTML object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>

Pensando con la herramienta de búsqueda

La fundamentación de búsqueda es una excelente manera de mejorar la calidad de las respuestas del modelo al darle la capacidad de buscar la información más reciente utilizando la Búsqueda de Google. Consulta la guía dedicada para obtener más detalles sobre esa característica.

from google.genai.types import Tool, GenerateContentConfig, GoogleSearch

google_search_tool = Tool(google_search=GoogleSearch())

prompt = """
    What were the major scientific breakthroughs announced last month? Use your
    critical thinking and only list what's really incredible and not just an
    overinfluated title.
"""

interaction = client.interactions.create(
    model=MODEL_ID,
    input=prompt,
    config=GenerateContentConfig(
        tools=[google_search_tool],
        thinking_config=types.ThinkingConfig(
            thinking_level=thinking_level,
            include_thoughts=True
        )
    )
)

Luego puedes verificar toda la información:

el resumen de los pensamientos del modelo
la respuesta del modelo
y la referencia de la Búsqueda de Google

for step in interaction.steps:
    if step.type == "model_output":
        for content in step.content:
            if hasattr(content, 'thought') and content.thought:
                display(Markdown("## **Thoughts summary:**"))
                display(Markdown(content.text))
                print()
            elif content.text:
                display(Markdown("## **Answer:**"))
                display(Markdown(content.text))

<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>

<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>

<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>

<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>
<IPython.core.display.HTML object>

Referencia de niveles de pensamiento

Los niveles de pensamiento proporcionan una forma sencilla de controlar la cantidad de razonamiento:

# Set thinking level
config = types.GenerateContentConfig(
    thinking_config=types.ThinkingConfig(
        thinking_level=types.ThinkingLevel.HIGH  # MINIMAL, LOW, MEDIUM, HIGH
    )
)

# @title Run this cell to set everything up if you jump directly to this section
from google.colab import userdata
from google import genai
from google.genai import types
from IPython.display import display, Markdown, HTML

client = genai.Client(api_key=userdata.get('GEMINI_API_KEY'))

# Select the Gemini 3 model

GEMINI_3_MODEL_ID = "gemini-3.7-flash" # @param ["gemini-3.1-pro-preview", "gemini-3.7-flash", "gemini-3.5-flash-lite"] {"allow-input":true, isTemplate: true}

Puedes establecer el nivel de pensamiento en minimal, low, medium o high (predeterminado). Esto indicará al modelo cuánto pensamiento se le permite hacer. Dado que el proceso de pensamiento permanece dinámico, high no significa necesariamente que el modelo pensará mucho, solo significa que se le permite pensar tanto como necesite.

De manera similar, establecer el nivel en low no significa que el modelo pensará muy poco, significa que estará restringido y podría no pensar tanto como debería para tareas más complejas.

prompt = """
  Find what I'm thinking of:
    It moves, but doesn't walk, run, or swim.
    It has no fixed shape and if cut into pieces, those pieces will keep living and moving.
    It has no brain but can solve complex mazes.
"""

# Thinking levels can be either "Minimal/Low/Medium/High" or types.ThinkingLevel.MINIMAL/types.ThinkingLevel.LOW/types.ThinkingLevel.MEDIUM/types.ThinkingLevel.HIGH
thinking_level = "High" # @param ["Minimal", "Low", "Medium","High"]

interaction = client.interactions.create(
  model=GEMINI_3_MODEL_ID,
  input=prompt,
  config=types.GenerateContentConfig(
    thinking_config=types.ThinkingConfig(
      thinking_level=thinking_level,
      include_thoughts=True
    )
  )
)

for part in response.parts:
  if not part.text:
    continue
  if part.thought:
    display(Markdown("### Thought summary:"))
    display(Markdown(part.text))
    print()
  else:
    display(Markdown("### Answer:"))
    display(Markdown(part.text))
    print()

print(f"We used {response.usage_metadata.thoughts_token_count} tokens for the thinking phase and {response.usage_metadata.prompt_token_count} for the output.")

<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>

<IPython.core.display.Markdown object>
<IPython.core.display.Markdown object>

We used 282 tokens for the thinking phase and 62 for the output.

Legado: Migrando de `thinking_budget` a `thinking_level`

Si anteriormente usabas thinking_budget (una característica de generateContent), así es como puedes migrar:

Si usabas thinking_budget=0 → usa ThinkingLevel.MINIMAL
Si usabas un thinking_budget bajo (por ejemplo, 1024) → usa ThinkingLevel.LOW
Si usabas un thinking_budget medio (por ejemplo, 4096-8192) → usa ThinkingLevel.MEDIUM
Si usabas el thinking_budget máximo o adaptativo (predeterminado) → usa ThinkingLevel.HIGH
Si usabas pensamiento dinámico → usa ThinkingLevel.HIGH (el modelo seguirá ajustándose dinámicamente)

Nota: thinking_budget es una característica heredada de la API generateContent que aún se puede usar para ajustar el comportamiento del pensamiento. Consulta el notebook generateContent para obtener más detalles.

Próximos pasos

Prueba Gemini 3 y otros modelos Gemini en Google AI Studio, y aprende más sobre Prompting para modelos de pensamiento.

Para más ejemplos de las capacidades de Gemini, consulta los otros ejemplos del Cookbook. Aprenderás a usar la API en vivo , a manejar múltiples herramientas o a usar las capacidades de comprensión espacial de Gemini.

Lección del curso «Gemini API Cookbook (quickstarts)» de Google, publicado con licencia Apache 2.0. Traducción y adaptación al español de IA con Clase. IA con Clase no está afiliado a Google. Ver el original · Licencia

Esta lección es gratuita. El resto del curso se abre con la Membresía de IA con Clase, que incluye todos los cursos del catálogo. Ver precios

← Anterior Siguiente: Empezar a pensar con REST →

Primeros pasos con los modelos de pensamiento de Gemini

Copyright 2026 Google LLC.

Comprendiendo los modelos de pensamiento

Configuración

Instalar el SDK

Configura tu clave de API

Inicializar el cliente SDK

Importaciones

Uso de modelos de pensamiento

Uso de niveles de pensamiento

Pensamiento mínimo

Resolviendo un problema de física

Trabajando con problemas multimodales

Resolviendo acertijos

Resolviendo un rompecabezas matemático con pensamiento elevado

Resúmenes de pensamientos de trabajo

Trabajando con modelos de pensamiento Gemini y herramientas

Resolviendo un problema usando la herramienta de ejecución de código

Pensando con la herramienta de búsqueda

Referencia de niveles de pensamiento

Legado: Migrando de thinking_budget a thinking_level

Próximos pasos

Legado: Migrando de `thinking_budget` a `thinking_level`