O Gemini 3.8 Flash já está disponível. Faça um teste.

O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Novidades do Gemini 3.5 Flash

Modelo mais recente Outros modelos

O Gemini 3.5 Flash (gemini-3.5-flash) é um modelo Flash descontinuado de geração anterior na série Gemini 3. As solicitações para gemini-3.5-flash são encaminhadas automaticamente para o Gemini 3.6 Flash. Para nosso modelo Flash mais recente, consulte o Gemini 3.8 Flash.

Este guia é preservado para referência histórica e documenta as mudanças básicas da API Gemini 3.x e as recomendações de parâmetros.

Visão geral do modelo

Modelo	ID do modelo	Status
Gemini 3.5 Flash	`gemini-3.5-flash`	Descontinuado (encaminhado automaticamente para `gemini-3.6-flash`).

O Gemini 3.5 Flash oferece suporte à janela de contexto de 1 milhão de tokens, 65 mil tokens de saída máximos, raciocínio e o mesmo conjunto de ferramentas e recursos de plataforma do Gemini 3 Flash, incluindo Uso do computador (pré-lançamento).

Para especificações completas, consulte a visão geral dos modelos.

Guia de início rápido

Todos os exemplos neste guia usam a API Interactions. A API GenerateContent também é compatível. As mesmas opções de configuração e recomendações se aplicam.

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."
  }'

O que há de novo

Desempenho sustentado:otimizado para tarefas agênticas e de programação em escala.
Execução com agentes:implantação de subagentes, solução de problemas e loops do agente rápidos em escala.
Programação:ciclos de programação iterativos, exploração rápida e prototipagem para testar caminhos alternativos e explorar soluções de forma dinâmica.
Longo prazo:fluxos de trabalho de várias etapas e uso de ferramentas em escala.
Preservação de raciocínio:o modelo mantém o raciocínio intermediário em conversas multiturnos automaticamente. Nenhuma mudança de API necessária.
Novo nível de esforço padrão:o nível de raciocínio padrão mudou de high para medium. Consulte Novo nível de esforço padrão para mais detalhes.
Raciocínio low aprimorado: low foi significativamente aprimorado para tarefas de código e agênticas que exigem menos etapas, oferecendo alta qualidade com menor latência e custo.

Como escolher o modelo Flash certo

Como o gemini-3.5-flash foi descontinuado e encaminhado automaticamente para gemini-3.6-flash, recomendamos migrar para um dos seguintes modelos ativos:

Gemini 3.8 Flash: nosso modelo Flash mais recente e inteligente para programação complexa e Agentic Workflows. Consulte o guia do Gemini 3.8 Flash.
Gemini 3.6 Flash: substituição direta para gemini-3.5-flash com uso reduzido de tokens e preços de saída mais baixos. Consulte o guia do Gemini 3.6 Flash e do 3.5 Flash-Lite.
Gemini 3.5 Flash-Lite / Gemini 3.1 Flash-Lite: para tarefas de baixo custo e alto volume que não exigem profundidade total de raciocínio do Flash, use o Gemini 3.5 Flash-Lite ou o Gemini 3.1 Flash-Lite.

Mudanças no comportamento

Novo nível de esforço padrão: `medium`

O nível de raciocínio padrão agora é medium, alterado de high na versão de pré-lançamento do Gemini 3 Flash. medium produz resultados muito bons em uma ampla variedade de tarefas, além de ser mais rápido e econômico. Para problemas complexos, high incentiva o modelo a pensar mais profundamente.

Nível de esforço	Quando usar
`minimal`	Otimizado para velocidade de resposta. Casos de uso semelhantes a chats, respostas factuais rápidas, chamadas de ferramentas mais simples.
`low`	Tarefas de código e agênticas que exigem menor latência e menos etapas. Também funciona bem para tarefas de análise e escrita que exigem algum raciocínio.
`medium` (padrão)	Melhor qualidade para a maioria das tarefas. Recomendado para casos de uso agênticos e de código complexo.
`high`	Maximiza a capacidade do modelo de pensar e usar ferramentas. Ideal para raciocínio complexo, matemática difícil e tarefas de código ou agente mais difíceis. Permite pensamentos e chamadas de função estendidos.

Para substituir o padrão, defina thinking_level na configuração:

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"}
  }'

A tabela a seguir mostra quais níveis de raciocínio são compatíveis por modelo:

Nível de raciocínio	Gemini 3.5 Flash	Gemini 3.1 Pro	Gemini 3.1 Flash-Lite	Gemini 3 Flash	Descrição
`minimal`	Compatível	Incompatível	Compatível (padrão)	Compatível	Corresponde à configuração "sem raciocínio" para a maioria das consultas. Observação: `minimal` não garante que o raciocínio esteja desativado. O modelo pode raciocinar de forma muito mínima para tarefas complexas.
`low`	Compatível	Compatível	Compatível	Compatível	Minimiza a latência e o custo.
`medium`	Compatível (padrão)	Compatível	Compatível	Compatível	Raciocínio equilibrado para a maioria das tarefas.
`high`	Compatível (dinâmico)	Compatível (padrão, dinâmico)	Compatível (dinâmico)	Compatível (padrão, dinâmico)	Maximiza a profundidade do raciocínio.

Preservação de raciocínio

O modelo mantém o raciocínio intermediário em conversas multiturnos automaticamente. Quando presente no histórico de conversas, o contexto de raciocínio é transferido, o que melhora o desempenho em tarefas complexas de várias etapas, como depuração iterativa e refatoração de código. Nenhuma mudança de API necessária:

API Interactions: os pensamentos já são preservados automaticamente. Nenhuma mudança no comportamento.
API GenerateContent: começando com o Gemini 3.5 Flash, o modelo usa o contexto de raciocínio de todos os turnos anteriores quando as assinaturas de pensamento estão presentes no histórico de conversas. Para ativar isso, transmita o histórico de conversas completo, não modificado (incluindo assinaturas de pensamento) em contents. Os SDKs processam isso automaticamente.

Atualizações de parâmetros e práticas recomendadas no Gemini 3.x

O seguinte se aplica a todos os modelos do Gemini 3.x, incluindo o Gemini 3.5 Flash.

temperature, top_p, top_k: recomendamos não mudar os valores padrão. Os recursos de raciocínio do Gemini 3 são otimizados para as configurações padrão.
Use thinking_level em vez de thinking_budget.
Correspondência de resposta de chamada de função: id, name e a contagem de respostas precisam corresponder às chamadas anteriores.
Respostas de funções multimodais: inclua conteúdo multimodal dentro da resposta da função, não fora dela.
Instruções inline em respostas de função: anexe ao texto de resposta da função, não como partes separadas.
Reduza chamadas de ferramentas desnecessárias: use níveis de raciocínio mais baixos ou faça testes com instruções do sistema para reduzir chamadas de ferramentas em Agentic Workflows.

Consulte as seções abaixo para saber como atualizar seu código.

Parâmetros de amostragem (não recomendados)

temperature, top_p e top_k não são mais recomendados para todos os modelos do Gemini 3.x. Os recursos de raciocínio do Gemini 3 são otimizados para as configurações padrão. Remova esses parâmetros de todas as solicitações.

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

Para garantir o determinismo, recomendamos definir uma instrução do sistema com regras explícitas para seu caso de uso específico.

`thinking_budget` (não recomendado)

O parâmetro numérico bruto thinking_budget não é mais recomendado em todos os modelos do Gemini 3.x. Use o tipo enumerado de string thinking_level.

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

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

Valores disponíveis: minimal, low, medium (padrão) e high.

Chamada de função: correspondência de resposta estrita

A API Interactions já gera erros em respostas de função incompatíveis. A API GenerateContent ainda não gera erros, mas respostas incompatíveis fazem com que o modelo retorne respostas vazias com finish_reason: STOP na maioria dos casos. Siga sempre estas convenções:

Requisito	Detalhes
Incluir `id`	Cada `FunctionResponse` precisa incluir o `id` do `FunctionCall` correspondente.
Correspondência de `name`	O `name` na resposta precisa corresponder ao `name` na chamada.
Contagens de correspondência	Retorne exatamente um `FunctionResponse` para cada `FunctionCall` recebido.

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": "..."}]
    }]
  }'

Respostas de funções multimodais

Muitas vezes, os clientes fornecem imagens fora da resposta da função. Isso pode levar a um comportamento inesperado do modelo (por exemplo, vazamento de pensamento) e resultar em saídas de qualidade inferior. Siga a recomendação na documentação da API de respostas de funções multimodais em vez disso e inclua conteúdo multimodal nas partes de resposta da função que você envia ao modelo. O modelo pode processar esse conteúdo multimodal no próximo turno para produzir uma resposta mais informada.

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
}

Instruções inline em respostas de função

Muitas vezes, os clientes fornecem instruções adicionais junto com as respostas de função como Parts subsequentes. Isso pode levar a um comportamento inesperado do modelo (por exemplo, vazamento de pensamento) e resultar em saídas de qualidade inferior. Em vez disso, anexe instruções extras ao final do texto de resposta da função, separadas por duas novas linhas.

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
}

Como reduzir chamadas de ferramentas desnecessárias

Se você tiver um uso excessivo de chamadas de ferramentas, duas técnicas ajudarão a minimizá-las:

Comece reduzindo o nível de raciocínio (medium, low ou minimal): níveis de raciocínio mais altos incentivam o modelo a usar mais ferramentas para explorar e verificar. Portanto, diminuir o nível pode reduzir as chamadas de ferramentas.
Adicione uma instrução do sistema:se o uso excessivo persistir após ajustar o nível de raciocínio, considere um comando que restrinja o uso de ferramentas. Exemplo:
```
You have a limited action budget of <n> tool calls. Use them efficiently.
```

Recursos da família Gemini 3

O Gemini 3.5 Flash herda todos os recursos da família Gemini 3, incluindo o uso do computador. Recursos introduzidos no Gemini 3 que são transferidos:

Raciocínio: Contexto de raciocínio criptografado preservado em chamadas de API. Automático na API Interactions; implícito no GenerateContent.
Saídas estruturadas com ferramentas: combine o modo JSON com ferramentas integradas (pesquisa, contexto de URL, execução de código, chamada de função).
Respostas de funções multimodais: retorne imagens, áudio e outras mídias nos resultados da chamada de função.
Execução de código com imagens: execute códigos que processam e geram imagens.
Uso combinado de ferramentas: use ferramentas integradas e chamadas de função personalizadas na mesma solicitação.
Resolução de mídia: controle refinado da alocação de tokens para entradas de imagem, vídeo e PDF. Os modelos do Gemini 3 oferecem suporte a configurações de resolução por item de conteúdo (low, medium, high, ultra_high) para comandos de fidelidade mista.
Assinaturas de pensamento: representações criptografadas do raciocínio interno do modelo. Necessário para chamadas de função multiturnos no modo sem estado; gerenciado automaticamente pela API Interactions e pelos SDKs oficiais.

Práticas recomendadas para comandos

Os modelos do Gemini 3.x são modelos de raciocínio, o que muda a forma como você deve solicitar.

Instruções precisas:use um texto conciso. O Gemini 3.x responde melhor a instruções diretas e claras. Técnicas de engenharia de comandos detalhadas ou complexas projetadas para modelos mais antigos podem fazer com que o modelo analise demais.
Nível de detalhe da saída:por padrão, o Gemini 3 e o 3.1 são menos detalhados e preferem respostas diretas e eficientes. Se o caso de uso exigir um tom conversacional, direcione o modelo explicitamente no comando (por exemplo, "Explique isso como um assistente amigável e falante").
Gerenciamento de contexto:ao trabalhar com grandes conjuntos de dados (como livros inteiros, bases de código ou vídeos longos), coloque suas instruções ou perguntas específicas no final do comando, após o contexto de dados. Ancore o raciocínio do modelo começando sua pergunta com uma frase como "Com base nas informações anteriores...".

Saiba mais sobre estratégias de design de comandos no guia de engenharia de comandos.

Limitações

A segmentação de imagens não é compatível com o Gemini 3.x. Para cargas de trabalho de segmentação, continue usando o Gemini 2.5 Flash com o raciocínio desativado.

Perguntas frequentes

Qual é o limite de conhecimento do Gemini 3.5 Flash? O Gemini 3.5 Flash tem um limite de conhecimento de janeiro de 2025. Para informações mais recentes, use a ferramenta de ancoragem de pesquisa.
Quais são os limites da janela de contexto? O Gemini 3.5 Flash oferece suporte a uma janela de contexto de entrada de 1 milhão de tokens e até 65 mil tokens de saída.
Meu código thinking_budget antigo ainda vai funcionar? Sim, thinking_budget ainda é compatível com versões anteriores, mas recomendamos migrar para thinking_level para um desempenho mais previsível. Não use os dois na mesma solicitação.
O Gemini 3.5 Flash oferece suporte à API Batch? Sim. Consulte o guia da API Batch para mais detalhes.
O armazenamento em cache de contexto é compatível? Sim, o armazenamento em cache de contexto é compatível.
Quais ferramentas são compatíveis? O Gemini 3.5 Flash oferece suporte a Pesquisa Google, embasamento com o Google Maps, pesquisa de arquivos, execução de código, contexto de URL, e chamada de função padrão, incluindo uso combinado de ferramentas, e uso do computador.

Outros modelos

A seguir

Saiba mais sobre estratégias de design de comandos no guia de engenharia de comandos.
Comece a usar o Cookbook do Gemini 3
Aprenda mais sobre a otimização e a inferência da API Gemini

Novidades do Gemini 3.5 Flash

Visão geral do modelo

Guia de início rápido

Python

JavaScript

Java

Go

REST

O que há de novo

Como escolher o modelo Flash certo

Mudanças no comportamento

Novo nível de esforço padrão: medium

Python

JavaScript

Java

Go

REST

Preservação de raciocínio

Atualizações de parâmetros e práticas recomendadas no Gemini 3.x

Parâmetros de amostragem (não recomendados)

thinking_budget (não recomendado)

Chamada de função: correspondência de resposta estrita

Python

JavaScript

Java

Go

REST

Respostas de funções multimodais

Python

JavaScript

Java

Go

Instruções inline em respostas de função

Python

JavaScript

Java

Go

Como reduzir chamadas de ferramentas desnecessárias

Recursos da família Gemini 3

Práticas recomendadas para comandos

Limitações

Perguntas frequentes

Outros modelos

A seguir

Novo nível de esforço padrão: `medium`

`thinking_budget` (não recomendado)