Novità di Gemini 3.5 Flash

Ultimo modello Altri modelli

Gemini 3.5 Flash (gemini-3.5-flash) è un modello Flash di generazione precedente deprecato della serie Gemini 3. Le richieste a gemini-3.5-flash vengono automaticamente indirizzate a Gemini 3.6 Flash. Per il nostro modello Flash più recente, vedi Gemini 3.8 Flash.

Questa guida viene conservata come riferimento storico e documenta le modifiche all'API Gemini 3.x e i consigli sui parametri.

Panoramica modelli

Modello ID modello Stato
Gemini 3.5 Flash gemini-3.5-flash Obsoleta (instradamento automatico a gemini-3.6-flash).

Gemini 3.5 Flash supportava la finestra contestuale da 1 milione di token, 65.000 token di output massimi, la funzionalità di ragionamento e lo stesso insieme di strumenti e funzionalità della piattaforma di Gemini 3 Flash, inclusa la funzionalità Uso del computer (anteprima).

Per le specifiche complete, consulta la panoramica dei modelli.

Guida rapida

Tutti gli esempi in questa guida utilizzano l'API Interactions. È supportata anche l'API GenerateContent; si applicano le stesse opzioni di configurazione e gli stessi suggerimenti.

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

Novità

  • Prestazioni sostenute:ottimizzato per attività agentiche e di programmazione su larga scala.
  • Esecuzione agentica:deployment di subagenti, risoluzione dei problemi e cicli agentici rapidi su larga scala.
  • Programmazione:cicli di programmazione iterativi, esplorazione rapida e prototipazione per testare percorsi alternativi ed esplorare dinamicamente le soluzioni.
  • Orizzonte lungo: workflow in più passaggi e utilizzo degli strumenti su larga scala.
  • Conservazione del ragionamento:il modello mantiene automaticamente il ragionamento intermedio nelle conversazioni a più turni. Non sono necessarie modifiche all'API.
  • Nuovo livello di impegno predefinito: l'impegno di ragionamento predefinito è cambiato da high a medium. Per informazioni dettagliate, consulta Nuovo livello di impegno predefinito.
  • Miglioramento del ragionamento di low: low è stato migliorato in modo significativo per il codice e le attività con agenti che richiedono meno passaggi, offrendo una qualità elevata a latenza e costi inferiori.

Scegliere il modello Flash giusto

Poiché gemini-3.5-flash è ritirato e indirizzato automaticamente a gemini-3.6-flash, ti consigliamo di eseguire la migrazione a uno dei seguenti modelli attivi:

  • Gemini 3.8 Flash: il nostro modello Flash più recente e intelligente per la programmazione complessa e gli Agentic Workflows. Consulta la guida a Gemini 3.8 Flash.
  • Gemini 3.6 Flash: sostituisce direttamente gemini-3.5-flash con un utilizzo ridotto dei token e prezzi di output inferiori. Consulta la guida a Gemini 3.6 Flash e 3.5 Flash-Lite.
  • Gemini 3.5 Flash-Lite / Gemini 3.1 Flash-Lite: per attività a basso costo e ad alto volume che non richiedono la profondità di ragionamento completa di Flash, utilizza Gemini 3.5 Flash-Lite o Gemini 3.1 Flash-Lite.

Modifiche comportamentali

Nuovo livello di impegno predefinito: medium

Lo sforzo di pensiero predefinito ora è medium, modificato da high in Gemini 3 Flash Preview. medium produce risultati molto buoni in un'ampia gamma di attività ed è più veloce ed efficiente in termini di costi. Per problemi complessi, high incoraggia il modello a ragionare in modo più approfondito.

Livello di impegno Quando utilizzarle
minimal Ottimizzato per la velocità di risposta. Casi d'uso simili a chat, risposte rapide e fattuali, chiamate di strumenti più semplici.
low Attività di programmazione e agentiche che richiedono una latenza inferiore e meno passaggi. Funziona bene anche per le attività di analisi e scrittura che richiedono un po' di riflessione.
medium (predefinito) Migliore qualità per la maggior parte delle attività. Consigliato per codice complesso e casi d'uso agentici.
high Massimizza la capacità del modello di pensare e utilizzare gli strumenti. Ideale per ragionamenti complessi, matematica avanzata e le attività di codifica o degli agenti più difficili. Consente pensieri estesi e chiamate di funzioni.

Per ignorare il valore predefinito, imposta thinking_level nella configurazione:

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

La tabella seguente mostra i livelli di pensiero supportati per modello:

Livello di ragionamento Gemini 3.5 Flash Gemini 3.1 Pro Gemini 3.1 Flash-Lite Gemini 3 Flash Descrizione
minimal Supportato Non supportato Supportato (valore predefinito) Supportato Corrisponde all'impostazione "nessun pensiero" per la maggior parte delle query. Tieni presente che minimal non garantisce che il pensiero sia disattivato. Il modello potrebbe ragionare in modo molto minimale per attività complesse.
low Supportato Supportato Supportato Supportato Riduce al minimo la latenza e i costi.
medium Supportato (valore predefinito) Supportato Supportato Supportato Pensiero equilibrato per la maggior parte delle attività.
high Supportato (dinamico) Supportato (valore predefinito, dinamico) Supportato (dinamico) Supportato (valore predefinito, dinamico) Massimizza la profondità del ragionamento.

Conservazione del ragionamento

Il modello mantiene automaticamente il ragionamento intermedio nelle conversazioni multi-turno. Se presente nella cronologia della conversazione, il contesto del ragionamento viene riportato avanti, il che migliora le prestazioni in attività complesse in più passaggi come il debug iterativo e il refactoring del codice. Nessuna modifica API necessaria:

  • API Interactions: i pensieri vengono già conservati automaticamente. Nessun cambiamento nel comportamento.
  • API GenerateContent: a partire da Gemini 3.5 Flash, il modello utilizza il contesto di ragionamento di tutti i turni precedenti quando le firme del pensiero sono presenti nella cronologia delle conversazioni. Per abilitare questa opzione, trasmetti la cronologia completa e non modificata della conversazione (incluse le firme del pensiero) in contents. Gli SDK gestiscono automaticamente questa operazione.

Aggiornamenti dei parametri e best practice in Gemini 3.x

Quanto segue si applica a tutti i modelli Gemini 3.x, incluso Gemini 3.5 Flash.

  • temperature, top_p, top_k: ti consigliamo vivamente di non modificare i valori predefiniti. Le funzionalità di ragionamento di Gemini 3 sono ottimizzate per le impostazioni predefinite.
  • Utilizza thinking_level anziché thinking_budget.
  • Corrispondenza della risposta alla chiamata di funzione: id, name e il conteggio delle risposte devono corrispondere alle chiamate precedenti.
  • Risposte di funzioni multimodali: includi contenuti multimodali all'interno della risposta di funzione, non all'esterno.
  • Istruzioni inline nelle risposte delle funzioni: aggiungile al testo di risposta della funzione, non come parti separate.
  • Ridurre le chiamate agli strumenti non necessarie: utilizza livelli di pensiero inferiori o sperimenta con le istruzioni di sistema per ridurre le chiamate agli strumenti nei workflow agentici.

Consulta le sezioni seguenti per scoprire come aggiornare il codice.

Parametri di campionamento (non più consigliati)

temperature, top_p e top_k non sono più consigliati per tutti i modelli Gemini 3.x. Le funzionalità di ragionamento di Gemini 3 sono ottimizzate per le impostazioni predefinite. Rimuovi questi parametri da tutte le richieste.

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

Per garantire il determinismo, ti consigliamo di definire un'istruzione di sistema con regole esplicite per il tuo caso d'uso specifico.

thinking_budget (non più consigliato)

Il parametro numerico non elaborato thinking_budget non è più consigliato per tutti i modelli Gemini 3.x. Utilizza invece l'enumerazione di stringhe thinking_level.

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

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

Valori disponibili: minimal, low, medium (predefinito) e high.

Chiamata di funzione: corrispondenza esatta della risposta

L'API Interactions genera già errori in caso di risposte di funzioni non corrispondenti. L'API GenerateContent non genera ancora errori, ma le risposte non corrispondenti fanno sì che il modello restituisca risposte vuote con finish_reason: STOP nella maggior parte dei casi. Segui sempre queste convenzioni:

Requisito Dettagli
Includi id Ogni FunctionResponse deve includere id dal FunctionCall corrispondente
Incontro name Il valore name nella risposta deve corrispondere al valore name nella chiamata
Conteggi delle corrispondenze Restituisci esattamente un FunctionResponse per ogni FunctionCall ricevuto

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

Risposte di funzioni multimodali

Spesso vediamo clienti fornire immagini al di fuori della risposta della funzione. Ciò può portare a un comportamento imprevisto del modello (ad es. perdita di pensieri) e a risultati di qualità inferiore. Segui invece il consiglio riportato nella documentazione dell'API Multimodal Function Responses e includi contenuti multimodali nelle parti della risposta della funzione che invii al modello. Il modello può elaborare questi contenuti multimodali nel turno successivo per produrre una risposta più informata.

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
}

Istruzioni incorporate nelle risposte delle funzioni

Spesso vediamo i clienti fornire istruzioni aggiuntive insieme alle risposte delle funzioni come Parts successivi. Ciò può portare a un comportamento imprevisto del modello (ad es. perdita di pensieri) e a risultati di qualità inferiore. Aggiungi invece eventuali istruzioni extra alla fine del testo di risposta della funzione, separate da due nuove righe.

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
}

Riduzione delle chiamate allo strumento non necessarie

Se riscontri un utilizzo eccessivo delle chiamate di strumenti, due tecniche aiutano a ridurle al minimo:

  1. Inizia riducendo il livello di pensiero (medium, low o minimal): i livelli di pensiero più elevati incoraggiano il modello a utilizzare più strumenti per esplorare e verificare, quindi abbassare il livello può ridurre le chiamate agli strumenti.

  2. Aggiungi un'istruzione di sistema:se l'uso eccessivo persiste dopo aver modificato il livello di pensiero, valuta la possibilità di utilizzare un prompt che limiti l'utilizzo dello strumento. Ad esempio:

    You have a limited action budget of <n> tool calls. Use them efficiently.

Funzionalità della famiglia Gemini 3

Gemini 3.5 Flash eredita tutte le funzionalità della famiglia Gemini 3, incluso l'utilizzo del computer. Funzionalità introdotte in Gemini 3 che vengono mantenute:

  • Pensiero: contesto di ragionamento criptato preservato tra le chiamate API. Automatico nell'API Interactions; implicito in GenerateContent.
  • Output strutturati con strumenti: combina la modalità JSON con strumenti integrati (Ricerca, contesto URL, esecuzione di codice, chiamata di funzioni).
  • Risposte di funzioni multimodali: restituisci immagini, audio e altri contenuti multimediali nei risultati della chiamata di funzione.
  • Esecuzione di codice con immagini: esegui codice che elabora e genera immagini.
  • Utilizzo combinato degli strumenti: utilizza gli strumenti integrati e le chiamate di funzione personalizzate nella stessa richiesta.
  • Risoluzione dei contenuti multimediali: Controllo granulare dell'allocazione dei token per gli input di immagini, video e PDF. I modelli Gemini 3 supportano le impostazioni di risoluzione per elemento di contenuti (low, medium, high, ultra_high) per i prompt a fedeltà mista.
  • Firme del pensiero: Rappresentazioni criptate del ragionamento interno del modello. Obbligatorio per la chiamata di funzione multi-turno in modalità stateless; gestito automaticamente dall'API Interactions e dagli SDK ufficiali.

Best practice per i prompt

I modelli Gemini 3.x sono modelli di ragionamento, il che cambia il modo in cui devi creare i prompt.

  • Istruzioni precise:sii conciso. Gemini 3.x risponde al meglio a istruzioni dirette e chiare. Tecniche di ingegneria dei prompt complesse o dettagliate progettate per modelli precedenti potrebbero causare un'analisi eccessiva del modello.
  • Livello di dettaglio dell'output: per impostazione predefinita, Gemini 3 e 3.1 sono meno dettagliati e preferiscono risposte dirette ed efficienti. Se il tuo caso d'uso richiede un tono colloquiale, guida il modello in modo esplicito nel prompt (ad esempio, "Spiega questo come se fossi un assistente amichevole e loquace").
  • Gestione del contesto: quando lavori con set di dati di grandi dimensioni (come libri, codebase o video lunghi), inserisci le istruzioni o le domande specifiche alla fine del prompt, dopo il contesto dei dati. Ancora il ragionamento del modello iniziando la domanda con una frase come "In base alle informazioni precedenti…".

Scopri di più sulle strategie di progettazione dei prompt nella guida all'ingegneria dei prompt.

Limitazioni

  • La segmentazione delle immagini non è supportata in Gemini 3.x. Per i carichi di lavoro di segmentazione, continua a utilizzare Gemini 2.5 Flash con la funzionalità di ragionamento disattivata.

Domande frequenti

  1. Qual è il knowledge cutoff per Gemini 3.5 Flash? Gemini 3.5 Flash ha un limite di conoscenza di gennaio 2025. Per informazioni più recenti, utilizza lo strumento Ricerca basata su dati reali.

  2. Quali sono i limiti della finestra contestuale? Gemini 3.5 Flash supporta una finestra contestuale di input da 1 milione di token e fino a 65.000 token di output.

  3. Il mio vecchio codice thinking_budget continuerà a funzionare? Sì, thinking_budget è ancora supportato per la compatibilità con le versioni precedenti, ma ti consigliamo di eseguire la migrazione a thinking_level per un rendimento più prevedibile. Non utilizzarli entrambi nella stessa richiesta.

  4. Gemini 3.5 Flash supporta l'API Batch? Sì. Per informazioni dettagliate, consulta la guida all'API Batch.

  5. La memorizzazione nella cache del contesto è supportata? Sì, la memorizzazione nella cache del contesto è supportata.

  6. Quali strumenti sono supportati? Gemini 3.5 Flash supporta la Ricerca Google, Grounding con Google Maps, la ricerca di file, l'esecuzione di codice, il contesto URL e l'invocazione di funzioni standard, inclusi l'utilizzo combinato degli strumenti e l'utilizzo del computer.

Altri modelli

Passaggi successivi