Gemini 3.8 Flash ist jetzt verfügbar. Jetzt ausprobieren.

Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Neues bei Gemini 3.5 Flash

3.6 Flash und 3.5 Flash-Lite Diese Seite

Gemini 3.5 Flash ist allgemein verfügbar, stabil und für den skalierbaren Einsatz in der Produktion geeignet. Als unser bisher intelligentestes Flash-Modell bietet es dauerhafte Spitzenleistung bei der agentischen Ausführung, beim Programmieren und bei Aufgaben mit langem Horizont.

Dieser Leitfaden enthält einen Überblick über Verbesserungen, API-Änderungen und Migrationsanleitungen für Gemini 3.5 Flash.

Neues Modell

Modell	Modell-ID	Beschreibung
Gemini 3.5 Flash	`gemini-3.5-flash`	Unser bisher intelligentestes Modell für dauerhafte Spitzenleistung bei agentischen und Coding-Aufgaben.

Gemini 3.5 Flash unterstützt 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. Informationen zu den Preisen finden Sie auf der Preisseite.

Kurzanleitung

In allen Beispielen in diesem Leitfaden 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 Spitzenleistung:Unser bisher intelligentestes Flash-Modell, das für agentische und Coding-Aufgaben in großem Umfang optimiert ist.
Agentenbasierte Ausführung:Bereitstellung von Sub-Agents, Problemlösung und schnelle agentenbasierte Schleifen im großen Maßstab.
Programmieren:Iterative Programmierzyklen, schnelle Erkundung und Prototyping, um alternative Pfade zu testen und Lösungen dynamisch zu erkunden.
Langer Zeithorizont:Mehrstufige Workflows und Tool-Nutzung 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 Standardaufwand.
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.
GA-Version:Stabiles Modell für die skalierte Nutzung in der Produktion.

Das richtige Flash-Modell auswählen

Gemini 3.5 Flash ist unser bisher intelligentestes und leistungsstärkstes Flash-Modell. Für verschiedene Anwendungsfälle können jedoch unterschiedliche Kosten- und Latenzanforderungen gelten.

Gemini 3.1 Flash-Lite: Für kostengünstige Aufgaben mit hohem Volumen, die nicht die fortschrittliche Tiefe des logischen Schlussfolgerns von 3.5 Flash erfordern, empfehlen wir Gemini 3.1 Flash-Lite. Es ist ein stabiles, langfristiges Modell, das für Effizienz optimiert ist. Weitere Informationen finden Sie im Entwicklerleitfaden für Flash-Lite.
Gemini 3 Flash (Vorabversion): Wir empfehlen zwar, zu 3.5 Flash zu migrieren, um die allgemeine Verfügbarkeit und verbesserte Schlussfolgerungen zu nutzen, aber Gemini 3 Flash (Vorabversion) ist weiterhin für Entwickler verfügbar, die das Vorabversionsmodell weiterhin testen möchten.

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. Sie eignet sich auch gut für Analyse- und Schreibaufgaben, die etwas Nachdenken 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 Schlussfolgerungen, schwierige mathematische Aufgaben und die schwierigsten Code- oder Agent-Aufgaben. Ermöglicht erweiterte Überlegungen und Funktionsaufrufe.

Um die Standardeinstellung zu überschreiben, 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 weitergeführt, 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 Kontext aus allen vorherigen Zügen, wenn im Chatverlauf Denkprozess-Signaturen vorhanden sind. Um dies zu ermöglichen, übergeben Sie den vollständigen, unveränderten Unterhaltungsverlauf (einschließlich Gedankensignaturen) in contents. Das SDK erledigt 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	Jeder `FunctionResponse` muss den `id` aus dem 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. Gedankenlecks) und zu Ausgaben von geringerer Qualität führen. Folgen Sie stattdessen der Empfehlung in der Dokumentation zur Multimodal Function Responses API und fügen Sie multimodale Inhalte in die Funktionsantwortteile ein, die Sie an das Modell senden. Das Modell kann diese multimodalen Inhalte in seinem nächsten Zug verarbeiten, um eine fundiertere Antwort zu geben.

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

Häufig geben Kunden zusätzliche Anweisungen zusammen mit Funktionsantworten als nachfolgende Parts an. Dies kann zu unerwartetem Modellverhalten führen, z.B. zu einer Offenlegung von Gedanken, und die Qualität der Ausgaben beeinträchtigen. Hängen Sie stattdessen alle zusätzlichen Anweisungen an das Ende des Funktionsantworttexts 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 Methoden minimieren:

Denkstufe reduzieren (medium, low oder minimal): Bei höheren Denkstufen wird das Modell dazu angeregt, mehr Tools zum Erkunden und Überprüfen zu verwenden. Durch Senken der Stufe können Tool-Aufrufe reduziert werden.
Systemanweisung hinzufügen:Wenn die Überbeanspruchung 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.
```

Checkliste für die Migration

Wir empfehlen dringend, auf das google-genai SDK v2.0.0 oder höher zu aktualisieren. In dieser Version werden funktionsgefährdende Änderungen an der Interactions API eingeführt. Weitere Informationen finden Sie in der Migrationsanleitung zu wichtigen Änderungen.

Von Gemini 3 Flash (Vorabversion) migrieren

Modellname aktualisieren: gemini-3-flash-preview → gemini-3.5-flash
Preise prüfen. Gemini 3.5 Flash ist teurer als Gemini 3 Flash (Vorabversion). Wenn Ihr Anwendungsfall sehr kostensensibel ist, sollten Sie stattdessen zu Gemini 3.1 Flash-Lite migrieren. Weitere Informationen finden Sie auf der Preisseite.
Entfernen Sie temperature, top_p und top_k aus Ihrer Konfiguration (nicht mehr empfohlen).
Ersetzen Sie thinking_budget durch thinking_level.
Fügen Sie allen FunctionResponse-Teilen id und das entsprechende name hinzu.
Testen Sie Ihre Prompts. Der Standardaufwand wurde von high auf medium geändert. Überprüfen Sie Qualität, Geschwindigkeit und Kosten.
Die Fortführung der Logikschritte ist jetzt standardmäßig aktiviert. Der Kontext für die Argumentation wird über mehrere Runden hinweg beibehalten, was die Leistung verbessert, aber die Tokennutzung erhöhen kann.
Reduzieren Sie unnötige Tool-Aufrufe: Beginnen Sie damit, die Denkebene zu reduzieren (medium, low oder minimal). Fügen Sie eine Systemanweisung hinzu, um die Tool-Nutzung einzuschränken, wenn es weiterhin zu einer Überbeanspruchung kommt.
Computer Use wird unterstützt.

Von Gemini 2.5 migrieren

Alle oben genannten Punkte plus:

Prompts vereinfachen Wenn Sie Chain-of-Thought-Prompt-Engineering verwendet haben, um die Begründung zu erzwingen, versuchen Sie es stattdessen mit thinking_level: "medium" oder "high" mit einfacheren Prompts.
PDF- und Media-Arbeitslasten testen Wenn Sie sich beim Parsen von dichten Dokumenten auf ein bestimmtes Verhalten verlassen haben, testen Sie die Einstellung media_resolution_high, um die Genauigkeit zu gewährleisten. Durch die Migration zu Gemini 3-Standardwerten kann sich die Tokennutzung für PDFs erhöhen, für Videos jedoch verringern. Wenn Anfragen das Kontextfenster überschreiten, reduzieren Sie explizit die media_resolution. Weitere Informationen finden Sie in der Dokumentation zur Media-Auflösung.
Kombinierte Tools nutzen Google Suche, URL-Kontext, Codeausführung und benutzerdefinierte Funktionen können in derselben Anfrage verwendet werden.
Wenn Sie multimodale Funktionsantworten verwenden, verschieben Sie multimodale Inhalte in die Teile der Funktionsantwort und nicht daneben.
Wenn Sie Inline-Anweisungen mit Funktionsantworten verwenden, hängen Sie sie an den Text der Funktionsantwort an und trennen Sie sie durch zwei Zeilenumbrüche, nicht als separate Teile.
Die Bildsegmentierung wird in Gemini 3.x nicht unterstützt. Für Segmentierungs-Workloads verwenden Sie weiterhin Gemini 2.5 Flash ohne Thinking-Modus.
Entfernen Sie candidate_count aus Ihrer Konfiguration (wird in Gemini 3.x nicht unterstützt).

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:Der verschlüsselte Kontext für die Begründung wird über API-Aufrufe hinweg beibehalten. 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

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.
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.
Funktioniert mein alter thinking_budget-Code weiterhin? Ja, thinking_budget wird aus Gründen der Abwärtskompatibilität weiterhin unterstützt. Wir empfehlen jedoch, zu thinking_level zu migrieren, um eine besser vorhersagbare Leistung zu erzielen. Verwenden Sie nicht beide in derselben Anfrage.
Unterstützt Gemini 3.5 Flash die Batch API? Ja. Weitere Informationen finden Sie im Batch API-Leitfaden.
Wird Kontext-Caching unterstützt? Ja, Kontext-Caching wird unterstützt.
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 Toolnutzung und Computernutzung.

Nächste Schritte

Weitere Informationen zu Strategien für das Design von Prompts finden Sie im Leitfaden zum Prompt-Engineering.
Gemini 3 Cookbook
Informationen zur Optimierung und Inferenz der Gemini API

Neues bei Gemini 3.5 Flash

Neues Modell

Kurzanleitung

Python

JavaScript

Java

Go

REST

Das ist neu

Das richtige Flash-Modell auswählen

Verhaltensänderungen

Neuer Standardaufwand: medium

Python

JavaScript

Java

Go

REST

Fortführung der Logikschritte

Parameter-Updates und Best Practices in Gemini 3.x

Parameter für die Stichprobenerhebung (nicht mehr empfohlen)

thinking_budget (nicht mehr empfohlen)

Funktionsaufrufe: Strikter Abgleich von Antworten

Python

JavaScript

Java

Go

REST

Multimodale Funktionsantworten

Python

JavaScript

Java

Ok

Inline-Anweisungen in Funktionsantworten

Python

JavaScript

Java

Ok

Unnötige Toolaufrufe reduzieren

Checkliste für die Migration

Von Gemini 3 Flash (Vorabversion) migrieren

Von Gemini 2.5 migrieren

Funktionen der Gemini 3-Familie

Best Practices für die Prompt-Erstellung

Beschränkungen

FAQ

Nächste Schritte

Neuer Standardaufwand: `medium`

`thinking_budget` (nicht mehr empfohlen)