Novità di Gemini 3.5 Flash

Modello più recente 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, consulta Gemini 3.8 Flash.

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

Panoramica modelli

Modello ID modello Stato
Gemini 3.5 Flash gemini-3.5-flash Deprecato (indirizzato automaticamente a gemini-3.6-flash).

Gemini 3.5 Flash supportava la finestra contestuale da 1 milione di token, un massimo di 65.000 token di output, il ragionamento e lo stesso set di strumenti e funzionalità della piattaforma di Gemini 3 Flash, incluso l'utilizzo 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 consigli.

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(""));

Vai

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: ottimizzate per attività agentiche e di programmazione su larga scala.
  • Esecuzione agentica: deployment di sub-agenti, risoluzione dei problemi e loop 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 in più turni. Non sono necessarie modifiche all'API.
  • Nuovo livello di sforzo predefinito: l'impegno di ragionamento predefinito è cambiato da high a medium. Per maggiori dettagli, consulta Nuovo livello di sforzo predefinito.
  • Ragionamento low migliorato: low è stato notevolmente migliorato per le attività di codice e agentiche che richiedono meno passaggi, offrendo una qualità elevata a costi e latenza inferiori.

Scegliere il modello Flash giusto

Poiché gemini-3.5-flash è deprecato e viene 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 workflow di programmazione e Agentic Workflows complessi. Consulta la guida di Gemini 3.8 Flash.
  • Gemini 3.6 Flash: sostituzione diretta di gemini-3.5-flash con un utilizzo di token ridotto e prezzi di output inferiori. Consulta la guida di 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 al comportamento

Nuovo livello di sforzo predefinito: medium

Lo sforzo di ragionamento predefinito è ora medium, modificato da high nell'anteprima di Gemini 3 Flash. medium produce risultati molto buoni in un'ampia gamma di attività, pur essendo più veloce ed economico. Per i problemi complessi, high incoraggia il modello a ragionare in modo più approfondito.

Livello di sforzo Quando utilizzarlo
minimal Ottimizzato per la velocità di risposta. Casi d'uso simili a chat, risposte fattuali rapide, chiamate di strumenti più semplici.
low Attività di codice 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 ragionamento.
medium (valore predefinito) Qualità ottimale per la maggior parte delle attività. Consigliato per casi d'uso di codice e agentici complessi.
high Massimizza la capacità del modello di ragionare e utilizzare gli strumenti. Ideale per ragionamenti complessi, matematica difficile e le attività di codice o agenti più difficili. Consente ragionamenti estesi e chiamate di funzioni.

Per sostituire 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(""));

Vai

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 ragionamento 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 ragionamento" per la maggior parte delle query. Nota: minimal non garantisce che il ragionamento sia disattivato, il modello potrebbe ragionare in modo molto minimo per le attività complesse.
low Supportato Supportato Supportato Supportato Riduce al minimo la latenza e i costi.
medium Supportato (valore predefinito) Supportato Supportato Supportato Ragionamento bilanciato 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 in più turni. Quando è presente nella cronologia delle conversazioni, il contesto di ragionamento viene riportato, il che migliora le prestazioni nelle attività complesse in più passaggi, come il debug iterativo e il refactoring del codice. Non sono necessarie modifiche all'API:

  • API Interazioni: i ragionamenti vengono già conservati automaticamente. Nessuna modifica al 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 di ragionamento sono presenti nella cronologia delle conversazioni. Per attivare questa funzionalità, trasmetti la cronologia delle conversazioni completa e non modificata (incluse le firme di ragionamento) in contents. Gli SDK gestiscono questa operazione automaticamente.

Aggiornamenti dei parametri e best practice in Gemini 3.x

Le seguenti indicazioni si applicano 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 delle risposte di chiamata di funzione: id, name e il conteggio delle risposte devono corrispondere alle chiamate precedenti.
  • Risposte di funzioni multimodali: includi i contenuti multimodali all'interno della risposta della funzione, non all'esterno.
  • Istruzioni in linea nelle risposte delle funzioni: aggiungile al testo della risposta della funzione, non come parti separate.
  • Riduci le chiamate di strumenti non necessarie: utilizza livelli di ragionamento inferiori o sperimenta le istruzioni di sistema per ridurre le chiamate di strumenti negli Agentic Workflows.

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 (valore predefinito) e high.

Chiamata di funzione: corrispondenza rigorosa delle risposte

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

Requisito Dettagli
Includi id Ogni FunctionResponse deve includere l'id della FunctionCall corrispondente
Corrispondenza di name name nella risposta deve corrispondere a name nella chiamata
Corrispondenza dei conteggi Restituisci esattamente una FunctionResponse per ogni FunctionCall ricevuta

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();

Vai

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 i clienti forniscono immagini al di fuori della risposta della funzione. Ciò può portare a un comportamento imprevisto del modello (ad es. perdita di ragionamento) e a output di qualità inferiore. Segui invece il consiglio riportato nella documentazione dell'API Risposte di funzioni multimodali e includi i 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();

Vai

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 in linea nelle risposte delle funzioni

Spesso i clienti forniscono istruzioni aggiuntive insieme alle risposte delle funzioni come Parts successive. Ciò può portare a un comportamento imprevisto del modello (ad es. perdita di ragionamento) e a output di qualità inferiore. Aggiungi invece eventuali istruzioni aggiuntive alla fine del testo della 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();

Vai

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
}

Ridurre le chiamate di strumenti non necessarie

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

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

  2. Aggiungi un'istruzione di sistema: se l'utilizzo eccessivo persiste dopo aver regolato il livello di ragionamento, valuta la possibilità di utilizzare un prompt che limiti l'utilizzo degli strumenti. 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 riportate:

  • Ragionamento: contesto di ragionamento criptato conservato nelle chiamate API. Automatico nell'API Interactions; implicito in GenerateContent.
  • Output strutturati con gli strumenti: combina la modalità JSON con gli strumenti integrati (Ricerca, Contesto URL, esecuzione di codice, chiamata di funzione).
  • Risposte di funzioni multimodali: restituisci immagini, audio e altri contenuti multimediali nei risultati delle chiamate di funzioni.
  • Esecuzione del codice con le immagini: esegui il codice che elabora e genera immagini.
  • Utilizzo combinato degli strumenti: utilizza gli strumenti integrati e la chiamata di funzione personalizzata 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 contenuto (low, medium, high, ultra_high) per i prompt a fedeltà mista.
  • Firme di ragionamento: 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 la creazione di prompt

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

  • Istruzioni precise: crea prompt concisi. Gemini 3.x risponde al meglio a istruzioni dirette e chiare. Le tecniche di progettazione di prompt dettagliate o complesse progettate per i modelli precedenti potrebbero causare un'analisi eccessiva del modello.
  • Dettagli 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, indirizza esplicitamente il modello nel prompt (ad esempio, "Spiega questo come un assistente amichevole e loquace").
  • Gestione del contesto: quando lavori con set di dati di grandi dimensioni (ad esempio libri interi, 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 del prompt.

Limitazioni

  • La segmentazione delle immagini non è supportata in Gemini 3.x. Per i workload di segmentazione, continua a utilizzare Gemini 2.5 Flash con il ragionamento disattivato.

Domande frequenti

  1. Qual è il knowledge cutoff per Gemini 3.5 Flash? Gemini 3.5 Flash ha un knowledge cutoff di gennaio 2025. Per informazioni più recenti, utilizza lo strumento di grounding della ricerca.

  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 funzionerà ancora? Sì, thinking_budget è ancora supportato per la compatibilità con le versioni precedenti, ma ti consigliamo di eseguire la migrazione a thinking_level per prestazioni più prevedibili. Non utilizzare entrambi nella stessa richiesta.

  4. Gemini 3.5 Flash supporta l'API Batch? Sì. Per maggiori dettagli, 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, il grounding con Google Maps, la ricerca di file, l'esecuzione di codice, il contesto URL e la chiamata di funzione standard, incluso l'utilizzo combinato degli strumenti e l'utilizzo del computer.

Altri modelli

Passaggi successivi