Gemini 3.8 Flash est désormais disponible. À vous de jouer.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Nouveautés de Gemini 3.5 Flash

Dernier modèle Autres modèles

Gemini 3.5 Flash (gemini-3.5-flash) est un modèle Flash de génération antérieure de la série Gemini 3, qui est désormais obsolète. Les requêtes envoyées à gemini-3.5-flash sont automatiquement redirigées vers Gemini 3.6 Flash. Pour découvrir notre dernier modèle Flash, consultez Gemini 3.8 Flash.

Ce guide est conservé à titre de référence historique. Il documente les modifications de base de l'API Gemini 3.x et les recommandations concernant les paramètres.

Présentation du modèle

Modèle	ID du modèle	État
Gemini 3.5 Flash	`gemini-3.5-flash`	Obsolète (redirigé automatiquement vers `gemini-3.6-flash`).

Gemini 3.5 Flash était compatible avec la fenêtre de contexte d'un million de jetons, la limite de 65 000 jetons de sortie, la fonctionnalité de réflexion et le même ensemble d'outils et de fonctionnalités de plate-forme que Gemini 3 Flash, y compris Utilisation de l'ordinateur (Preview).

Pour connaître les caractéristiques complètes, consultez la présentation des modèles.

Guide de démarrage rapide

Tous les exemples de ce guide utilisent l'API Interactions. L'API GenerateContent est également compatible. Les mêmes options de configuration et recommandations s'appliquent.

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

Nouveautés

Performances durables : optimisé pour les tâches agentiques et de codage à grande échelle.
Exécution agentique : déploiement de sous-agents, résolution de problèmes et boucles agentiques rapides à grande échelle.
Codage : cycles de codage itératifs, exploration rapide et prototypage pour tester d'autres chemins et explorer dynamiquement les solutions.
Horizon long : workflows multi-étapes et utilisation d'outils à grande échelle.
Préservation de la pensée : le modèle conserve automatiquement le raisonnement intermédiaire dans les conversations multitours. Aucune modification de l'API n'est nécessaire.
Nouveau niveau d'effort par défaut : l'effort de réflexion par défaut est passé de high à medium. Pour en savoir plus, consultez Nouveau niveau d'effort par défaut.
Amélioration de la réflexion low : low est considérablement amélioré pour le code et les tâches agentiques qui nécessitent moins d'étapes, offrant une qualité élevée à une latence et un coût inférieurs.

Choisir le bon modèle Flash

Étant donné que gemini-3.5-flash est obsolète et automatiquement redirigé vers gemini-3.6-flash, nous vous recommandons de migrer vers l'un des modèles actifs suivants :

Gemini 3.8 Flash : notre dernier modèle Flash, le plus intelligent, pour le codage complexe et les workflows agentifs. Consultez le guide Gemini 3.8 Flash.
Gemini 3.6 Flash : remplace directement gemini-3.5-flash, avec une utilisation de jetons réduite et des prix de sortie plus bas. Consultez le guide Gemini 3.6 Flash et 3.5 Flash-Lite.
Gemini 3.5 Flash-Lite / Gemini 3.1 Flash-Lite : pour les tâches à faible coût et à grand volume qui ne nécessitent pas toute la profondeur de raisonnement de Flash, utilisez Gemini 3.5 Flash-Lite ou Gemini 3.1 Flash-Lite.

Changements de comportement

Nouveau niveau d'effort par défaut : `medium`

L'effort de réflexion par défaut est désormais medium, alors qu'il était de high dans la version preview de Gemini 3 Flash. medium offre de très bons résultats pour un large éventail de tâches, tout en étant plus rapide et plus économique. Pour les problèmes complexes, high encourage le modèle à réfléchir plus en profondeur.

Niveau d'effort	Quand les utiliser ?
`minimal`	Optimisé pour la vitesse de réponse. Cas d'utilisation de type chat, réponses factuelles rapides, appels d'outils plus simples.
`low`	Les tâches de codage et agentiques qui nécessitent une latence plus faible et moins d'étapes. Il est également efficace pour les tâches d'analyse et de rédaction qui nécessitent une certaine réflexion.
`medium` (par défaut)	Qualité optimale pour la plupart des tâches. Recommandé pour les cas d'utilisation complexes de code et d'agents.
`high`	Maximise la capacité du modèle à réfléchir et à utiliser des outils. Idéal pour le raisonnement complexe, les mathématiques difficiles et les tâches de code ou d'agent les plus complexes. Permet des réflexions approfondies et des appels de fonction.

Pour remplacer la valeur par défaut, définissez thinking_level dans votre configuration :

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

Le tableau suivant indique les niveaux de réflexion compatibles par modèle :

Niveau de réflexion	Gemini 3.5 Flash	Gemini 3.1 Pro	Gemini 3.1 Flash-Lite	Gemini 3 Flash	Description
`minimal`	Compatible	Not supported	Compatible (par défaut)	Compatible	Correspond au paramètre "Pas de réflexion" pour la plupart des requêtes. Notez que `minimal` ne garantit pas que la réflexion est désactivée. Le modèle peut raisonner de manière très minimale pour les tâches complexes.
`low`	Compatible	Compatible	Compatible	Compatible	Minimise la latence et les coûts.
`medium`	Compatible (par défaut)	Compatible	Compatible	Compatible	Pensée équilibrée pour la plupart des tâches.
`high`	Compatible (dynamique)	Compatible (par défaut, dynamique)	Compatible (dynamique)	Compatible (par défaut, dynamique)	Maximise la profondeur du raisonnement.

Préservation des pensées

Le modèle conserve automatiquement le raisonnement intermédiaire dans les conversations multitours. Lorsqu'il est présent dans l'historique des conversations, le contexte de raisonnement est reporté, ce qui améliore les performances pour les tâches complexes en plusieurs étapes, comme le débogage itératif et la refactorisation du code. Aucune modification de l'API n'est nécessaire :

API Interactions : les réflexions sont déjà conservées automatiquement. Aucun changement de comportement.
API GenerateContent : à partir de Gemini 3.5 Flash, le modèle utilise le contexte de raisonnement de tous les tours précédents lorsque des signatures de pensée sont présentes dans l'historique des conversations. Pour ce faire, transmettez l'historique complet et non modifié de la conversation (y compris les signatures de pensée) dans contents. Les SDK s'en chargent automatiquement.

Mises à jour des paramètres et bonnes pratiques dans Gemini 3.x

Les informations suivantes s'appliquent à tous les modèles Gemini 3.x, y compris Gemini 3.5 Flash.

temperature, top_p, top_k : nous vous recommandons vivement de ne pas modifier les valeurs par défaut. Les capacités de raisonnement de Gemini 3 sont optimisées pour les paramètres par défaut.
Utilisez thinking_level à la place de thinking_budget.
Correspondance des réponses d'appel de fonction : id, name et le nombre de réponses doivent correspondre aux appels précédents.
Réponses de fonction multimodales : incluez le contenu multimodal dans la réponse de fonction, et non en dehors.
Instructions intégrées dans les réponses de fonction : ajoutez-les au texte de la réponse de fonction, et non en tant que parties distinctes.
Réduisez les appels d'outils inutiles : utilisez des niveaux de réflexion inférieurs ou testez les instructions système pour réduire les appels d'outils dans les workflows agentiques.

Consultez les sections ci-dessous pour savoir comment mettre à jour votre code.

Paramètres d'échantillonnage (non recommandés)

temperature, top_p et top_k ne sont plus recommandés pour tous les modèles Gemini 3.x. Les capacités de raisonnement de Gemini 3 sont optimisées pour les paramètres par défaut. Supprimez ces paramètres de toutes les requêtes.

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

Pour garantir le déterminisme, nous vous recommandons de définir une instruction système avec des règles explicites pour votre cas d'utilisation spécifique.

`thinking_budget` (non recommandé)

Le paramètre numérique brut thinking_budget n'est plus recommandé pour tous les modèles Gemini 3.x. Utilisez plutôt l'enum de chaîne thinking_level.

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

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

Valeurs disponibles : minimal, low, medium (par défaut) et high.

Appel de fonction : correspondance stricte des réponses

L'API Interactions génère déjà des erreurs en cas de réponses de fonction non concordantes. L'API GenerateContent ne génère pas encore d'erreur, mais les réponses non concordantes entraînent le renvoi de réponses vides avec finish_reason: STOP par le modèle dans la plupart des cas. Respectez toujours les conventions suivantes :

Exigence	Détails
Inclure `id`	Chaque `FunctionResponse` doit inclure le `id` du `FunctionCall` correspondant.
Match `name`	Le `name` de la réponse doit correspondre au `name` de l'appel.
Nombre de correspondances	Renvoyez exactement un `FunctionResponse` pour chaque `FunctionCall` reçu.

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

Réponses de fonction multimodales

Nous constatons souvent que les clients fournissent des images en dehors de la réponse de la fonction. Cela peut entraîner un comportement inattendu du modèle (par exemple, une fuite de pensée) et générer des résultats de qualité inférieure. Suivez plutôt la recommandation dans la documentation de l'API Réponses de fonction multimodales et incluez du contenu multimodal dans les parties de la réponse de la fonction que vous envoyez au modèle. Le modèle peut traiter ce contenu multimodal lors de son prochain tour pour produire une réponse plus pertinente.

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
}

Instructions intégrées dans les réponses de fonctions

Nous constatons souvent que les clients fournissent des instructions supplémentaires avec les réponses aux fonctions en tant que Parts ultérieurs. Cela peut entraîner un comportement inattendu du modèle (par exemple, une fuite de pensée) et des résultats de qualité inférieure. Ajoutez plutôt les instructions supplémentaires à la fin du texte de réponse de la fonction, en les séparant par deux sauts de ligne.

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
}

Réduire les appels d'outils inutiles

Si vous constatez une utilisation excessive des appels d'outils, deux techniques peuvent vous aider à les minimiser :

Commencez par réduire le niveau de réflexion (medium, low ou minimal) : Les niveaux de réflexion plus élevés encouragent le modèle à utiliser davantage d'outils pour explorer et vérifier. Abaisser le niveau peut donc réduire les appels d'outils.
Ajoutez une instruction système : si l'utilisation excessive persiste après avoir ajusté le niveau de réflexion, envisagez d'utiliser une requête qui limite l'utilisation des outils. Exemple :
```
You have a limited action budget of <n> tool calls. Use them efficiently.
```

Fonctionnalités de la famille Gemini 3

Gemini 3.5 Flash hérite de toutes les fonctionnalités de la famille Gemini 3, y compris Computer Use. Fonctionnalités introduites dans Gemini 3 et conservées :

Réflexion : le contexte de raisonnement chiffré est conservé lors des appels d'API. Automatique dans l'API Interactions ; implicite dans GenerateContent.
Sorties structurées avec des outils : combinez le mode JSON avec des outils intégrés (recherche, contexte d'URL, exécution de code, appel de fonction).
Réponses de fonction multimodales : renvoyez des images, de l'audio et d'autres contenus multimédias dans les résultats des appels de fonction.
Exécution de code avec des images : exécutez du code qui traite et génère des images.
Utilisation combinée d'outils : utilisez des outils intégrés et l'appel de fonction personnalisé dans la même requête.
Résolution du contenu multimédia : contrôle précis de l'allocation de jetons pour les entrées d'images, de vidéos et de PDF. Les modèles Gemini 3 sont compatibles avec les paramètres de résolution par élément de contenu (low, medium, high, ultra_high) pour les requêtes de fidélité mixte.
Signatures de réflexion : représentations chiffrées du raisonnement interne du modèle. Obligatoire pour l'appel de fonction multitours en mode sans état. Géré automatiquement par l'API Interactions et les SDK officiels.

Bonnes pratiques concernant les prompts

Les modèles Gemini 3.x sont des modèles de raisonnement, ce qui modifie la façon dont vous devez formuler vos requêtes.

Instructions précises : soyez concis. Gemini 3.x répond mieux aux instructions directes et claires. Les techniques de prompt engineering verbeuses ou complexes conçues pour les anciens modèles peuvent entraîner une suranalyse du modèle.
Niveau de verbosité des réponses : par défaut, Gemini 3 et 3.1 sont moins verbeux et préfèrent les réponses directes et efficaces. Si votre cas d'utilisation nécessite un ton conversationnel, orientez explicitement le modèle dans votre requête (par exemple, "Explique cela comme un assistant amical et bavard").
Gestion du contexte : lorsque vous travaillez avec de grands ensembles de données (comme des livres entiers, des bases de code ou de longues vidéos), placez vos instructions ou questions spécifiques à la fin de la requête, après le contexte des données. Ancrez le raisonnement du modèle en commençant votre question par une expression telle que "Sur la base des informations précédentes…".

Découvrez les stratégies de conception de prompts dans le guide sur le prompt engineering.

Limites

La segmentation d'images n'est pas prise en charge dans Gemini 3.x. Pour les charges de travail de segmentation, continuez à utiliser Gemini 2.5 Flash avec la réflexion désactivée.

Questions fréquentes

Quelle est la date limite des connaissances pour Gemini 3.5 Flash ? Gemini 3.5 Flash a une date limite des connaissances (ou "knowledge cutoff") fixée à janvier 2025. Pour obtenir des informations plus récentes, utilisez l'outil Ancrage de recherche.
Quelles sont les limites de la fenêtre de contexte ? Gemini 3.5 Flash est compatible avec une fenêtre de contexte d'entrée d'un million de jetons et jusqu'à 65 000 jetons de sortie.
Mon ancien code thinking_budget fonctionnera-t-il toujours ? Oui, thinking_budget est toujours accepté pour la rétrocompatibilité, mais nous vous recommandons de migrer vers thinking_level pour des performances plus prévisibles. Ne les utilisez pas les deux dans la même requête.
Le modèle Gemini 3.5 Flash est-il compatible avec l'API Batch ? Oui. Pour en savoir plus, consultez le guide de l'API Batch.
La mise en cache du contexte est-elle prise en charge ? Oui, la mise en cache du contexte est prise en charge.
Quels outils sont compatibles ? Gemini 3.5 Flash est compatible avec la recherche Google, l'ancrage avec Google Maps, la recherche de fichiers, l'exécution de code, le contexte d'URL et l'appel de fonction standard, y compris l'utilisation combinée d'outils et l'utilisation de l'ordinateur.

Autres modèles

Étape suivante

Découvrez les stratégies de conception de prompts dans le guide sur le prompt engineering.
Premiers pas avec le cookbook Gemini 3
En savoir plus sur l'optimisation et l'inférence de l'API Gemini

Nouveautés de Gemini 3.5 Flash

Présentation du modèle

Guide de démarrage rapide

Python

JavaScript

Java

Go

REST

Nouveautés

Choisir le bon modèle Flash

Changements de comportement

Nouveau niveau d'effort par défaut : medium

Python

JavaScript

Java

Go

REST

Préservation des pensées

Mises à jour des paramètres et bonnes pratiques dans Gemini 3.x

Paramètres d'échantillonnage (non recommandés)

thinking_budget (non recommandé)

Appel de fonction : correspondance stricte des réponses

Python

JavaScript

Java

Go

REST

Réponses de fonction multimodales

Python

JavaScript

Java

Go

Instructions intégrées dans les réponses de fonctions

Python

JavaScript

Java

Go

Réduire les appels d'outils inutiles

Fonctionnalités de la famille Gemini 3

Bonnes pratiques concernant les prompts

Limites

Questions fréquentes

Autres modèles

Étape suivante

Nouveau niveau d'effort par défaut : `medium`

`thinking_budget` (non recommandé)