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 de geração anterior descontinuado da série Gemini 3. As solicitações para gemini-3.5-flash são encaminhadas automaticamente para o Gemini 3.6 Flash. Para conhecer nosso modelo Flash mais recente, consulte Gemini 3.8 Flash.

Este guia é preservado para referência histórica e documenta as mudanças básicas na 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 (roteado automaticamente para `gemini-3.6-flash`).

O Gemini 3.5 Flash oferecia suporte à janela de contexto de 1 milhão de tokens, 65 mil tokens de saída máxima, raciocínio e o mesmo conjunto de ferramentas e recursos da plataforma do Gemini 3 Flash, incluindo o 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 consistente:otimizado para tarefas agênticas e de programação em grande escala.
Execução agêntica:implantação de subagentes, resolução de problemas e loops agênticos rápidos em grande 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 grande escala.
Preservação de raciocínio:o modelo mantém o raciocínio intermediário em conversas multiturno automaticamente. Não é necessário fazer mudanças na API.
Novo nível de raciocínio 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.
Melhoria no raciocínio do low:o low foi significativamente aprimorado para código e tarefas de agente que exigem menos etapas, oferecendo alta qualidade com menor latência e custo.

Como escolher o modelo certo do Flash

Como o gemini-3.5-flash foi descontinuado e é encaminhado automaticamente para o 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 do 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 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 de comportamento

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

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

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

Para substituir o padrão, defina thinking_level na sua 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 pensamento são compatíveis com cada 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 pensar" para a maioria das consultas. Observação: o `minimal` não garante que o pensamento 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	Pensamento 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 de várias rodadas automaticamente. Quando presente no histórico de conversas, o contexto de raciocínio é mantido, 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 na API é necessária:

API Interactions: as ideias já são preservadas automaticamente. Nenhuma mudança no comportamento.
API GenerateContent: a partir do Gemini 3.5 Flash, o modelo usa o contexto de raciocínio de todas as interações anteriores quando as assinaturas de pensamento estão presentes no histórico de conversas. Para ativar isso, transmita o histórico de conversas completo e sem modificações (incluindo assinaturas de pensamento) em contents. Os SDKs fazem isso automaticamente.

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

As informações a seguir se aplicam 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. As capacidades de raciocínio do Gemini 3 são otimizadas para as configurações padrão.
Use thinking_level em vez de thinking_budget
Correspondência de respostas de chamadas 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: anexar ao texto de resposta da função, não como partes separadas.
Reduza as chamadas de ferramentas desnecessárias: use níveis de pensamento mais baixos ou teste instruções do sistema para reduzir as chamadas de ferramentas em fluxos de trabalho agênticos.

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

Parâmetros de amostragem (não são mais recomendados)

temperature, top_p e top_k não são mais recomendados para todos os modelos do Gemini 3.x. As capacidades de raciocínio do Gemini 3 são otimizadas 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. Em vez disso, use o enum 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 restrita de respostas

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.
`name`ª partida	O `name` na resposta precisa corresponder ao `name` na chamada.
Contagens de correspondências	Retornar 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 Multimodal Function Responses 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 na próxima vez para produzir uma resposta mais completa.

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 nas respostas de função

Muitas vezes, os clientes fornecem instruções adicionais com respostas de funções 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, adicione as 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
}

Reduzir chamadas de ferramentas desnecessárias

Se você notar um uso excessivo de chamadas de função, duas técnicas podem ajudar a minimizar isso:

Comece reduzindo o nível de pensamento (medium, low ou minimal): níveis mais altos incentivam o modelo a usar mais ferramentas para explorar e verificar, então diminuir o nível pode reduzir as chamadas de ferramentas.
Adicione uma instrução do sistema:se o uso excessivo persistir depois de ajustar o nível de raciocínio, considere um comando que restrinja o uso da ferramenta. 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 continuam disponíveis:

Pensando:contexto de raciocínio criptografado preservado em todas as chamadas de API. Automático na API Interactions; implícito em GenerateContent.
Saídas estruturadas com ferramentas:combine o modo JSON com ferramentas integradas (pesquisa, contexto de URL, execução de código, chamadas de função).
Respostas de função multimodal:retornam 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 chamada de função personalizada na mesma solicitação.
Resolução de mídia:controle refinado sobre a 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 chamada de função multiturno 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 de raciocínio, o que muda a forma de dar comandos.

Instruções precisas:seja conciso. O Gemini 3.x responde melhor a instruções diretas e claras. Técnicas de engenharia de comando 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 de conversa, oriente o modelo explicitamente no comando (por exemplo, "Explique isso como um assistente amigável e comunicativo").
Gerenciamento de contexto:ao trabalhar com conjuntos de dados grandes (como livros inteiros, bases de código ou vídeos longos), coloque suas instruções ou perguntas específicas no final do comando, depois do contexto dos dados. Para ancorar o raciocínio do modelo, comece 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 modo de pensamento 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 Embasamento da 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, o thinking_budget ainda é compatível com versões anteriores, mas recomendamos migrar para o thinking_level para ter um desempenho mais previsível. Não use os dois na mesma solicitação.
O Gemini 3.5 Flash é compatível com a 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 é compatível com 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
Saiba mais sobre otimização e 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 certo do Flash

Mudanças de 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 são mais recomendados)

thinking_budget (não recomendado)

Chamada de função: correspondência restrita de respostas

Python

JavaScript

Java

Go

REST

Respostas de funções multimodais

Python

JavaScript

Java

Go

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

Python

JavaScript

Java

Go

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)