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ñado para dar vida a cualquier idea a través del 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 Vertex AI, 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 Vertex AI 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 la versión 1.51.0 o posterior del SDK de IA generativa para Python.

pip install --upgrade google-genai

Configura variables de entorno para usar el SDK de IA generativa con Vertex AI

Reemplaza el valor de GOOGLE_CLOUD_PROJECT por el ID del proyecto de Google Cloud . El modelo de versión preliminar de Gemini 3 Pro gemini-3-pro-preview solo está disponible en los extremos globales:

export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True

Realiza tu primera solicitud

De forma predeterminada, Gemini 3 Pro usa el pensamiento dinámico para razonar 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 nivel de pensamiento bajo es ideal para tareas de alto rendimiento en las que la velocidad es primordial, ya que coincide aproximadamente con el perfil de latencia de Gemini 2.5 Flash y, al mismo tiempo, proporciona una calidad de respuesta superior.

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-pro-preview",
   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 complejo

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 avanzado de herramientas, usa niveles de pensamiento altos. Usa estas configuraciones para tareas que antes requerían modelos de razonamiento especializados.

Para tareas más lentas y que requieren mayor razonamiento, 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-pro-preview",
  contents=prompt,
  config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
          thinking_level=types.ThinkingLevel.HIGH # Dynamic thinking for high reasoning tasks
      )
  ),
)
print(response.text)

Nuevas funciones de la API

Gemini 3 introduce potentes mejoras en la API y nuevos parámetros diseñados para brindar a los desarrolladores un 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:

Cambio en la API o función nueva Documentación
Modelo: gemini-3-pro-preview Tarjeta de modelo Model Garden
Nivel de pensamiento Pensamiento
Resolución de medios Comprensión de imágenes Comprensión de videos Comprensión de audio Comprensión de documentos
Firma de pensamiento Firmas de pensamiento
Temperatura Referencia de la API
Respuestas de funciones multimodales Llamada a función: Respuestas de funciones multimodales
Llamada a función de transmisión Llamada a función: Llamada a función de transmisión

Nivel de pensamiento

El parámetro thinking_level te permite especificar un presupuesto de pensamiento 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 entre la latencia y el costo.

  • Baja: Minimiza la latencia y el costo. Es la mejor opción para seguir instrucciones o chatear.
  • Alto: Maximiza la profundidad del razonamiento. Predeterminado. Pensamiento dinámico El modelo puede tardar mucho más en generar el primer token, pero el resultado se verificará de forma más exhaustiva.

Ejemplo del SDK de IA generativa

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
   model="gemini-3-pro-preview",
   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.
  • El valor reasoning_effort medium se asigna a thinking_level alto.
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-pro-preview",
    reasoning_effort="medium", # Map to thinking_level high.
    messages=[{"role": "user", "content": prompt}],
)

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

Resolución de medios

Gemini 3 introduce 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 pequeño o identificar detalles, 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 de PDF o fotograma de video.

Puedes establecer la resolución en low, medium o high para cada parte de los medios individualmente o de forma global (con generation_config). Si no se especifica, el modelo usa la configuración predeterminada óptima según el tipo de medio.

Tokens
Imagen Video PDF
MEDIA_RESOLUTION_UNSPECIFIED (PREDETERMINADO) 1120 70 560
MEDIA_RESOLUTION_LOW 280 70 280
MEDIA_RESOLUTION_MEDIUM 560 70 560
MEDIA_RESOLUTION_HIGH 1120 280 1120
Resolución de medios Tokens máximos Orientación sobre el uso
high 1120 Tareas de análisis de imágenes para garantizar la máxima calidad
medium 560
low Imagen: 280 Video: 70 Es suficiente para la mayoría de las tareas. Nota: En el caso de los videos, low tiene un máximo de 70 tokens por fotograma.

Cómo establecer media_resolution por parte individual

Puedes establecer media_resolution para cada parte de contenido multimedia individual:

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
  model="gemini-3-pro-preview",
  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-pro-preview",
  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 pensamientos

Las firmas de pensamiento 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 funciones.

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

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

¿Por qué son importantes las firmas de pensamiento?

Sin firmas de pensamiento, el modelo "olvida" sus pasos de razonamiento específicos durante la fase de ejecución de la herramienta. Pasar la firma de vuelta garantiza lo siguiente:

  • Continuidad del contexto: El modelo conserva el motivo por el que se llamó a la herramienta.
  • Razonamiento complejo: Permite realizar 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 pensamiento?

Gemini 3 Pro aplica una validación más estricta y un manejo actualizado en las firmas de pensamiento que se introdujeron originalmente en Gemini 2.5. Para garantizar que el modelo mantenga el contexto en varios turnos de una conversación, debes devolver las firmas de pensamiento en tus solicitudes posteriores.

  • Las respuestas del modelo con una llamada a función siempre devolverán una firma de pensamiento.
  • Cuando hay llamadas a funciones paralelas, la primera parte de la llamada a función que devuelve la respuesta del modelo tendrá una firma de pensamiento.
  • Cuando hay llamadas a funciones secuenciales (de varios pasos), cada llamada a función tendrá una firma y se espera que los clientes devuelvan la firma.
  • Las respuestas del modelo sin una llamada a función devolverán una firma de pensamiento dentro de la última parte que devuelva el modelo.

¿Cómo se manejan las firmas de pensamiento?

Existen dos formas principales de controlar las firmas de pensamiento: automáticamente con los SDKs de IA generativa o la API de OpenAI, o bien de forma manual si interactúas directamente con la API.

Si usas los SDKs 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, los thought_signatures se controlan automáticamente. No es necesario que realices ningún cambio en tu código.

Ejemplo de llamada a función manual

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

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-pro-preview",
   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="tool",
        parts=[
            types.Part.from_function_response(
                name=function_call.name,
                response=function_response_data,
            )
        ],
    )
]

response_2 = client.models.generate_content(
   model="gemini-3-pro-preview",
   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 en la llamada a funciones automática, las firmas de pensamiento 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-pro-preview",
    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 pensamiento se controlan automáticamente agregando la respuesta completa del modelo en solicitudes secuenciales del modelo:

...
# 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": "tool",
        "tool_call_id": tool_call_1.id,
        "content": json.dumps(result_1),
    }
)

response2 = client.chat.completions.create(
    model="gemini-3-pro-preview",
    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.

Manipulación manual

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

Debes devolver esta firma en la parte exacta en la que se recibió cuando envíes el historial de conversación.

Si no se devuelven las firmas adecuadas, Gemini 3 devolverá un error 400 "Falta un thought_signature en el bloque de contenido <Function Call> en el <índice del array de contenido>".

Respuestas de funciones multimodales

La llamada a funciones multimodal permite que los usuarios obtengan respuestas de funciones que contienen objetos multimodales, lo que mejora el uso de las capacidades de llamada a funciones del modelo. Las llamadas a funciones estándar solo admiten respuestas de funciones 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-pro-preview",
    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="tool",
    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-pro-preview",
  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 función de transmisión

Puedes usar argumentos de llamadas a funciones parciales 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-pro-preview",
   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)

En el caso de 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 ajustar la temperatura para controlar la creatividad en comparación con el determinismo, las capacidades de razonamiento de Gemini 3 se optimizaron para el parámetro de configuración predeterminado.

Cambiar la temperatura (configurarla en un valor inferior a 1.0) puede generar un comportamiento inesperado, como bucles o un rendimiento degradado, en especial en tareas complejas de razonamiento o matemáticas.

Funciones admitidas

Gemini 3 Pro también admite las siguientes funciones:

Sugiere prácticas recomendadas

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

  • Instrucciones precisas: Sé conciso en tus instrucciones. 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 usaban para los modelos anteriores.
  • Nivel de detalle de la respuesta: De forma predeterminada, Gemini 3 es menos detallado y prefiere proporcionar respuestas directas y eficientes. Si tu caso de uso requiere un asistente más conversacional o "parlanchín", debes dirigir explícitamente el modelo en la instrucción (por ejemplo, "Explica esto como un asistente amigable y parlanchín").

Consideraciones sobre la migración

Ten en cuenta las siguientes funciones y restricciones cuando realices la migración:

  • Nivel de pensamiento: Gemini 3 Pro y los modelos posteriores usan el parámetro thinking_level 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 de forma explícita temperature (en especial, en valores bajos para obtener resultados determinísticos), se recomienda quitar este parámetro y usar el valor predeterminado de Gemini 3 de 1.0 para evitar posibles problemas de bucles o degradación del rendimiento en tareas complejas.
  • Firmas de pensamiento: En el caso de Gemini 3 Pro y modelos posteriores, si se espera una firma de pensamiento en un turno, pero no se proporciona, el modelo devuelve un error en lugar de una advertencia.
  • Resolución de medios y tokenización: Gemini 3 Pro y los modelos posteriores usan una longitud de secuencia variable para la tokenización de medios 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 la entrada multimodal: Los recuentos de tokens para las entradas multimodales (imágenes, video y audio) son una estimación basada en el media_resolution elegido. Por lo tanto, es posible que el resultado de la llamada a la API de count_tokens no coincida con los tokens finales consumidos. El uso preciso para la facturación solo está disponible después de la ejecución dentro del usage_metadata de la respuesta.
  • Consumo de tokens: La migración a la configuración predeterminada de Gemini 3 Pro 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 los medios.
  • Comprensión de documentos y archivos PDF: Cambió la resolución predeterminada del OCR para archivos PDF. Si te basaste en un comportamiento específico para el análisis de documentos densos, prueba el nuevo parámetro de configuración media_resolution: "high" para garantizar la precisión continua. En el caso de Gemini 3 Pro y modelos posteriores, los recuentos de tokens de PDF en usage_metadata se registran en la modalidad IMAGE en lugar de DOCUMENT.
  • Segmentación de imágenes: Los modelos de Gemini 3 Pro y versiones posteriores 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 modo de pensamiento desactivado.
  • Respuestas de funciones multimodales: En el caso de los modelos de Gemini Pro 3 y versiones posteriores, puedes incluir datos de imágenes y PDF en las respuestas de funciones.

Preguntas frecuentes

  1. ¿Cuál es el corte de conocimiento de Gemini 3 Pro? Gemini 3 tiene un corte de conocimiento de enero de 2025.

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

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

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

  5. ¿gemini-3-pro-preview admite la API de Gemini Live? No.

¿Qué sigue?