Neues bei Gemini 3.5 Flash

Neuestes Modell Andere Modelle

Gemini 3.5 Flash (gemini-3.5-flash) ist ein eingestelltes Flash-Modell der Gemini 3-Serie aus einer früheren Generation. Anfragen an gemini-3.5-flash werden automatisch an Gemini 3.6 Flash weitergeleitet. Informationen zu unserem neuesten Flash-Modell finden Sie unter Gemini 3.8 Flash.

Dieser Leitfaden wird als historische Referenz beibehalten und dokumentiert die grundlegenden Änderungen an der Gemini 3.x API und Parameterempfehlungen.

Modellübersicht

Modell Modell-ID Status
Gemini 3.5 Flash gemini-3.5-flash Eingestellt (Anfragen werden automatisch an gemini-3.6-flash weitergeleitet).

Gemini 3.5 Flash unterstützte das Kontextfenster mit 1 Million Tokens, maximal 65.000 Ausgabe-Tokens, Thinking und dieselben Tools und Plattformfunktionen wie Gemini 3 Flash, einschließlich Computer Use (Preview).

Die vollständigen Spezifikationen finden Sie in der Modellübersicht.

Kurzanleitung

In allen Beispielen in dieser Anleitung wird die Interactions API verwendet. Die GenerateContent API wird ebenfalls unterstützt. Es gelten dieselben Konfigurationsoptionen und Empfehlungen.

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

Das ist neu

  • Dauerhafte Leistung:Optimiert für agentische und Coding-Aufgaben in großem Umfang.
  • Agentenbasierte Ausführung:Bereitstellung von Sub-Agents, Problemlösung und schnelle agentenbasierte Schleifen im großen Maßstab.
  • Programmieren:Iterative Programmierzyklen, schnelle Tests und Prototyping, um alternative Pfade zu testen und Lösungen dynamisch zu erkunden.
  • Langfristig:Mehrstufige Workflows und Toolnutzung im großen Maßstab.
  • Mehrfachdialog-Gedächtnis:Das Modell behält Zwischenüberlegungen in Mehrfachdialogen automatisch bei. Es sind keine API-Änderungen erforderlich.
  • Neuer Standardaufwand: Der Standardaufwand für das Denken wurde von high in medium geändert. Weitere Informationen finden Sie unter Neuer Standard-Aufwand.
  • Verbessertes low-Denken:low wurde für Code- und Agent-Aufgaben, die weniger Schritte erfordern, deutlich verbessert und bietet eine hohe Qualität bei geringerer Latenz und geringeren Kosten.

Das richtige Flash-Modell auswählen

Da gemini-3.5-flash eingestellt und automatisch an gemini-3.6-flash weitergeleitet wird, empfehlen wir, zu einem der folgenden aktiven Modelle zu migrieren:

Verhaltensänderungen

Neuer Standardaufwand: medium

Der standardmäßige Denkaufwand ist jetzt medium. In der Vorabversion von Gemini 3 Flash war er high. medium liefert bei einer Vielzahl von Aufgaben sehr gute Ergebnisse und ist dabei schneller und kostengünstiger. Bei komplexen Problemen wird das Modell durch high angeregt, genauer nachzudenken.

Aufwand Anwendung
minimal Für schnelle Antworten optimiert. Chatähnliche Anwendungsfälle, schnelle sachliche Antworten, einfachere Tool-Aufrufe.
low Code- und Agent-Aufgaben, die eine geringere Latenz und weniger Schritte erfordern. Eignet sich auch gut für Analyse- und Schreibaufgaben, die etwas mehr Überlegung erfordern.
medium (Standard) Beste Qualität für die meisten Aufgaben. Für komplexen Code und agentische Anwendungsfälle empfohlen.
high Maximiert die Fähigkeit des Modells, zu denken und Tools zu verwenden. Optimal für komplexe logische Schlussfolgerungen, schwierige mathematische Aufgaben und die anspruchsvollsten Code- oder Agent-Aufgaben. Ermöglicht erweiterte Überlegungen und Funktionsaufrufe.

Wenn Sie die Standardeinstellung überschreiben möchten, legen Sie thinking_level in Ihrer Konfiguration fest:

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

In der folgenden Tabelle sehen Sie, welche Denkebenen pro Modell unterstützt werden:

Denkaufwand Gemini 3.5 Flash Gemini 3.1. Pro Gemini 3.1 Flash Lite Gemini 3 Flash Beschreibung
minimal Unterstützt Nicht unterstützt Unterstützt (Standard) Unterstützt Entspricht für die meisten Anfragen der Einstellung „Kein Denken“. minimal garantiert nicht, dass das Thinking-Modell deaktiviert ist. Das Modell kann bei komplexen Aufgaben sehr wenig Reasoning durchführen.
low Unterstützt Unterstützt Unterstützt Unterstützt Minimiert Latenz und Kosten.
medium Unterstützt (Standard) Unterstützt Unterstützt Unterstützt Ausgewogenes Denken für die meisten Aufgaben.
high Unterstützt (dynamisch) Unterstützt (Standard, dynamisch) Unterstützt (dynamisch) Unterstützt (Standard, dynamisch) Maximiert die Tiefe der Argumentation.

Fortführung der Logikschritte

Das Modell behält automatisch Zwischenüberlegungen in Mehrfachdialogen bei. Wenn der Kontext für das logische Schlussfolgern im Unterhaltungsverlauf vorhanden ist, wird er weitergegeben, was die Leistung bei komplexen mehrstufigen Aufgaben wie iterativem Debugging und Refactoring von Code verbessert. Keine API-Änderungen erforderlich:

  • Interactions API: Gedanken werden bereits automatisch beibehalten. Keine Verhaltensänderung.
  • GenerateContent API: Ab Gemini 3.5 Flash verwendet das Modell den Reasoning-Kontext aus allen vorherigen Turns, wenn im Chatverlauf Gedanken-Signaturen vorhanden sind. Um dies zu ermöglichen, übergeben Sie den vollständigen, unveränderten Unterhaltungsverlauf (einschließlich Gedankensignaturen) in contents. Die SDKs erledigen das automatisch.

Parameter-Updates und Best Practices in Gemini 3.x

Das Folgende gilt für alle Gemini 3.x-Modelle, einschließlich Gemini 3.5 Flash.

  • temperature, top_p, top_k: Wir empfehlen dringend, die Standardwerte nicht zu ändern. Die Schlussfolgerungsfunktionen von Gemini 3 sind für die Standardeinstellungen optimiert.
  • Verwenden Sie thinking_level anstelle von thinking_budget.
  • Abgleich von Funktionsaufrufantworten: id, name und die Anzahl der Antworten müssen mit den vorherigen Aufrufen übereinstimmen.
  • Multimodale Funktionsantworten: Multimodale Inhalte müssen in der Funktionsantwort enthalten sein, nicht außerhalb.
  • Inline-Anweisungen in Funktionsantworten: An den Antworttext der Funktion anhängen, nicht als separate Teile.
  • Unnötige Tool-Aufrufe reduzieren: Verwenden Sie niedrigere Denkebenen oder testen Sie Systemanweisungen, um Tool-Aufrufe in agentischen Workflows zu reduzieren.

In den folgenden Abschnitten erfahren Sie, wie Sie Ihren Code aktualisieren.

Parameter für die Stichprobenerhebung (nicht mehr empfohlen)

temperature, top_p und top_k werden für alle Gemini 3.x-Modelle nicht mehr empfohlen. Die Schlussfolgerungsfunktionen von Gemini 3 sind für die Standardeinstellungen optimiert. Entfernen Sie diese Parameter aus allen Anfragen.

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

Um die Deterministik zu gewährleisten, empfehlen wir, eine Systemanweisung mit expliziten Regeln für Ihren spezifischen Anwendungsfall zu definieren.

thinking_budget (nicht mehr empfohlen)

Der numerische Rohparameter thinking_budget wird für alle Gemini 3.x-Modelle nicht mehr empfohlen. Verwenden Sie stattdessen das String-Enum thinking_level.

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

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

Verfügbare Werte: minimal, low, medium (Standard) und high.

Funktionsaufrufe: Strikter Abgleich von Antworten

Die Interactions API gibt bereits Fehler bei nicht übereinstimmenden Funktionsantworten zurück. Die GenerateContent API gibt noch keinen Fehler zurück, aber bei nicht übereinstimmenden Antworten gibt das Modell in den meisten Fällen leere Antworten mit finish_reason: STOP zurück. Beachten Sie immer die folgenden Konventionen:

Anforderung Details
id einschließen Jede FunctionResponse muss die id der entsprechenden FunctionCall enthalten.
name. Partie Die name in der Antwort muss mit der name im Aufruf übereinstimmen.
Anzahl der Übereinstimmungen Gibt für jedes empfangene FunctionCall genau ein FunctionResponse zurück.

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

Multimodale Funktionsantworten

Wir stellen häufig fest, dass Kunden Bilder außerhalb der Funktionsantwort bereitstellen. Dies kann zu unerwartetem Modellverhalten (z.B. Offenlegung von Gedanken) und zu Ausgaben von geringerer Qualität führen. Folgen Sie stattdessen der Empfehlung in der API-Dokumentation zu multimodalen Funktionsantworten und fügen Sie multimodale Inhalte in die Teile der Funktionsantwort ein, die Sie an das Modell senden. Das Modell kann diese multimodalen Inhalte in seinem nächsten Zug verarbeiten, um eine fundiertere Antwort zu generieren.

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

Ok

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
}

Inline-Anweisungen in Funktionsantworten

Wir sehen oft, dass Kunden zusätzliche Anweisungen zusammen mit Funktionsantworten als nachfolgende Parts angeben. Dies kann zu unerwartetem Modellverhalten (z.B. Offenlegung von Gedanken) und zu Ausgaben von geringerer Qualität führen. Hängen Sie stattdessen alle zusätzlichen Anweisungen an das Ende des Antworttexts der Funktion an und trennen Sie sie durch zwei Zeilenumbrüche.

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

Ok

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
}

Unnötige Toolaufrufe reduzieren

Wenn es zu einem übermäßigen Gebrauch von Tool-Aufrufen kommt, können Sie das mit zwei Techniken minimieren:

  1. Reduzieren Sie zuerst die Denkebene (medium, low oder minimal): Bei höheren Denkebenen wird das Modell dazu angeregt, mehr Tools zum Untersuchen und Überprüfen zu verwenden. Durch Senken der Ebene können Tool-Aufrufe reduziert werden.

  2. Systemanweisung hinzufügen:Wenn die übermäßige Nutzung nach dem Anpassen der Denkebene weiterhin besteht, sollten Sie einen Prompt verwenden, der die Toolnutzung einschränkt. Beispiel:

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

Funktionen der Gemini 3-Familie

Gemini 3.5 Flash bietet alle Funktionen der Gemini 3-Familie, einschließlich Computer Use. Funktionen, die in Gemini 3 eingeführt wurden und weiterhin verfügbar sind:

  • Überlegung:Verschlüsselter Kontext für die Begründung, der über API-Aufrufe hinweg beibehalten wird. Automatisch in der Interactions API; implizit in GenerateContent.
  • Strukturierte Ausgaben mit Tools:Kombinieren Sie den JSON-Modus mit integrierten Tools (Suche, URL-Kontext, Codeausführung, Funktionsaufruf).
  • Multimodale Funktionsantworten:Bilder, Audio und andere Medien in Funktionsaufrufergebnissen zurückgeben.
  • Codeausführung mit Bildern:Code ausführen, der Bilder verarbeitet und generiert.
  • Kombinierte Tool-Nutzung:Verwenden Sie integrierte Tools und benutzerdefinierte Funktionsaufrufe in derselben Anfrage.
  • Media-Auflösung:Detaillierte Steuerung der Tokenzuweisung für Bild-, Video- und PDF-Eingaben. Gemini 3-Modelle unterstützen Auflösungseinstellungen pro Inhaltselement (low, medium, high, ultra_high) für Prompts mit unterschiedlicher Qualität.
  • Gedankensignaturen:Verschlüsselte Darstellungen der internen Argumentation des Modells. Erforderlich für Mehrfachdialog-Funktionsaufrufe im zustandslosen Modus; wird automatisch von der Interactions API und den offiziellen SDKs verwaltet.

Best Practices für die Prompt-Erstellung

Gemini 3.x-Modelle sind Modelle für das Schlussfolgern. Das bedeutet, dass Sie Ihre Prompts anders formulieren müssen.

  • Genaue Anweisungen:Fassen Sie sich kurz. Gemini 3.x reagiert am besten auf direkte, klare Anweisungen. Ausführliche oder komplexe Prompt-Engineering-Techniken, die für ältere Modelle entwickelt wurden, können dazu führen, dass das Modell zu viele Analysen durchführt.
  • Ausführlichkeit der Ausgabe:Standardmäßig sind Gemini 3 und 3.1 weniger ausführlich und bevorzugen direkte, effiziente Antworten. Wenn Ihr Anwendungsfall einen Konversationston erfordert, weisen Sie das Modell in Ihrem Prompt explizit darauf hin (z. B. „Erkläre das als freundlicher, gesprächiger Assistent“).
  • Kontextverwaltung:Wenn Sie mit großen Datasets arbeiten (z. B. ganze Bücher, Codebasen oder lange Videos), platzieren Sie Ihre spezifischen Anweisungen oder Fragen am Ende des Prompts, nach dem Datenkontext. Verankern Sie die Argumentation des Modells, indem Sie Ihre Frage mit einer Formulierung wie „Basierend auf den vorherigen Informationen…“ beginnen.

Weitere Informationen zu Strategien für das Design von Prompts finden Sie im Leitfaden zum Prompt-Engineering.

Beschränkungen

  • Die Bildsegmentierung wird in Gemini 3.x nicht unterstützt. Für Segmentierungs-Workloads verwenden Sie weiterhin Gemini 2.5 Flash ohne Thinking-Modus.

FAQ

  1. Was ist der Wissensstand von Gemini 3.5 Flash? Gemini 3.5 Flash hat einen Wissensstand von Januar 2025. Aktuellere Informationen finden Sie im Tool Search Grounding.

  2. Was sind die Grenzwerte für das Kontextfenster? Gemini 3.5 Flash unterstützt ein Kontextfenster mit 1 Million Eingabetokens und bis zu 65.000 Ausgabetokens.

  3. Funktioniert mein alter thinking_budget-Code weiterhin? Ja, thinking_budget wird weiterhin für die Abwärtskompatibilität unterstützt. Wir empfehlen jedoch, zu thinking_level zu migrieren, um eine besser vorhersagbare Leistung zu erzielen. Verwenden Sie nicht beide in derselben Anfrage.

  4. Unterstützt Gemini 3.5 Flash die Batch API? Ja. Weitere Informationen finden Sie im Batch API-Leitfaden.

  5. Wird Kontext-Caching unterstützt? Ja, Kontext-Caching wird unterstützt.

  6. Welche Tools werden unterstützt? Gemini 3.5 Flash unterstützt Google Suche, Grounding mit Google Maps, Dateisuche, Codeausführung, URL-Kontext und standardmäßigen Funktionsaufruf>, einschließlich kombinierter Tool-Nutzung und Computer-Nutzung.

Andere Modelle

Nächste Schritte