Gemini 3.8 Flash ya está disponible. Pruébalo.

Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Novedades de Gemini 3.5 Flash

Modelo más reciente Otros modelos

Gemini 3.5 Flash (gemini-3.5-flash) es un modelo Flash de generación anterior obsoleto de la serie Gemini 3. Las solicitudes a gemini-3.5-flash se enrutan automáticamente a Gemini 3.6 Flash. Para conocer nuestro modelo Flash más reciente, consulta Gemini 3.8 Flash.

Esta guía se conserva como referencia histórica y documenta los cambios básicos en la API de Gemini 3.x y las recomendaciones de parámetros.

Resumen del modelo

Modelo	ID de modelo	Estado
Gemini 3.5 Flash	`gemini-3.5-flash`	Obsoleto (se redirecciona automáticamente a `gemini-3.6-flash`).

Gemini 3.5 Flash admitía la ventana de contexto de 1 millón de tokens, un máximo de 65,000 tokens de salida, la capacidad de pensar y el mismo conjunto de herramientas y funciones de la plataforma que Gemini 3 Flash, incluido el Uso de la computadora (versión preliminar).

Para conocer las especificaciones completas, consulta la descripción general de los modelos.

Guía de inicio rápido

En todos los ejemplos de esta guía, se usa la API de Interactions. También se admite la API de GenerateContent, y se aplican las mismas opciones de configuración y recomendaciones.

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Explain how parallel agentic execution works in three sentences."
)
print(interaction.output_text)

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

async function main() {
  const interaction = await client.interactions.create({
    model: "gemini-3.5-flash",
    input: "Explain how parallel agentic execution works in three sentences.",
  });
  console.log(interaction.output_text);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.5-flash"))
        .input(
            InteractionsInput.of(
                "Explain how parallel agentic execution works in three sentences."))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.5-flash"),
            Input: interactions.NewInteractionsInput("Explain how parallel agentic execution works in three sentences."),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3.5-flash",
    "input": "Explain how parallel agentic execution works in three sentences."
  }'

Novedades

Rendimiento sostenido: Optimizado para tareas de programación y con agentes a gran escala.
Ejecución basada en agentes: Implementación de subagentes, resolución de problemas y bucles basados en agentes rápidos a gran escala.
Codificación: Ciclos de codificación iterativos, exploración rápida y creación de prototipos para probar rutas alternativas y explorar soluciones de forma dinámica
Largo plazo: Flujos de trabajo de varios pasos y uso de herramientas a gran escala
Conservación del pensamiento: El modelo mantiene el razonamiento intermedio en las conversaciones de varios turnos de forma automática. No se necesitan cambios en la API.
Nuevo nivel de esfuerzo predeterminado: El esfuerzo de pensamiento predeterminado cambió de high a medium. Consulta Nuevo nivel de esfuerzo predeterminado para obtener más detalles.
Mejora del pensamiento de low: low mejoró significativamente para las tareas de código y de agentes que requieren menos pasos, lo que ofrece una gran calidad con menor latencia y costo.

Cómo elegir el modelo de Flash adecuado

Dado que gemini-3.5-flash dejó de estar disponible y se enruta automáticamente a gemini-3.6-flash, te recomendamos que migres a uno de los siguientes modelos activos:

Gemini 3.8 Flash: Es nuestro modelo Flash más reciente y más inteligente para flujos de trabajo complejos de programación y Agentic Workflows. Consulta la guía de Gemini 3.8 Flash.
Gemini 3.6 Flash: Es un reemplazo directo de gemini-3.5-flash con un uso reducido de tokens y precios de salida más bajos. Consulta la guía de Gemini 3.6 Flash y 3.5 Flash-Lite.
Gemini 3.5 Flash-Lite o Gemini 3.1 Flash-Lite: Para tareas de bajo costo y gran volumen que no requieren la profundidad de razonamiento completa de Flash, usa Gemini 3.5 Flash-Lite o Gemini 3.1 Flash-Lite.

Cambios en el comportamiento

Nuevo nivel de esfuerzo predeterminado: `medium`

El esfuerzo de pensamiento predeterminado ahora es medium, que cambió de high en la versión preliminar de Gemini 3 Flash. medium produce resultados muy buenos en una amplia variedad de tareas, además de ser más rápido y rentable. Para problemas complejos, high alienta al modelo a pensar de manera más profunda.

Nivel de esfuerzo	Cuándo debe utilizarse
`minimal`	Se optimizó para la velocidad de respuesta. Casos de uso similares a los de un chat, respuestas fácticas rápidas y llamadas a herramientas más sencillas
`low`	Tareas de código y de agentes que requieren una latencia más baja y menos pasos También funciona bien para tareas de análisis y escritura que requieren algo de reflexión.
`medium` (predeterminado)	Mejor calidad para la mayoría de las tareas. Se recomienda para casos de uso complejos de código y agentes.
`high`	Maximiza la capacidad del modelo para pensar y usar herramientas. Ideal para razonamiento complejo, matemáticas difíciles y las tareas de código o de agente más difíciles. Permite pensamientos extendidos y llamadas a funciones.

Para anular el valor predeterminado, establece thinking_level en tu configuración:

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Prove that the square root of 2 is irrational.",
    generation_config={"thinking_level": "high"},
)
print(interaction.output_text)

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

async function main() {
  const interaction = await client.interactions.create({
    model: "gemini-3.5-flash",
    input: "Prove that the square root of 2 is irrational.",
    generationConfig: { thinkingLevel: "high" },
  });
  console.log(interaction.output_text);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.GenerationConfig;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ThinkingLevel;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.5-flash"))
        .input(InteractionsInput.of("Prove that the square root of 2 is irrational."))
        .generationConfig(GenerationConfig.builder().thinkingLevel(ThinkingLevel.HIGH).build())
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.5-flash"),
            Input: interactions.NewInteractionsInput("Prove that the square root of 2 is irrational."),
            GenerationConfig: &interactions.GenerationConfig{
                ThinkingLevel: interactions.ThinkingLevelHigh.ToPointer(),
            },
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3.5-flash",
    "input": "Prove that the square root of 2 is irrational.",
    "generation_config": {"thinking_level": "high"}
  }'

En la siguiente tabla, se muestran los niveles de pensamiento que admite cada modelo:

Nivel de razonamiento	Gemini 3.5 Flash	Gemini 3.1 Pro	Gemini 3.1 Flash-Lite	Gemini 3 Flash	Descripción
`minimal`	Admitido	No compatible	Admitido (predeterminado)	Admitido	Coincide con el parámetro de configuración "sin razonamiento" para la mayoría de las búsquedas. Ten en cuenta que `minimal` no garantiza que el razonamiento esté desactivado. Es posible que el modelo razone de forma muy mínima para tareas complejas.
`low`	Admitido	Admitido	Admitido	Admitido	Minimiza la latencia y el costo.
`medium`	Admitido (predeterminado)	Admitido	Admitido	Admitido	Pensamiento equilibrado para la mayoría de las tareas.
`high`	Admitido (dinámico)	Admitido (predeterminado, dinámico)	Admitido (dinámico)	Admitido (predeterminado, dinámico)	Maximiza la profundidad del razonamiento.

Preservación de pensamientos

El modelo mantiene el razonamiento intermedio en las conversaciones de varios turnos de forma automática. Cuando está presente en el historial de conversaciones, el contexto de razonamiento se mantiene, lo que mejora el rendimiento en tareas complejas de varios pasos, como la depuración iterativa y la refactorización de código. No se necesitan cambios en la API:

API de Interactions: Los pensamientos ya se conservan automáticamente. No hay cambios en el comportamiento.
API de GenerateContent: A partir de Gemini 3.5 Flash, el modelo usa el contexto de razonamiento de todos los turnos anteriores cuando hay firmas de pensamiento en el historial de conversación. Para habilitar esta opción, pasa el historial de conversación completo y sin modificar (incluidas las firmas de pensamiento) en contents. Los SDKs controlan esto automáticamente.

Actualizaciones de parámetros y prácticas recomendadas en Gemini 3.x

Las siguientes condiciones se aplican a todos los modelos de Gemini 3.x, incluido Gemini 3.5 Flash.

temperature, top_p, top_k: Te recomendamos que no cambies los valores predeterminados. Las capacidades de razonamiento de Gemini 3 están optimizadas para la configuración predeterminada.
excepto porque se usa thinking_level en lugar de thinking_budget.
Coincidencia de la respuesta de la llamada a función: id, name y el recuento de respuestas deben coincidir con las llamadas anteriores.
Respuestas de funciones multimodales: Incluye contenido multimodal dentro de la respuesta de la función, no fuera de ella.
Instrucciones intercaladas en las respuestas de funciones: Se agregan al texto de la respuesta de la función, no como partes separadas.
Reduce las llamadas a herramientas innecesarias: Usa niveles de pensamiento más bajos o experimenta con instrucciones del sistema para reducir las llamadas a herramientas en los flujos de trabajo de agentes.

Consulta las siguientes secciones para saber cómo actualizar tu código.

Parámetros de muestreo (ya no se recomiendan)

temperature, top_p y top_k ya no se recomiendan para todos los modelos de Gemini 3.x. Las capacidades de razonamiento de Gemini 3 están optimizadas para la configuración predeterminada. Quita estos parámetros de todas las solicitudes.

# ⚠️ Remove these parameters (not recommended)
generation_config = {
    "temperature": 0.7,
    "top_p": 0.9,
    "top_k": 40,
}

Para garantizar el determinismo, te recomendamos que definas una instrucción del sistema con reglas explícitas para tu caso de uso específico.

`thinking_budget` (ya no se recomienda)

Ya no se recomienda el parámetro numérico sin procesar thinking_budget en todos los modelos de Gemini 3.x. En su lugar, usa la enumeración de cadena thinking_level.

# ⚠️ Before (not recommended)
generation_config = {
    "thinking": {"thinking_budget": 7500},
}

# ✅ After
generation_config = {
    "thinking": {"thinking_level": "medium"},
}

Valores disponibles: minimal, low, medium (predeterminado) y high.

Llamada a función: Coincidencia estricta de respuestas

La API de Interactions ya muestra errores en las respuestas de funciones que no coinciden. La API de GenerateContent aún no arroja errores, pero las respuestas que no coinciden hacen que el modelo devuelva respuestas vacías con finish_reason: STOP en la mayoría de los casos. Siempre sigue estas convenciones:

Requisito	Detalles
Incluir `id`	Cada `FunctionResponse` debe incluir el `id` del `FunctionCall` correspondiente.
Partido `name`	El `name` de la respuesta debe coincidir con el `name` de la llamada.
Recuentos de coincidencias	Devuelve exactamente un `FunctionResponse` para cada `FunctionCall` recibido.

Python

# ✅ Include matching call_id and name in the function_result
final_interaction = client.interactions.create(
    model="gemini-3.5-flash",
    previous_interaction_id=interaction.id,
    tools=[my_tool],
    input=[{
        "type": "function_result",
        "name": fc_step.name,
        "call_id": fc_step.id,
        "result": [{"type": "text", "text": json.dumps(result)}],
    }],
)

JavaScript

// ✅ Include matching call_id and name in the function_result
const finalInteraction = await client.interactions.create({
  model: "gemini-3.5-flash",
  previousInteractionId: interaction.id,
  tools: [myTool],
  input: [{
    type: "function_result",
    name: fcStep.name,
    call_id: fcStep.id,
    result: [{ type: "text", text: JSON.stringify(result) }],
  }],
});

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Function;
import com.google.genai.gaos.models.interactions.FunctionResultStep;
import com.google.genai.gaos.models.interactions.FunctionResultStepResultUnion;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.List;

Client client = new Client();

// Assumes interactionId, callId, functionName, myTool, and resultJson from previous step
String interactionId = "interaction-id-123";
String callId = "call-id-123";
String functionName = "get_weather";
Function myTool = Function.builder().name(functionName).build();
String resultJson = "{\"temperature\": \"72F\"}";

// ✅ Include matching callId and name in the FunctionResultStep
FunctionResultStep functionResult =
    FunctionResultStep.builder()
        .name(functionName)
        .callId(callId)
        .result(
            FunctionResultStepResultUnion.of(
                Arrays.asList(TextContent.builder().text(resultJson).build())))
        .build();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.5-flash"))
        .previousInteractionId(interactionId)
        .tools(Arrays.asList(myTool))
        .input(InteractionsInput.ofStep(Arrays.asList(functionResult)))
        .build();

Interaction finalInteraction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

Go

package main

import (
    "context"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    // Assumes interactionID, callID, functionName, myTool, and resultJSON from previous step
    interactionID := "interaction-id-123"
    callID := "call-id-123"
    functionName := "get_weather"
    myTool := interactions.NewTool(interactions.Function{Name: genai.Ptr(functionName)})
    resultJSON := `{"temperature": "72F"}`

    // ✅ Include matching CallID and Name in the FunctionResultStep
    functionResult := interactions.NewStep(interactions.FunctionResultStep{
        Name:   genai.Ptr(functionName),
        CallID: callID,
        Result: interactions.NewFunctionResultStepResultUnion([]interactions.FunctionResultSubcontent{
            interactions.NewFunctionResultSubcontent(interactions.TextContent{Text: resultJSON}),
        }),
    })

    finalRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model:                 interactions.Model("gemini-3.5-flash"),
            PreviousInteractionID: genai.Ptr(interactionID),
            Tools:                 []interactions.Tool{myTool},
            Input:                 interactions.NewInteractionsInput([]interactions.Step{functionResult}),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    _ = finalRes
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3.5-flash",
    "previous_interaction_id": "<INTERACTION_ID>",
    "tools": [...],
    "input": [{
      "type": "function_result",
      "name": "my_function",
      "call_id": "<CALL_ID>",
      "result": [{"type": "text", "text": "..."}]
    }]
  }'

Respuestas de funciones multimodales

A menudo, vemos que los clientes proporcionan imágenes fuera de la respuesta de la función. Esto puede generar un comportamiento inesperado del modelo (p.ej., fuga de pensamientos) y producir resultados de menor calidad. Sigue la recomendación en la documentación de la API de Multimodal Function Responses y, en su lugar, incluye contenido multimodal en las partes de la respuesta de la función que envías al modelo. El modelo puede procesar este contenido multimodal en su siguiente turno para producir una respuesta más fundamentada.

Python

# ✅ Include multimodal content in the function response
final_interaction = client.interactions.create(
    model="gemini-3.5-flash",
    previous_interaction_id=interaction.id,
    input=[
        {
            "type": "function_result",
            "name": tool_call.name,
            "call_id": tool_call.id,
            "result": [
                {"type": "text", "text": "instrument.jpg"},
                {
                    "type": "image",
                    "mime_type": "image/jpeg",
                    "data": base64_image_data,
                },
            ],
        }
    ],
)

JavaScript

// ✅ Include multimodal content in the function response
const finalInteraction = await client.interactions.create({
  model: "gemini-3.5-flash",
  previousInteractionId: interaction.id,
  input: [{
    type: "function_result",
    name: toolCall.name,
    call_id: toolCall.id,
    result: [
      { type: "text", text: "instrument.jpg" },
      {
        type: "image",
        mime_type: "image/jpeg",
        data: base64ImageData,
      },
    ],
  }],
});

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.FunctionResultStep;
import com.google.genai.gaos.models.interactions.FunctionResultStepResultUnion;
import com.google.genai.gaos.models.interactions.ImageContent;
import com.google.genai.gaos.models.interactions.ImageContentMimeType;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.List;

Client client = new Client();

// Assumes interactionId, callId, functionName, and base64ImageData from previous step
String interactionId = "interaction-id-123";
String callId = "call-id-123";
String functionName = "get_instrument_image";
String base64ImageData = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";

// ✅ Include multimodal content in the function response
FunctionResultStep functionResult =
    FunctionResultStep.builder()
        .name(functionName)
        .callId(callId)
        .result(
            FunctionResultStepResultUnion.of(
                Arrays.asList(
                    TextContent.builder().text("instrument.jpg").build(),
                    ImageContent.builder()
                        .mimeType(ImageContentMimeType.IMAGE_JPEG)
                        .data(base64ImageData)
                        .build())))
        .build();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.5-flash"))
        .previousInteractionId(interactionId)
        .input(InteractionsInput.ofStep(Arrays.asList(functionResult)))
        .build();

Interaction finalInteraction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

Go

package main

import (
    "context"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    // Assumes interactionID, callID, functionName, and base64ImageData from previous step
    interactionID := "interaction-id-123"
    callID := "call-id-123"
    functionName := "get_instrument_image"
    base64ImageData := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="

    // ✅ Include multimodal content in the function response
    functionResult := interactions.NewStep(interactions.FunctionResultStep{
        Name:   genai.Ptr(functionName),
        CallID: callID,
        Result: interactions.NewFunctionResultStepResultUnion([]interactions.FunctionResultSubcontent{
            interactions.NewFunctionResultSubcontent(interactions.TextContent{
                Text: "instrument.jpg",
            }),
            interactions.NewFunctionResultSubcontent(interactions.ImageContent{
                MimeType: interactions.ImageContentMimeType("image/jpeg").ToPointer(),
                Data:     genai.Ptr(base64ImageData),
            }),
        }),
    })

    finalRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model:                 interactions.Model("gemini-3.5-flash"),
            PreviousInteractionID: genai.Ptr(interactionID),
            Input:                 interactions.NewInteractionsInput([]interactions.Step{functionResult}),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    _ = finalRes
}

Instrucciones intercaladas en las respuestas de funciones

A menudo, vemos que los clientes proporcionan instrucciones adicionales junto con las respuestas de las funciones como Parts posteriores. Esto puede generar un comportamiento inesperado del modelo (p.ej., fuga de pensamiento) y producir resultados de menor calidad. En cambio, agrega cualquier instrucción adicional al final del texto de respuesta de la función, separada por dos saltos de línea.

Python

# ✅ Append inline instructions to the end of the function response separated by two newlines
result_text = f"{json.dumps(result)}\n\n<your inline instructions>"

final_interaction = client.interactions.create(
    model="gemini-3.5-flash",
    previous_interaction_id=interaction.id,
    tools=[my_tool],
    input=[{
        "type": "function_result",
        "name": fc_step.name,
        "call_id": fc_step.id,
        "result": [{"type": "text", "text": result_text}],
    }],
)

JavaScript

// ✅ Append inline instructions to the end of the function response separated by two newlines
const resultText = `${JSON.stringify(result)}\n\n<your inline instructions>`;

const finalInteraction = await client.interactions.create({
  model: "gemini-3.5-flash",
  previousInteractionId: interaction.id,
  tools: [myTool],
  input: [{
    type: "function_result",
    name: fcStep.name,
    call_id: fcStep.id,
    result: [{ type: "text", text: resultText }],
  }],
});

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Function;
import com.google.genai.gaos.models.interactions.FunctionResultStep;
import com.google.genai.gaos.models.interactions.FunctionResultStepResultUnion;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.List;

Client client = new Client();

// Assumes interactionId, callId, functionName, myTool, and resultJson from previous step
String interactionId = "interaction-id-123";
String callId = "call-id-123";
String functionName = "get_weather";
Function myTool = Function.builder().name(functionName).build();
String resultJson = "{\"temperature\": \"72F\"}";

// ✅ Append inline instructions to the end of the function response separated by two newlines
String resultText = resultJson + "\n\n<your inline instructions>";

FunctionResultStep functionResult =
    FunctionResultStep.builder()
        .name(functionName)
        .callId(callId)
        .result(
            FunctionResultStepResultUnion.of(
                Arrays.asList(TextContent.builder().text(resultText).build())))
        .build();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.5-flash"))
        .previousInteractionId(interactionId)
        .tools(Arrays.asList(myTool))
        .input(InteractionsInput.ofStep(Arrays.asList(functionResult)))
        .build();

Interaction finalInteraction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

Go

package main

import (
    "context"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    // Assumes interactionID, callID, functionName, myTool, and resultJSON from previous step
    interactionID := "interaction-id-123"
    callID := "call-id-123"
    functionName := "get_weather"
    myTool := interactions.NewTool(interactions.Function{Name: genai.Ptr(functionName)})
    resultJSON := `{"temperature": "72F"}`

    // ✅ Append inline instructions to the end of the function response separated by two newlines
    resultText := resultJSON + "\n\n<your inline instructions>"

    functionResult := interactions.NewStep(interactions.FunctionResultStep{
        Name:   genai.Ptr(functionName),
        CallID: callID,
        Result: interactions.NewFunctionResultStepResultUnion([]interactions.FunctionResultSubcontent{
            interactions.NewFunctionResultSubcontent(interactions.TextContent{Text: resultText}),
        }),
    })

    finalRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model:                 interactions.Model("gemini-3.5-flash"),
            PreviousInteractionID: genai.Ptr(interactionID),
            Tools:                 []interactions.Tool{myTool},
            Input:                 interactions.NewInteractionsInput([]interactions.Step{functionResult}),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    _ = finalRes
}

Reducir las llamadas innecesarias a herramientas

Si experimentas un uso excesivo de las llamadas a herramientas, puedes usar dos técnicas para minimizarlo:

Comienza por reducir el nivel de pensamiento (medium, low o minimal): Los niveles de pensamiento más altos alientan al modelo a usar más herramientas para explorar y verificar, por lo que reducir el nivel puede disminuir las llamadas a herramientas.
Agrega una instrucción del sistema: Si el uso excesivo persiste después de ajustar el nivel de pensamiento, considera usar una instrucción que restrinja el uso de herramientas. Por ejemplo:
```
You have a limited action budget of <n> tool calls. Use them efficiently.
```

Funciones familiares de Gemini 3

Gemini 3.5 Flash hereda todas las capacidades de la familia de modelos de Gemini 3, incluido el uso en computadoras. Funciones introducidas en Gemini 3 que se mantienen:

Thinking: Contexto de razonamiento encriptado que se conserva en las llamadas a la API. Automático en la API de Interactions; implícito en GenerateContent.
Resultados estructurados con herramientas: Combina el modo JSON con herramientas integradas (búsqueda, contexto de URL, ejecución de código, llamadas a funciones).
Respuestas de funciones multimodales: Devolver imágenes, audio y otro contenido multimedia en los resultados de llamadas a funciones
Ejecución de código con imágenes: Ejecuta código que procesa y genera imágenes.
Uso combinado de herramientas: Usa herramientas integradas y llamadas a funciones personalizadas en la misma solicitud.
Resolución de medios: Control detallado sobre la asignación de tokens para las entradas de imágenes, videos y PDFs Los modelos de Gemini 3 admiten la configuración de resolución por elemento de contenido (low, medium, high, ultra_high) para instrucciones de fidelidad mixta.
Firmas de razonamiento: Son representaciones encriptadas del razonamiento interno del modelo. Se requiere para las llamadas a funciones de varios turnos en modo sin estado. La API de Interactions y los SDKs oficiales lo administran automáticamente.

Prácticas recomendadas para escribir instrucciones

Los modelos de Gemini 3.x son modelos de razonamiento, lo que cambia la forma en que debes darles instrucciones.

Instrucciones precisas: Sé breve. Gemini 3.x responde mejor a las instrucciones directas y claras. Las técnicas de ingeniería de instrucciones detalladas o complejas diseñadas para modelos anteriores pueden hacer que el modelo realice un análisis excesivo.
Detalle de la respuesta: De forma predeterminada, Gemini 3 y 3.1 son menos detallados y prefieren respuestas directas y eficientes. Si tu caso de uso requiere un tono conversacional, guía al modelo de forma explícita en tu instrucción (por ejemplo, "Explica esto como un asistente amigable y conversador").
Administración del contexto: Cuando trabajes con conjuntos de datos grandes (como libros completos, bases de código o videos largos), coloca tus instrucciones o preguntas específicas al final de la instrucción, después del contexto de los datos. Ancla el razonamiento del modelo comenzando tu pregunta con una frase como "Según la información anterior…".

Obtén más información sobre las estrategias de diseño de instrucciones en la guía de ingeniería de instrucciones.

Limitaciones

La segmentación de imágenes no se admite en Gemini 3.x. Para las cargas de trabajo de segmentación, sigue usando Gemini 2.5 Flash con el modo de pensamiento desactivado.

Preguntas frecuentes

¿Cuál es la fecha límite de conocimiento de Gemini 3.5 Flash? Gemini 3.5 Flash tiene una fecha límite de conocimiento de enero de 2025. Para obtener información más reciente, usa la herramienta Search Grounding.
¿Cuáles son los límites de la ventana de contexto? Gemini 3.5 Flash admite una ventana de contexto de entrada de 1 millón de tokens y hasta 65,000 tokens de salida.
¿Mi código thinking_budget anterior seguirá funcionando? Sí, thinking_budget sigue siendo compatible con versiones anteriores, pero recomendamos migrar a thinking_level para obtener un rendimiento más predecible. No uses ambos en la misma solicitud.
¿Gemini 3.5 Flash admite la API por lotes? Sí. Consulta la guía de la API de Batch para obtener más detalles.
¿Se admite el almacenamiento en caché de contexto? Sí, se admite el almacenamiento en caché de contexto.
¿Qué herramientas se admiten? Gemini 3.5 Flash admite la Búsqueda de Google, la fundamentación con Google Maps, la Búsqueda de archivos, la Ejecución de código, el Contexto de URL y la Llamada a funciones estándar, incluido el uso combinado de herramientas y el Uso de la computadora.

Otros modelos

¿Qué sigue?

Obtén más información sobre las estrategias de diseño de instrucciones en la guía de ingeniería de instrucciones.
Comienza a usar la guía de soluciones de Gemini 3
Obtén información sobre la optimización y la inferencia de la API de Gemini

Novedades de Gemini 3.5 Flash

Resumen del modelo

Guía de inicio rápido

Python

JavaScript

Java

Go

REST

Novedades

Cómo elegir el modelo de Flash adecuado

Cambios en el comportamiento

Nuevo nivel de esfuerzo predeterminado: medium

Python

JavaScript

Java

Go

REST

Preservación de pensamientos

Actualizaciones de parámetros y prácticas recomendadas en Gemini 3.x

Parámetros de muestreo (ya no se recomiendan)

thinking_budget (ya no se recomienda)

Llamada a función: Coincidencia estricta de respuestas

Python

JavaScript

Java

Go

REST

Respuestas de funciones multimodales

Python

JavaScript

Java

Go

Instrucciones intercaladas en las respuestas de funciones

Python

JavaScript

Java

Go

Reducir las llamadas innecesarias a herramientas

Funciones familiares de Gemini 3

Prácticas recomendadas para escribir instrucciones

Limitaciones

Preguntas frecuentes

Otros modelos

¿Qué sigue?

Nuevo nivel de esfuerzo predeterminado: `medium`

`thinking_budget` (ya no se recomienda)