Comienza a usar Gemini 3

Gemini 3 es nuestra familia de modelos más inteligente hasta la fecha, creada sobre una base de razonamiento de vanguardia. Está diseñada para dar vida a cualquier idea mediante el dominio de flujos de trabajo basados en agentes, la codificación autónoma y las tareas multimodales complejas.

En esta guía, se proporciona una ruta práctica y consolidada para comenzar a usar Gemini 3 en Gemini Enterprise Agent Platform, en la que se destacan las funciones clave y las prácticas recomendadas de Gemini 3.

Guía de inicio rápido

Antes de comenzar, debes autenticarte en Gemini Enterprise Agent Platform con una clave de API o credenciales predeterminadas de la aplicación (ADC). Consulta los métodos de autenticación para obtener más información.

Instala el SDK de IA generativa de Google

Las funciones de la API de Gemini 3 requieren el SDK de IA generativa de Google para Python versión 1.51.0 o posterior.

pip install --upgrade google-genai

Establece variables de entorno para usar el SDK de IA generativa de Google con Gemini Enterprise Agent Platform

Reemplaza el valor de GOOGLE_CLOUD_PROJECT por tu Google Cloud ID del proyecto. El modelo Gemini 3.1 Pro gemini-3.1-pro-preview y el modelo Gemini 3 Flash gemini-3-flash-preview solo están disponibles en extremos globales:

export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

Realiza tu primera solicitud

De forma predeterminada, los modelos de Gemini 3 y Gemini 3 Flash usan el razonamiento dinámico para razonar a través de las instrucciones. Para obtener respuestas más rápidas y con menor latencia cuando no se requiere un razonamiento complejo, puedes restringir el thinking_level del modelo. El razonamiento bajo es ideal para tareas de alta capacidad de procesamiento en las que la velocidad es primordial.

Para obtener respuestas rápidas y con baja latencia, haz lo siguiente:

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
   model="gemini-3.6-flash",
   contents="How does AI work?",
   config=types.GenerateContentConfig(
       thinking_config=types.ThinkingConfig(
           thinking_level=types.ThinkingLevel.LOW # For fast and low latency response
       )
   ),
)
print(response.text)

Prueba tareas de razonamiento complejas

Gemini 3 se destaca en el razonamiento avanzado. Para tareas complejas, como la planificación de varios pasos, la generación de código verificada o el uso profundo de herramientas, usa niveles de razonamiento altos. Usa estas configuraciones para tareas que antes requerían modelos de razonamiento especializados.

Para tareas más lentas y de razonamiento alto, haz lo siguiente:

from google import genai
from google.genai import types

client = genai.Client()

prompt = """
You are tasked with implementing the classic Thread-Safe Double-Checked Locking (DCL) Singleton pattern in modern C++. This task is non-trivial and requires specialized concurrency knowledge to prevent memory reordering issues.

Write a complete, runnable C++ program named `dcl_singleton.cpp` that defines a class `Singleton` with a private constructor and a static `getInstance()` method.

Your solution MUST adhere to the following strict constraints:
1. The Singleton instance pointer (`static Singleton*`) must be wrapped in `std::atomic` to correctly manage memory visibility across threads.
2. The `getInstance()` method must use `std::memory_order_acquire` when reading the instance pointer in the outer check.
3. The instance creation and write-back must use `std::memory_order_release` when writing to the atomic pointer.
4. A standard `std::mutex` must be used only to protect the critical section (the actual instantiation).
5. The `main` function must demonstrate safe, concurrent access by launching at least three threads, each calling `Singleton::getInstance()`, and printing the address of the returned instance to prove all threads received the same object.
"""

response = client.models.generate_content(
  model="gemini-3.6-flash",
  contents=prompt,
  config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
          thinking_level=types.ThinkingLevel.HIGH # Dynamic thinking for high reasoning tasks
      )
  ),
)
print(response.text)

Otros niveles de razonamiento

Gemini 3 Flash presenta dos niveles de razonamiento nuevos: MINIMAL y MEDIUM para brindarte aún más control sobre la forma en que el modelo controla las tareas de razonamiento complejas.

MINIMAL ofrece opciones de presupuesto de razonamiento casi nulas para tareas optimizadas para la capacidad de procesamiento, en lugar del razonamiento. MEDIUM permite un equilibrio entre la velocidad y el razonamiento que permite cierta capacidad de razonamiento, pero sigue priorizando las operaciones de baja latencia.

Nuevas funciones de la API

Gemini 3 presenta potentes mejoras en la API y parámetros nuevos diseñados para brindar a los desarrolladores control detallado sobre el rendimiento (latencia, costo), el comportamiento del modelo y la fidelidad multimodal.

En esta tabla, se resumen las principales funciones y parámetros nuevos disponibles, junto con vínculos directos a su documentación detallada:

Nueva función o cambio en la API Documentación
Modelo: gemini-3.1-pro-preview Ficha del modelo
Model Garden
Nivel de razonamiento Razonamiento
Resolución de contenido multimedia Comprensión de imágenes
Comprensión de videos
Comprensión de audio
Comprensión de documentos
Firma de razonamiento Firmas de razonamiento
Temperatura Referencia de la API
Respuestas de funciones multimodales Llamada a función: Respuestas de funciones multimodales
Llamada a funciones de transmisión Llamada a función: Llamada a funciones de transmisión

Nivel de razonamiento

El parámetro thinking_level te permite especificar un presupuesto de razonamiento para la generación de respuestas del modelo. Si seleccionas uno de los dos estados, puedes equilibrar explícitamente las compensaciones entre la calidad de la respuesta y la complejidad del razonamiento, y la latencia y el costo.

  • MINIMAL: (solo Gemini 3 Flash y Gemini 3.1 Flash-Lite) Restringe el modelo para que use la menor cantidad posible de tokens para el razonamiento y se usa mejor para tareas de baja complejidad que no se beneficiarían de un razonamiento extenso. MINIMAL está lo más cerca posible de un presupuesto cero para el razonamiento, pero aún requiere firmas de razonamiento.
  • LOW: Restringe el modelo para que use menos tokens para el razonamiento y es adecuado para tareas más simples en las que no se requiere un razonamiento extenso. LOW es ideal para tareas de alta capacidad de procesamiento en las que la velocidad es esencial.
  • MEDIUM: (solo Gemini 3 Flash, Gemini 3.1 Pro y Gemini 3.1 Flash-Lite) Ofrece un enfoque equilibrado adecuado para tareas de complejidad moderada que se benefician del razonamiento, pero no requieren una planificación profunda de varios pasos. Proporciona más capacidad de razonamiento que LOW y, al mismo tiempo, mantiene una latencia más baja que HIGH.
  • HIGH: Permite que el modelo use más tokens para el razonamiento y es adecuado para instrucciones complejas que requieren un razonamiento profundo, como la planificación de varios pasos, la generación de código verificada o situaciones avanzadas de llamadas a función. Este es el nivel predeterminado para los modelos de Gemini 3 y Gemini 3 Flash. Usa esta configuración cuando reemplaces tareas para las que antes podrías haber dependido de modelos de razonamiento especializados.

Ejemplo del SDK de IA generativa de Google

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
   model="gemini-3.6-flash",
   contents="Find the race condition in this multi-threaded C++ snippet: [code here]",
   config=types.GenerateContentConfig(
       thinking_config=types.ThinkingConfig(
           thinking_level=types.ThinkingLevel.HIGH # Default, dynamic thinking
       )
   ),
)
print(response.text)

Ejemplo de compatibilidad con OpenAI

Para los usuarios que utilizan la capa de compatibilidad con OpenAI, los parámetros estándar se asignan automáticamente a los equivalentes de Gemini 3:

  • reasoning_effort se asigna a thinking_level.
  • none: se asigna a thinking_level mínimo (solo Gemini 3 Flash).
  • medium: se asigna a thinking_level medio para todos los modelos de Gemini 3.
import openai
from google.auth import default
from google.auth.transport.requests import Request

credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])

client = openai.OpenAI(
    base_url=f"https://aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/global/endpoints/openapi",
    api_key=credentials.token,
)

prompt = """
Write a bash script that takes a matrix represented as a string with
format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
"""

response = client.chat.completions.create(
    model="gemini-3.6-flash",
    reasoning_effort="medium", # Map to thinking_level high.
    messages=[{"role": "user", "content": prompt}],
)

print(response.choices[0].message.content)

Resolución de contenido multimedia

Gemini 3 presenta un control detallado sobre el procesamiento de visión multimodal con el parámetro media_resolution. Las resoluciones más altas mejoran la capacidad del modelo para leer texto fino o identificar detalles pequeños, pero aumentan el uso de tokens y la latencia. El parámetro media_resolution determina la cantidad máxima de tokens asignados por imagen de entrada, página PDF o fotograma de video.

Puedes establecer la resolución en low, medium o high de forma global (con generation_config) o para partes de contenido multimedia individuales. La resolución ultra_high solo se puede establecer para partes de contenido multimedia individuales. Si no se especifica, el modelo usa valores predeterminados óptimos según el tipo de contenido multimedia.

Recuentos de tokens

En esta tabla, se resumen los recuentos de tokens aproximados para cada valor media_resolution y tipo de contenido multimedia.

Resolución de contenido multimedia Imagen Video PDF
UNSPECIFIED (predeterminado) 1120 70 560
LOW 280 70 280 + texto
MEDIUM 560 70 560 + texto
HIGH 1120 280 1120 + texto
ULTRA_HIGH 2240 N/A N/A
Resolución de contenido multimedia Tokens máx. Orientación sobre el uso
ultra_high 2240 Tareas que requieren el análisis de detalles finos en imágenes, como el procesamiento de imágenes fijas de grabación de pantalla o fotos de alta resolución
high 1120 Tareas de análisis de imágenes para garantizar la máxima calidad
medium 560
low Imagen: 280 Video: 70 Suficiente para la mayoría de las tareas Nota: Para el video, low es un máximo de 70 tokens por fotograma.

Cómo establecer media_resolution por parte individual

Puedes establecer media_resolution por parte individual de contenido multimedia:

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
  model="gemini-3.6-flash",
  contents=[
      types.Part(
          file_data=types.FileData(
              file_uri="gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png",
              mime_type="image/jpeg",
          ),
          media_resolution=types.PartMediaResolution(
              level=types.PartMediaResolutionLevel.MEDIA_RESOLUTION_HIGH # High resolution
          ),
      ),
      Part(
          file_data=types.FileData(
             file_uri="gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4",
            mime_type="video/mp4",
          ),
          media_resolution=types.PartMediaResolution(
              level=types.PartMediaResolutionLevel.MEDIA_RESOLUTION_LOW # Low resolution
          ),
      ),
      "When does the image appear in the video? What is the context?",
  ],
)
print(response.text)

Cómo establecer media_resolution de forma global

También puedes establecer media_resolution de forma global (con GenerateContentConfig):

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
  model="gemini-3.6-flash",
  contents=[
      types.Part(
          file_data=types.FileData(
              file_uri="gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png",
              mime_type="image/jpeg",
          ),
      ),
      "What is in the image?",
  ],
  config=types.GenerateContentConfig(
      media_resolution=types.MediaResolution.MEDIA_RESOLUTION_LOW, # Global setting
  ),
)
print(response.text)

Firmas de razonamiento

Las firmas de razonamiento son tokens encriptados que conservan el estado de razonamiento del modelo durante las conversaciones de varios turnos, en especial cuando se usa la llamada a función.

Cuando un modelo de razonamiento decide llamar a una herramienta externa, pausa su proceso de razonamiento interno. La firma de razonamiento actúa como un "estado de guardado", lo que permite que el modelo reanude su cadena de razonamiento sin problemas una vez que proporcionas el resultado de la función.

Para obtener más información, consulta Firmas de razonamiento.

¿Por qué son importantes las firmas de razonamiento?

Sin firmas de razonamiento, el modelo "olvida" sus pasos de razonamiento específicos durante la fase de ejecución de la herramienta. Si vuelves a pasar la firma, se garantiza lo siguiente:

  • Continuidad del contexto: El modelo conserva el motivo por el que se llamó a la herramienta.
  • Razonamiento complejo: Permite tareas de varios pasos en las que el resultado de una herramienta informa el razonamiento para la siguiente.

¿Dónde se muestran las firmas de razonamiento?

Los modelos de Gemini 3 y Gemini 3 Flash aplican una validación más estricta y un manejo actualizado en las firmas de razonamiento que se introdujeron originalmente en Gemini 2.5. Para asegurarte de que el modelo mantenga el contexto en varios turnos de una conversación, debes mostrar las firmas de razonamiento en tus solicitudes posteriores.

  • Las respuestas del modelo con una llamada a función siempre mostrarán una firma de razonamiento, incluso cuando se use el nivel de razonamiento MINIMAL.
  • Cuando hay llamadas a función paralelas, la primera parte de la llamada a función que muestra la respuesta del modelo tendrá una firma de razonamiento.
  • Cuando hay llamadas a función secuenciales (varios pasos), cada llamada a función tendrá una firma y se espera que los clientes vuelvan a pasar la firma.
  • Las respuestas del modelo sin una llamada a función mostrarán una firma de razonamiento dentro de la última parte que muestra el modelo.

¿Cómo se controlan las firmas de razonamiento?

Hay dos formas principales de controlar las firmas de razonamiento: automáticamente con los SDK de IA generativa de Google o la API de OpenAI, o de forma manual si interactúas directamente con la API.

Control automatizado (recomendado)

Si usas los SDK de IA generativa de Google (Python, Node.js, Go, Java) o la API de OpenAI Chat Completions, y utilizas las funciones estándar del historial de chat o agregas la respuesta completa del modelo, thought_signatures se controla automáticamente. No es necesario realizar cambios en el código.

Ejemplo de llamada a función manual

Cuando se usa el SDK de IA generativa de Google, las firmas de razonamiento se controlan automáticamente agregando la respuesta completa del modelo en solicitudes de modelo secuenciales:

from google import genai
from google.genai import types

client = genai.Client()

# 1. Define your tool
get_weather_declaration = types.FunctionDeclaration(
   name="get_weather",
   description="Gets the current weather temperature for a given location.",
   parameters={
       "type": "object",
       "properties": {"location": {"type": "string"}},
       "required": ["location"],
   },
)
get_weather_tool = types.Tool(function_declarations=[get_weather_declaration])

# 2. Send a message that triggers the tool
prompt = "What's the weather like in London?"
response = client.models.generate_content(
   model="gemini-3.6-flash",
   contents=prompt,
   config=types.GenerateContentConfig(
       tools=[get_weather_tool],
       thinking_config=types.ThinkingConfig(include_thoughts=True)
   ),
)

# 4. Handle the function call
function_call = response.function_calls[0]
location = function_call.args["location"]
print(f"Model wants to call: {function_call.name}")

# Execute your tool (e.g., call an API)
# (This is a mock response for the example)
print(f"Calling external tool for: {location}")
function_response_data = {
   "location": location,
   "temperature": "30C",
}

# 5. Send the tool's result back
# Append this turn's messages to history for a final response.
# The `content` object automatically attaches the required thought_signature behind the scenes.
history = [
    types.Content(role="user", parts=[types.Part(text=prompt)]),
    response.candidates[0].content, # Signature preserved here
    types.Content(
        role="user",
        parts=[
            types.Part.from_function_response(
                name=function_call.name,
                response=function_response_data,
            )
        ],
    )
]

response_2 = client.models.generate_content(
   model="gemini-3.6-flash",
   contents=history,
   config=types.GenerateContentConfig(
        tools=[get_weather_tool],
        thinking_config=types.ThinkingConfig(include_thoughts=True)
   ),
)

# 6. Get the final, natural-language answer
print(f"\nFinal model response: {response_2.text}")
Ejemplo de llamada a función automática

Cuando se usa el SDK de IA generativa de Google en la llamada a función automática, las firmas de razonamiento se controlan automáticamente:


from google import genai
from google.genai import types

def get_current_temperature(location: str) -> dict:
    """Gets the current temperature for a given location.

    Args:
        location: The city and state, for example San Francisco, CA

    Returns:
        A dictionary containing the temperature and unit.
    """
    # ... (implementation) ...
    return {"temperature": 25, "unit": "Celsius"}

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.6-flash",
    contents="What's the temperature in Boston?",
    config=types.GenerateContentConfig(
            tools=[get_current_temperature],
    )
)

print(response.text) # The SDK handles the function call and thought signature, and returns the final text
Ejemplo de compatibilidad con OpenAI

Cuando se usa la API de OpenAI Chat Completions, las firmas de razonamiento se controlan automáticamente agregando la respuesta completa del modelo en solicitudes de modelo secuenciales:

...
# Append user prompt and assistant response including thought signatures
messages.append(response1.choices[0].message)

# Execute the tool
tool_call_1 = response1.choices[0].message.tool_calls[0]
result_1 = get_current_temperature(**json.loads(tool_call_1.function.arguments))

# Append tool response to messages
messages.append(
    {
        "role": "user",
        "tool_call_id": tool_call_1.id,
        "content": json.dumps(result_1),
    }
)

response2 = client.chat.completions.create(
    model="gemini-3.6-flash",
    messages=messages,
    tools=tools,
    extra_body={
        "extra_body": {
            "google": {
                "thinking_config": {
                    "include_thoughts": True,
                },
            },
        },
    },
)

print(response2.choices[0].message.tool_calls)

Consulta el ejemplo de código completo.

Control manual

Si interactúas directamente con la API o administras cargas útiles JSON sin procesar, debes controlar correctamente la thought_signature incluida en el turno del modelo.

Debes mostrar esta firma en la parte exacta en la que se recibió cuando envíes el historial de conversaciones.

Si no se muestran las firmas adecuadas, Gemini 3 mostrará un error 400 Error "<Function Call> in the <index of contents array> content block is missing a thought_signature".

Respuestas de funciones multimodales

La llamada a función multimodal permite a los usuarios tener respuestas de función que contienen objetos multimodales, lo que permite mejorar el uso de las capacidades de llamada a función del modelo. La llamada a función estándar solo admite respuestas de función basadas en texto:

from google import genai
from google.genai import types

client = genai.Client()

# This is a manual, two turn multimodal function calling workflow:

# 1. Define the function tool
get_image_declaration = types.FunctionDeclaration(
   name="get_image",
   description="Retrieves the image file reference for a specific order item.",
   parameters={
       "type": "object",
       "properties": {
            "item_name": {
                "type": "string",
                "description": "The name or description of the item ordered (e.g., 'green shirt')."
            }
       },
       "required": ["item_name"],
   },
)
tool_config = types.Tool(function_declarations=[get_image_declaration])

# 2. Send a message that triggers the tool
prompt = "Show me the green shirt I ordered last month."
response_1 = client.models.generate_content(
    model="gemini-3.6-flash",
    contents=[prompt],
    config=types.GenerateContentConfig(
        tools=[tool_config],
    )
)

# 3. Handle the function call
function_call = response_1.function_calls[0]
requested_item = function_call.args["item_name"]
print(f"Model wants to call: {function_call.name}")

# Execute your tool (e.g., call an API)
# (This is a mock response for the example)
print(f"Calling external tool for: {requested_item}")

function_response_data = {
  "image_ref": {"$ref": "dress.jpg"},
}

function_response_multimodal_data = types.FunctionResponsePart(
   file_data=types.FunctionResponseFileData(
      mime_type="image/png",
      display_name="dress.jpg",
      file_uri="gs://cloud-samples-data/generative-ai/image/dress.jpg",
   )
)

# 4. Send the tool's result back
# Append this turn's messages to history for a final response.
history = [
  types.Content(role="user", parts=[types.Part(text=prompt)]),
  response_1.candidates[0].content,
  types.Content(
    role="user",
    parts=[
        types.Part.from_function_response(
            name=function_call.name,
            response=function_response_data,
            parts=[function_response_multimodal_data]
        )
    ],
  )
]

response_2 = client.models.generate_content(
  model="gemini-3.6-flash",
  contents=history,
  config=types.GenerateContentConfig(
      tools=[tool_config],
      thinking_config=types.ThinkingConfig(include_thoughts=True)
  ),
)

print(f"\nFinal model response: {response_2.text}")

Llamada a funciones de transmisión

Puedes usar argumentos de llamada a función parcial de transmisión para mejorar la experiencia de transmisión en el uso de herramientas. Para habilitar esta función, establece stream_function_call_arguments de forma explícita en true:

from google import genai
from google.genai import types

client = genai.Client()

get_weather_declaration = types.FunctionDeclaration(
  name="get_weather",
  description="Gets the current weather temperature for a given location.",
  parameters={
      "type": "object",
      "properties": {"location": {"type": "string"}},
      "required": ["location"],
  },
)
get_weather_tool = types.Tool(function_declarations=[get_weather_declaration])


for chunk in client.models.generate_content_stream(
   model="gemini-3.6-flash",
   contents="What's the weather in London and New York?",
   config=types.GenerateContentConfig(
       tools=[get_weather_tool],
       tool_config = types.ToolConfig(
           function_calling_config=types.FunctionCallingConfig(
               mode=types.FunctionCallingConfigMode.AUTO,
               stream_function_call_arguments=True,
           )
       ),
   ),
):
   function_call = chunk.function_calls[0]
   if function_call and function_call.name:
       print(f"{function_call.name}")
       print(f"will_continue={function_call.will_continue}")

Ejemplo de respuesta del modelo:

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "get_weather",
              "willContinue": true
            }
          }
        ]
      }
    }
  ]
}

Temperatura

  • Range for Gemini 3: 0.0 - 2.0 (default: 1.0)

Para Gemini 3, se recomienda mantener el parámetro temperature en su valor predeterminado de 1.0.

Si bien los modelos anteriores a menudo se beneficiaban de la temperatura de ajuste para controlar la creatividad en comparación con el determinismo, las capacidades de razonamiento de Gemini 3 están optimizadas para la configuración predeterminada.

Cambiar la temperatura (establecerla en menos de 1.0) puede provocar un comportamiento inesperado, como bucles o un rendimiento degradado, en especial en tareas matemáticas o de razonamiento complejas.

Funciones admitidas

Los modelos de Gemini 3 también admiten las siguientes funciones:

Prácticas recomendadas para escribir instrucciones

Gemini 3 es un modelo de razonamiento, lo que cambia la forma en que debes escribir las instrucciones.

  • Instrucciones precisas: Sé conciso en tus instrucciones de entrada. Gemini 3 responde mejor a las instrucciones directas y claras. Es posible que analice en exceso las técnicas de ingeniería de instrucciones detalladas o demasiado complejas que se usan para modelos más antiguos.
  • Detalles de salida: De forma predeterminada, Gemini 3 es menos detallado y prefiere proporcionar respuestas directas y eficientes. Si tu caso de uso requiere una personalidad más conversacional o "parlanchina", debes dirigir explícitamente el modelo en la instrucción (por ejemplo, "Explica esto como un asistente amigable y conversador").
  • Grounding: Para los casos de uso de grounding, te recomendamos que uses las siguientes instrucciones para desarrolladores: You are a strictly grounded assistant limited to the information provided in the User Context. In your answers, rely **only** on the facts that are directly mentioned in that context. You must **not** access or utilize your own knowledge or common sense to answer. Do not assume or infer from the provided facts; simply report them exactly as they appear. Your answer must be factual and fully truthful to the provided text, leaving absolutely no room for speculation or interpretation. Treat the provided context as the absolute limit of truth; any facts or details that are not directly mentioned in the context must be considered **completely untruthful** and **completely unsupported**. If the exact answer is not explicitly written in the context, you must state that the information is not available.
  • Uso de la herramienta Búsqueda de Google: Cuando se usa la herramienta Búsqueda de Google, Gemini 3 Flash a veces puede confundir la fecha y hora actuales con eventos en 2024. Esto puede hacer que el modelo formule consultas de búsqueda para el año incorrecto. Para asegurarte de que el modelo utilice el período correcto, refuerza explícitamente la fecha actual en system instructions: For time-sensitive user queries that require up-to-date information, you MUST follow the provided current time (date and year) when formulating search queries in tool calls. Remember it is 2025 this year.
  • Fecha límite de conocimiento: Para ciertas consultas, Gemini 3 Flash se beneficia de que se le indique explícitamente su fecha límite de conocimiento. Este es el caso cuando la herramienta Búsqueda de Google está inhabilitada y la consulta requiere explícitamente que el modelo pueda identificar los datos de corte en el conocimiento paramétrico. Recomendación: Agrega la siguiente cláusula a system instructions: Your knowledge cutoff date is January 2025.
  • Uso de media_resolution: Usa el parámetro media_resolution para controlar la cantidad máxima de tokens que usa el modelo para representar una imagen o fotogramas en videos. La alta resolución permitirá que el modelo capture detalles en una imagen y puede usar más tokens por fotograma, mientras que una resolución más baja permite optimizar el costo y la latencia de las imágenes con menos detalles visuales.
  • Mejora el análisis de video: Usa una tasa de muestreo de fotogramas por segundo (FPS) más alta para los videos que requieren un análisis temporal detallado, como la comprensión de acciones rápidas o el seguimiento de movimientos de alta velocidad.

Consideraciones sobre la migración

Ten en cuenta las siguientes funciones y restricciones cuando realices migraciones:

  • Nivel de razonamiento: Los modelos de Gemini 3 usan el thinking_level parámetro para controlar la cantidad de razonamiento interno que realiza el modelo (bajo o alto) y para equilibrar la calidad de la respuesta, la complejidad del razonamiento, la latencia y el costo.
  • Configuración de temperatura: Si tu código existente establece explícitamente temperature (en especial, en valores bajos para resultados deterministas), te recomendamos que quites este parámetro y uses el valor predeterminado de Gemini 3 de 1.0 para evitar posibles problemas de bucle o degradación del rendimiento en tareas complejas.
  • Firmas de razonamiento: Para los modelos de Gemini 3, si se espera una firma de razonamiento en un turno, pero no se proporciona, el modelo muestra un error en lugar de una advertencia.
  • Resolución de contenido multimedia y tokenización: Los modelos de Gemini 3 usan una longitud de secuencia variable para la tokenización de contenido multimedia en lugar de Pan and Scan, y tienen nuevas resoluciones predeterminadas y costos de tokens para imágenes, PDFs y videos.
  • Recuento de tokens para entrada multimodal: Los recuentos de tokens para entradas multimodales (imágenes, video, audio) son una estimación basada en la media_resolution elegida. Por lo tanto, es posible que el resultado de la llamada a la API count_tokens no coincida con los tokens consumidos finales. El uso preciso para la facturación solo está disponible después de la ejecución dentro de usage_metadata de la respuesta.
  • Consumo de tokens: La migración a los valores predeterminados de Gemini 3 puede aumentar el uso de tokens para imágenes y PDFs, pero disminuir el uso de tokens para videos. Si las solicitudes ahora superan la ventana de contexto debido a resoluciones predeterminadas más altas, se recomienda reducir explícitamente la resolución de contenido multimedia.
  • Comprensión de PDFs y documentos: Cambió la resolución predeterminada de OCR para PDFs. Si dependías de un comportamiento específico para el análisis de documentos densos, prueba la nueva media_resolution: "high" configuración para garantizar la precisión continua. Para los modelos de Gemini 3, los recuentos de tokens de PDF en usage_metadata se informan en la modalidad IMAGE en lugar de DOCUMENT.
  • Segmentación de imágenes: Los modelos de Gemini 3 no admiten la segmentación de imágenes. Para las cargas de trabajo que requieren segmentación de imágenes integrada, se recomienda seguir utilizando Gemini 2.5 Flash con el razonamiento desactivado.
  • Respuestas de funciones multimodales: Para los modelos de Gemini 3, puedes incluir datos de imágenes y PDFs en las respuestas de función.

Preguntas frecuentes

  1. ¿En qué región está disponible gemini-3.1-pro-preview en Google Cloud? Global

  2. ¿Cuáles son los límites de la ventana de contexto? Los modelos de Gemini 3 admiten una ventana de contexto de entrada de 1 millón de tokens y hasta 64,000 tokens de salida.

  3. ¿gemini-3.1-pro-preview admite la salida de imágenes? No.

  4. ¿gemini-3.1-pro-preview admite la API de Gemini Live? No.

¿Qué sigue?