Nowości w Gemini 3.5 Flash

Najnowszy model Inne modele

Gemini 3.5 Flash (gemini-3.5-flash) to wycofany model Flash wcześniejszej generacji z serii Gemini 3. Żądania wysyłane do modelu gemini-3.5-flash są automatycznie przekierowywane do modelu Gemini 3.6 Flash. Informacje o naszym najnowszym modelu Flash znajdziesz w przewodniku po Gemini 3.8 Flash.

Ten przewodnik jest zachowany jako materiał historyczny i zawiera informacje o podstawowych zmianach w interfejsie Gemini 3.x API oraz zalecenia dotyczące parametrów.

Informacje o modelu

Model Identyfikator modelu Stan
Gemini 3.5 Flash gemini-3.5-flash Wycofano (automatycznie przekierowywany do modelu gemini-3.6-flash).

Model Gemini 3.5 Flash obsługiwał okno kontekstu o wielkości 1 mln tokenów, maksymalnie 65 tys. tokenów wyjściowych, myślenie oraz ten sam zestaw narzędzi i funkcji platformy co model Gemini 3 Flash, w tym korzystanie z komputera (wersja testowa).

Pełne specyfikacje znajdziesz w informacjach o modelach.

Krótkie wprowadzenie

Wszystkie przykłady w tym przewodniku korzystają z interfejsu Interactions API. Obsługiwany jest też interfejs GenerateContent API. Obowiązują te same opcje konfiguracji i zalecenia.

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

Nowości

  • Stała wydajność: zoptymalizowany pod kątem zadań agentowych i związanych z kodowaniem na dużą skalę.
  • Wykonywanie zadań przez agentów: wdrażanie podagentów, rozwiązywanie problemów i szybkie pętle agentowe na dużą skalę.
  • Kodowanie: iteracyjne cykle kodowania, szybkie eksplorowanie i tworzenie prototypów w celu testowania alternatywnych ścieżek i dynamicznego eksplorowania rozwiązań.
  • Długi horyzont: wieloetapowe przepływy pracy i korzystanie z narzędzi na dużą skalę.
  • Zachowanie myśli: model automatycznie zachowuje pośrednie wnioskowanie w rozmowach wieloetapowych. Nie trzeba wprowadzać zmian w interfejsie API.
  • Nowy domyślny nakład pracy związany z myśleniem: domyślny nakład pracy związany z myśleniem został zmieniony z high na medium. Więcej informacji znajdziesz w sekcji Nowy domyślny poziom wysiłku.
  • Ulepszone low myślenie: low został znacznie ulepszony w przypadku zadań związanych z kodem i agentowych, które wymagają mniejszej liczby kroków, zapewniając wysoką jakość przy niższym czasie oczekiwania i koszcie.

Wybór odpowiedniego modelu Flash

Model gemini-3.5-flash został wycofany i jest automatycznie przekierowywany do modelu gemini-3.6-flash, dlatego zalecamy przejście na jeden z tych aktywnych modeli:

  • Gemini 3.8 Flash: nasz najnowszy i najbardziej inteligentny model Flash do złożonych przepływów pracy związanych z kodowaniem i Agentic Workflows. Zapoznaj się z przewodnikiem po Gemini 3.8 Flash.
  • Gemini 3.6 Flash: bezpośredni zamiennik modelu gemini-3.5-flash z mniejszym zużyciem tokenów i niższymi cenami za dane wyjściowe. Zapoznaj się z przewodnikiem po Gemini 3.6 Flash i 3.5 Flash-Lite.
  • Gemini 3.5 Flash-Lite / Gemini 3.1 Flash-Lite: w przypadku zadań o niskich kosztach i dużej liczbie, które nie wymagają pełnej głębi rozumowania Flash, użyj modelu Gemini 3.5 Flash-Lite lub Gemini 3.1 Flash-Lite.

Zmiany w zachowaniu

Nowy domyślny poziom wysiłku: medium

Domyślny nakład pracy związany z myśleniem to teraz medium, a nie high jak w wersji testowej Gemini 3 Flash. Poziom medium zapewnia bardzo dobre wyniki w przypadku wielu zadań, a jednocześnie jest szybszy i bardziej opłacalny. W przypadku złożonych problemów poziom high zachęca model do głębszego myślenia.

Poziom wysiłku Kiedy używać
minimal Zoptymalizowany pod kątem szybkości odpowiedzi. Przypadki użycia podobne do czatu, szybkie odpowiedzi zgodne z prawdą, prostsze wywołania narzędzi.
low Zadania związane z kodem i agentowe, które wymagają krótszego czasu oczekiwania i mniejszej liczby kroków. Sprawdza się też w przypadku zadań związanych z analizą i pisaniem, które wymagają pewnego myślenia.
medium (wartość domyślna) Najlepsza jakość w przypadku większości zadań. Zalecany w przypadku złożonych przypadków użycia związanych z kodem i agentowych.
high Maksymalizuje zdolność modelu do myślenia i korzystania z narzędzi. Najlepszy w przypadku złożonego rozumowania, trudnych obliczeń matematycznych oraz najbardziej skomplikowanych zadań związanych z kodem lub agentowych. Umożliwia dłuższe myślenie i wywoływanie funkcji.

Aby zastąpić wartość domyślną, ustaw thinking_level w konfiguracji:

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

W tabeli poniżej znajdziesz informacje o tym, które poziomy myślenia są obsługiwane w przypadku poszczególnych modeli:

Poziom myślenia Gemini 3.5 Flash Gemini 3.1 Pro Gemini 3.1 Flash-Lite Gemini 3 Flash Opis
minimal Obsługiwane Nieobsługiwane Obsługiwane (wartość domyślna) Obsługiwane W przypadku większości zapytań odpowiada ustawieniu „bez myślenia”. Uwaga: poziom minimal nie gwarantuje, że myślenie jest wyłączone. W przypadku złożonych zadań model może myśleć w minimalnym stopniu.
low Obsługiwane Obsługiwane Obsługiwane Obsługiwane Minimalizuje czas oczekiwania i koszt.
medium Obsługiwane (wartość domyślna) Obsługiwane Obsługiwane Obsługiwane Zrównoważone myślenie w przypadku większości zadań.
high Obsługiwane (dynamiczne) Obsługiwane (wartość domyślna, dynamiczne) Obsługiwane (dynamiczne) Obsługiwane (wartość domyślna, dynamiczne) Maksymalizuje głębię rozumowania.

Zachowanie myśli

Model automatycznie zachowuje pośrednie wnioskowanie w rozmowach wieloetapowych. Jeśli w historii rozmów występuje kontekst rozumowania, jest on przenoszony, co poprawia skuteczność w przypadku złożonych zadań wieloetapowych, takich jak iteracyjne debugowanie i refaktoryzacja kodu. Nie trzeba wprowadzać zmian w interfejsie API:

  • Interfejs Interactions API: myśli są już automatycznie zachowywane. Brak zmian w zachowaniu.
  • Interfejs GenerateContent API: począwszy od modelu Gemini 3.5 Flash, model używa kontekstu rozumowania ze wszystkich poprzednich etapów, gdy w historii rozmów występują sygnatury myśli. Aby to włączyć, przekaż pełną, niezmodyfikowaną historię rozmów (w tym sygnatury myśli) w parametrze contents. Pakiety SDK robią to automatycznie.

Aktualizacje parametrów i sprawdzone metody w Gemini 3.x

Poniższe informacje dotyczą wszystkich modeli Gemini 3.x, w tym Gemini 3.5 Flash.

  • temperature, top_p, top_k: zdecydowanie zalecamy, aby nie zmieniać wartości domyślnych. Możliwości rozumowania Gemini 3 są zoptymalizowane pod kątem ustawień domyślnych.
  • Zamiast parametru thinking_budget używaj parametru thinking_level.
  • Dopasowywanie odpowiedzi wywoływania funkcji: id, name i liczba odpowiedzi muszą być zgodne z poprzednimi wywołaniami.
  • Multimodalne odpowiedzi funkcji: umieszczaj treści multimodalne w odpowiedzi funkcji, a nie poza nią.
  • Instrukcje wbudowane w odpowiedzi funkcji: dołączaj je do tekstu odpowiedzi funkcji, a nie jako osobne części.
  • Ograniczanie niepotrzebnych wywołań narzędzi: używaj niższych poziomów myślenia lub eksperymentuj z instrukcjami systemowymi, aby ograniczyć wywoływanie narzędzi w Agentic Workflows.

W sekcjach poniżej znajdziesz informacje o tym, jak zaktualizować kod.

Parametry próbkowania (nie są już zalecane)

Parametry temperature, top_p i top_k nie są już zalecane w przypadku wszystkich modeli Gemini 3.x. Możliwości rozumowania Gemini 3 są zoptymalizowane pod kątem ustawień domyślnych. Usuń te parametry ze wszystkich żądań.

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

Aby zapewnić determinizm, zalecamy zdefiniowanie instrukcji systemowej z wyraźnymi regułami dotyczącymi konkretnego przypadku użycia.

thinking_budget (nie jest już zalecany)

Parametr thinking_budget w postaci surowej liczby nie jest już zalecany w przypadku wszystkich modeli Gemini 3.x. Zamiast niego używaj wyliczenia ciągu znaków thinking_level.

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

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

Dostępne wartości: minimal, low, medium (wartość domyślna) i high.

Wywoływanie funkcji: ścisłe dopasowywanie odpowiedzi

Interfejs Interactions API już zgłasza błędy w przypadku niedopasowanych odpowiedzi funkcji. Interfejs GenerateContent API jeszcze nie zgłasza błędów, ale w większości przypadków niedopasowane odpowiedzi powodują, że model zwraca puste odpowiedzi z parametrem finish_reason: STOP. Zawsze przestrzegaj tych konwencji:

Wymaganie Szczegóły
Uwzględnij parametr id Każda FunctionResponse musi zawierać parametr id z odpowiedniego parametru FunctionCall
Dopasuj parametr name Parametr name w odpowiedzi musi być zgodny z parametrem name w wywołaniu
Dopasuj liczby Zwróć dokładnie 1 parametr FunctionResponse dla każdego otrzymanego parametru FunctionCall

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

Multimodalne odpowiedzi funkcji

Często widzimy, że klienci udostępniają obrazy poza odpowiedzią funkcji. Może to prowadzić do nieoczekiwanego zachowania modelu (np. wycieku myśli) i obniżenia jakości danych wyjściowych. Zamiast tego postępuj zgodnie z zaleceniami w dokumentacji interfejsu Multimodal Function Responses API i umieszczaj treści multimodalne w częściach odpowiedzi funkcji, które wysyłasz do modelu. Model może przetworzyć te treści multimodalne w następnym kroku, aby wygenerować bardziej świadomą odpowiedź.

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
}

Instrukcje wbudowane w odpowiedzi funkcji

Często widzimy, że klienci podają dodatkowe instrukcje wraz z odpowiedziami funkcji jako kolejne parametry Parts. Może to prowadzić do nieoczekiwanego zachowania modelu (np. wycieku myśli) i obniżenia jakości danych wyjściowych. Zamiast tego dołączaj dodatkowe instrukcje na końcu tekstu odpowiedzi funkcji, oddzielając je dwoma znakami nowego wiersza.

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
}

Ograniczanie niepotrzebnych wywołań narzędzi

Jeśli zauważysz nadmierne użycie wywołań narzędzi, możesz je zminimalizować na 2 sposoby:

  1. Zacznij od zmniejszenia poziomu myślenia (medium, low lub minimal): wyższe poziomy myślenia zachęcają model do używania większej liczby narzędzi do eksplorowania i weryfikowania, więc obniżenie poziomu może zmniejszyć liczbę wywołań narzędzi.

  2. Dodaj instrukcję systemową: jeśli po dostosowaniu poziomu myślenia problem nadal występuje, rozważ użycie prompta, który ogranicza użycie narzędzi. Na przykład:

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

Funkcje rodziny modeli Gemini 3

Model Gemini 3.5 Flash dziedziczy wszystkie możliwości rodziny modeli Gemini 3, w tym korzystanie z komputera. Funkcje wprowadzone w Gemini 3, które są nadal dostępne:

  • Myślenie: zaszyfrowany kontekst rozumowania zachowywany podczas wywołań interfejsu API. Automatyczne w interfejsie Interactions API; domyślne w interfejsie GenerateContent.
  • Ustrukturyzowane dane wyjściowe z narzędziami: połącz tryb JSON z wbudowanymi narzędziami (wyszukiwanie, kontekst adresu URL, wykonywanie kodu, wywoływanie funkcji).
  • Multimodalne odpowiedzi funkcji: zwracaj obrazy, dźwięk i inne multimedia w wynikach wywołań funkcji.
  • Wykonywanie kodu z obrazami: wykonuj kod, który przetwarza i generuje obrazy.
  • Łączne korzystanie z narzędzi: używaj wbudowanych narzędzi i niestandardowego wywoływania funkcji w tym samym żądaniu.
  • Rozdzielczość multimediów: precyzyjna kontrola alokacji tokenów na potrzeby danych wejściowych w postaci obrazów, filmów i plików PDF. Modele Gemini 3 obsługują ustawienia rozdzielczości dla poszczególnych elementów treści (low, medium, high, ultra_high) w przypadku promptów o mieszanej jakości.
  • Sygnatury myśli: zaszyfrowane reprezentacje wewnętrznego rozumowania modelu. Wymagane w przypadku wieloetapowego wywoływania funkcji w trybie bezstanowym; zarządzane automatycznie przez interfejs Interactions API i oficjalne pakiety SDK.

Sprawdzone metody tworzenia promptów

Modele Gemini 3.x to modele rozumowania, co zmienia sposób tworzenia promptów.

  • Precyzyjne instrukcje: bądź zwięzły. Modele Gemini 3.x najlepiej reagują na bezpośrednie i jasne instrukcje. Rozbudowane lub złożone techniki tworzenia promptów zaprojektowane dla starszych modeli mogą powodować nadmierną analizę przez model.
  • Szczegółowość danych wyjściowych: domyślnie modele Gemini 3 i 3.1 są mniej szczegółowe i preferują bezpośrednie, skuteczne odpowiedzi. Jeśli Twój przypadek użycia wymaga konwersacyjnego tonu, wyraźnie poinstruuj model w prompcie (np. „Wyjaśnij to jako przyjazny, rozmowny asystent”).
  • Zarządzanie kontekstem: jeśli pracujesz z dużymi zbiorami danych (np. całymi książkami, bazami kodu lub długimi filmami), umieść konkretne instrukcje lub pytania na końcu prompta, po kontekście danych. Ustal rozumowanie modelu, zaczynając pytanie od frazy takiej jak „Na podstawie powyższych informacji…”.

Więcej informacji o strategiach projektowania promptów znajdziesz w przewodniku po inżynierii promptów.

Ograniczenia

  • Segmentacja obrazów nie jest obsługiwana w Gemini 3.x. W przypadku zadań związanych z segmentacją nadal używaj modelu Gemini 2.5 Flash z wyłączonym myśleniem.

Najczęstsze pytania

  1. Jaka jest granica wiedzy w przypadku modelu Gemini 3.5 Flash? Granica wiedzy w przypadku modelu Gemini 3.5 Flash to styczeń 2025 r. Aby uzyskać najnowsze informacje, użyj narzędzia do wyszukiwania Search Grounding.

  2. Jakie są limity okna kontekstu? Model Gemini 3.5 Flash obsługuje okno kontekstu o wielkości 1 mln tokenów i maksymalnie 65 tys. tokenów wyjściowych.

  3. Czy mój stary kod thinking_budget będzie nadal działać? Tak, parametr thinking_budget jest nadal obsługiwany w celu zapewnienia zgodności wstecznej, ale zalecamy przejście na parametr thinking_level, aby uzyskać bardziej przewidywalną skuteczność. Nie używaj obu parametrów w tym samym żądaniu.

  4. Czy model Gemini 3.5 Flash obsługuje interfejs Batch API? Tak. Więcej informacji znajdziesz w przewodniku po interfejsie Batch API.

  5. Czy pamięć podręczna kontekstu jest obsługiwana? Tak, pamięć podręczna kontekstu jest obsługiwana.

  6. Które narzędzia są obsługiwane? Model Gemini 3.5 Flash obsługuje wyszukiwarkę Google, powiązanie ze źródłami informacji przy użyciu Map Google, wyszukiwanie plików, wykonywanie kodu, kontekst adresu URL i standardowe wywoływanie funkcji, w tym łączne korzystanie z narzędzi i korzystanie z komputera.

Inne modele

Co dalej?