Empezar a usar Gemini 3

Gemini 3 es nuestra familia de modelos más inteligente hasta la fecha, basada en un razonamiento de vanguardia. Se ha diseñado para dar vida a cualquier idea dominando los flujos de trabajo de agentes, la programación autónoma y las tareas multimodales complejas.

Esta guía ofrece una ruta práctica y consolidada para empezar a usar Gemini 3 en Vertex AI, destacando las funciones clave y las prácticas recomendadas de Gemini 3.

Guía de inicio rápido

Antes de empezar, debes autenticarte en Vertex AI mediante una clave de API o credenciales predeterminadas de la aplicación (ADC). Consulta más información sobre los métodos de autenticación.

Instalar el SDK de IA generativa de Google

Para usar las funciones de la API de Gemini 3, necesitas la versión 1.51.0 o una posterior del SDK de IA generativa para Python.

pip install --upgrade google-genai

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

Sustituye el valor GOOGLE_CLOUD_PROJECT por el ID de tu proyecto Google Cloud . El modelo de vista previa de Gemini 3 Pro gemini-3-pro-preview solo está disponible en los endpoints globales:

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

Enviar la primera solicitud

De forma predeterminada, Gemini 3 Pro usa el pensamiento dinámico para analizar las peticiones. Para obtener respuestas más rápidas y con menor latencia cuando no se requiere un razonamiento complejo, puedes limitar el thinking_level del modelo. El pensamiento bajo es ideal para tareas de alto rendimiento en las que la velocidad es primordial, ya que se ajusta aproximadamente al perfil de latencia de Gemini 2.5 Flash y, al mismo tiempo, ofrece una calidad de respuesta superior.

Para obtener respuestas rápidas y con baja latencia:

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)

Probar tareas de razonamiento complejas

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

Para tareas más lentas que requieren un razonamiento profundo:

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 incluye potentes mejoras en la API y nuevos parámetros diseñados para ofrecer a los desarrolladores un control granular sobre el rendimiento (latencia y coste), el comportamiento del modelo y la fidelidad multimodal.

En esta tabla se resumen las nuevas funciones y los parámetros principales disponibles, así como enlaces directos a su documentación detallada:

Nueva función o cambio en la API Documentación
Modelo: gemini-3-pro-preview Tarjeta de modelo Model Garden
Nivel de pensamiento Pensando
Resolución de los archivos multimedia Comprensión de imágenes Comprensión de vídeos Comprensión de audio Comprensión de documentos
Firma de pensamiento Firmas de pensamientos
Temperatura Referencia de la API
Respuestas de funciones multimodales Llamadas de función: respuestas de funciones multimodales
Llamadas de función de streaming Llamadas de función: llamadas de función de streaming

Nivel de pensamiento

El parámetro thinking_level te permite especificar un presupuesto de reflexión para la generación de respuestas del modelo. Al seleccionar uno de los dos estados, puedes equilibrar explícitamente las ventajas y desventajas entre la calidad de la respuesta y la complejidad del razonamiento, la latencia y el coste.

  • Baja: minimiza la latencia y el coste. Ideal 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 habrá revisado más a fondo.

Ejemplo de 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

En el caso de los usuarios que utilizan la capa de compatibilidad de 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 los archivos multimedia

Gemini 3 introduce un control granular sobre el procesamiento de la visión multimodal mediante 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 el número máximo de tokens asignados por imagen de entrada, página PDF o fotograma de vídeo.

Puedes definir la resolución en low, medium o high por cada parte del contenido multimedia o de forma global (con generation_config). Si no se especifica, el modelo usa los valores predeterminados óptimos en función del tipo de contenido multimedia.

Tokens
Image Vídeo 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 los medios Tokens máximos Recomendaciones de uso
high 1120 Tareas de análisis de imágenes para asegurar la máxima calidad.
medium 560
low Imagen: 280 Vídeo: 70 Suficiente para la mayoría de las tareas. Nota: En el caso de los vídeos, low tiene un máximo de 70 tokens por fotograma.

Configuración de media_resolution por pieza individual

Puedes definir media_resolution para cada parte de contenido multimedia:

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)

Configurar media_resolution de forma global

También puedes definir 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 cifrados que conservan el estado del razonamiento del modelo durante las conversaciones de varias interacciones, sobre todo 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 al modelo reanudar su cadena de pensamiento sin problemas una vez que proporciones el resultado de la función.

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

¿Por qué son importantes las firmas de pensamiento?

Sin firmas de pensamiento, el modelo "olvida" los pasos de razonamiento específicos durante la fase de ejecución de la herramienta. Al devolver la firma, se asegura lo siguiente:

  • Continuidad del contexto: el modelo conserva el motivo por el que se ha llamado a la herramienta.
  • Razonamiento complejo: permite realizar tareas de varios pasos en las que el resultado de una herramienta influye en el razonamiento de la siguiente.

¿Dónde se devuelven las firmas de pensamiento?

Gemini 3 Pro aplica una validación más estricta y una gestión actualizada de las firmas de pensamientos, que se introdujeron originalmente en Gemini 2.5. Para asegurarte de que el modelo mantiene el contexto en varias interacciones de una conversación, debes devolver las firmas de pensamiento en tus solicitudes posteriores.

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

¿Cómo se gestionan las firmas de pensamiento?

Hay dos formas principales de gestionar las firmas de pensamiento: automáticamente, mediante los SDKs de IA generativa o la API de OpenAI, o manualmente, si interactúas directamente con la API.

Si usas los SDKs de IA generativa de Google (Python, Node.js, Go y Java) o la API Chat Completions de OpenAI, y utilizas las funciones estándar del historial de chat o añades la respuesta completa del modelo, thought_signatures se gestionan automáticamente. No tienes que hacer ningún cambio en el código.

Ejemplo de llamada de función manual

Cuando se usa el SDK de IA generativa, las firmas de pensamiento se gestionan automáticamente añadiendo 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-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 funciones automática

Cuando se usa el SDK de IA generativa en la llamada automática a funciones, las firmas de pensamiento se gestionan 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 Chat Completions de OpenAI, las firmas de pensamiento se gestionan automáticamente añadiendo 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": "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 gestionas cargas útiles JSON sin formato, debes gestionar correctamente el thought_signature incluido en el turno del modelo.

Debes devolver esta firma en la parte exacta en la que se recibió al enviar el historial de la conversación.

Si no se devuelven las firmas adecuadas, Gemini 3 devolverá un error 400 "<Function Call> in the <index of contents array> content block is missing a thought_signature" (Falta un thought_signature en el bloque de contenido <index of contents array>).

Respuestas de funciones multimodales

La llamada de función multimodal permite a los usuarios obtener respuestas de funciones que contengan objetos multimodales, lo que mejora el uso de las funciones de llamada del modelo. La llamada a funciones estándar solo admite 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}")

Llamadas de función de streaming

Puedes usar argumentos de llamada de función parciales de streaming para mejorar la experiencia de streaming al usar herramientas. Para habilitar esta función, debes asignar explícitamente el valor true a stream_function_call_arguments:

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 encarecidamente mantener el parámetro temperature con su valor predeterminado, 1.0.

Aunque los modelos anteriores se beneficiaban a menudo de la temperatura de ajuste para controlar la creatividad frente al determinismo, las funciones de razonamiento de Gemini 3 están optimizadas para el ajuste predeterminado.

Cambiar la temperatura (ajustarla a menos de 1.0) puede provocar un comportamiento inesperado, como bucles o un rendimiento deficiente, sobre todo en tareas matemáticas o de razonamiento complejas.

Funciones compatibles

Gemini 3 Pro también admite las siguientes funciones:

Prácticas recomendadas para escribir peticiones

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

  • Instrucciones precisas: sé conciso en tus peticiones. Gemini 3 responde mejor a las instrucciones directas y claras. Puede analizar en exceso las técnicas de ingeniería de peticiones detalladas o demasiado complejas que se usan en modelos antiguos.
  • Nivel de detalle de la salida: de forma predeterminada, Gemini 3 es menos detallado y prefiere ofrecer respuestas directas y eficientes. Si tu caso práctico requiere un perfil más conversacional o "parlanchín", debes dirigir explícitamente al modelo en la petición (por ejemplo, "Explícame esto como si fueras un asistente amable y parlanchín").

Consideraciones sobre la migración

Ten en cuenta las siguientes funciones y restricciones al migrar:

  • Nivel de reflexión: 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 las respuestas, la complejidad del razonamiento, la latencia y el coste.
  • Ajustes de temperatura: si tu código define explícitamente temperature (sobre todo con valores bajos para obtener resultados deterministas), te recomendamos que elimines este parámetro y uses el valor predeterminado de Gemini 3, 1.0, para evitar posibles problemas de bucles o una degradación del rendimiento en tareas complejas.
  • Firmas de pensamiento: en 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 los archivos multimedia y tokenización: Gemini 3 Pro y modelos posteriores utilizan una longitud de secuencia variable para la tokenización de archivos multimedia en lugar de Pan y Scan, y tienen nuevas resoluciones predeterminadas y costes de tokens para imágenes, PDFs y vídeos.
  • Recuento de tokens para entradas multimodales: el recuento de tokens de las entradas multimodales (imágenes, vídeo y audio) es una estimación basada en el media_resolution elegido. Por lo tanto, es posible que el resultado de la llamada a la API count_tokens no coincida con los tokens consumidos finalmente. El uso preciso para la facturación solo está disponible después de la ejecución en el usage_metadata de la respuesta.
  • Consumo de tokens: si migras a los valores predeterminados de Gemini 3 Pro, puede que aumente el uso de tokens para imágenes y PDFs, pero que disminuya en el caso de los vídeos. Si las solicitudes ahora superan la ventana de contexto debido a resoluciones predeterminadas más altas, se recomienda reducir explícitamente la resolución del contenido multimedia.
  • Comprensión de PDFs y documentos: la resolución predeterminada del OCR para PDFs ha cambiado. Si dependías de un comportamiento específico para el análisis de documentos densos, prueba el nuevo ajuste media_resolution: "high" para asegurarte de que la precisión no se vea afectada. En el caso de Gemini 3 Pro y modelos posteriores, el recuento de tokens de PDF en usage_metadata se registra en la modalidad IMAGE en lugar de DOCUMENT.
  • Segmentación de imágenes: los modelos Gemini 3 Pro y posteriores no admiten la segmentación de imágenes. En el caso de las cargas de trabajo que requieran segmentación de imágenes integrada, se recomienda seguir usando Gemini 2.5 Flash con la función de reflexión desactivada.
  • Respuestas de funciones multimodales: en los modelos Gemini 3 Pro y posteriores, puedes incluir datos de imágenes y PDFs en las respuestas de funciones.

Preguntas frecuentes

  1. ¿Cuál es la fecha límite de los conocimientos de Gemini 3 Pro? Gemini 3 tiene una fecha límite de conocimientos de enero del 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 Gemini Live? No.

Siguientes pasos