Nowości w Gemini 3.5 Flash

Najnowszy model Inne modele

Gemini 3.5 Flash (gemini-3.5-flash) to wycofany model Flash starszej 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 artykule Gemini 3.8 Flash.

Ten przewodnik jest zachowany do celów historycznych i zawiera dokumentację podstawowych zmian w interfejsie Gemini 3.x API oraz rekomendacje dotyczące parametrów.

Informacje o modelu

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

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

Pełne specyfikacje znajdziesz w omówieniu modeli.

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 rekomendacje.

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 subagentów, rozwiązywanie problemów i szybkie pętle agentowe na dużą skalę.
  • Kodowanie: iteracyjne cykle kodowania, szybkie eksplorowanie i prototypowanie, aby testować alternatywne ścieżki i dynamicznie eksplorować rozwiązania.
  • Długoterminowe: wieloetapowe przepływy pracy i korzystanie z narzędzi na dużą skalę.
  • Zachowanie myśli: model automatycznie zachowuje pośrednie rozumowanie w wieloetapowych rozmowach. Nie wymaga to żadnych zmian w interfejsie API.
  • Nowy domyślny poziom nakładu pracy: 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 nakładu pracy.
  • Ulepszone low myślenie: low jest znacznie ulepszony w przypadku kodu i zadań agentowych, które wymagają mniejszej liczby kroków, zapewniając wysoką jakość przy mniejszym czasie oczekiwania i koszcie.

Wybór odpowiedniego modelu Flash

gemini-3.5-flash zostało wycofane i jest automatycznie przekierowywane do gemini-3.6-flash, dlatego zalecamy przejście na jeden z tych aktywnych modeli:

Zmiany w zachowaniu

Nowy domyślny poziom nakładu pracy: medium

Domyślny nakład pracy związany z myśleniem to teraz medium, a w Gemini 3 Flash w wersji testowej wynosił high. medium daje bardzo dobre wyniki w przypadku wielu różnych zadań, a przy tym jest szybszy i bardziej opłacalny. W przypadku złożonych problemów high zachęca model do głębszego zastanowienia się.

Poziom wysiłku Kiedy używać
minimal Zoptymalizowany pod kątem szybkości reakcji. Zastosowania podobne do czatu, szybkie odpowiedzi na pytania o fakty, prostsze wywołania narzędzi.
low Kodowanie i zadania agentowe, które wymagają krótszego czasu oczekiwania i mniejszej liczby kroków. Sprawdza się też w przypadku zadań analitycznych i związanych z pisaniem, które wymagają zastanowienia.
medium (domyślnie) Najwyższa jakość w przypadku większości zadań. Zalecany w przypadku złożonego kodu i zastosowań związanych z agentami.
high Maksymalizuje zdolność modelu do myślenia i korzystania z narzędzi. Najlepszy do złożonego rozumowania, trudnych obliczeń matematycznych i najtrudniejszych zadań związanych z kodem lub agentem. Umożliwia dłuższe myślenie i wywoływanie funkcji.

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

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 poszczególnych modelach:

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 (domyślnie) Obsługiwane W przypadku większości zapytań odpowiada ustawieniu „bez myślenia”. Pamiętaj, że minimal nie gwarantuje wyłączenia myślenia. Model może w minimalnym stopniu rozumować w przypadku złożonych zadań.
low Obsługiwane Obsługiwane Obsługiwane Obsługiwane Minimalizuje czas oczekiwania i koszty.
medium Obsługiwane (domyślnie) Obsługiwane Obsługiwane Obsługiwane Zrównoważone myślenie w przypadku większości zadań.
high Obsługiwane (dynamiczne) Obsługiwane (domyślne, dynamiczne) Obsługiwane (dynamiczne) Obsługiwane (domyślne, dynamiczne) Zwiększa głębokość rozumowania.

Zachowanie myśli

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

  • Interfejs API interakcji: myśli są już automatycznie zachowywane. Brak zmiany w zachowaniu.
  • Interfejs GenerateContent API: począwszy od modelu Gemini 3.5 Flash, model używa kontekstu rozumowania ze wszystkich poprzednich tur, gdy w historii rozmów znajdują się sygnatury myśli. Aby to zrobić, przekaż w parametrze contents pełną, niezmodyfikowaną historię rozmowy (w tym sygnatury myśli). Pakiety SDK obsługują 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. Funkcje rozumowania Gemini 3 są zoptymalizowane pod kątem ustawień domyślnych.
  • Zamiast zasady thinking_budget użyj zasady thinking_level.
  • Dopasowywanie odpowiedzi wywoływania funkcji: id, name i liczba odpowiedzi muszą być zgodne z poprzednimi wywołaniami.
  • Odpowiedzi funkcji multimodalnych: zawierają treści multimodalne w odpowiedzi funkcji, a nie poza nią.
  • Instrukcje wbudowane w odpowiedzi funkcji: dołączaj 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łania narzędzi w przepływach pracy agenta.

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

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

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 dla konkretnego przypadku użycia.

thinking_budget (niezalecane)

Surowy parametr liczbowy thinking_budget nie jest już zalecany we wszystkich modelach Gemini 3.x. Zamiast tego użyj 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 (domyślna) i high.

Wywoływanie funkcji: ścisłe dopasowywanie odpowiedzi

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

Wymaganie Szczegóły
Uwzględnij: id Każdy element FunctionResponse musi zawierać element id z odpowiedniego elementu FunctionCall.
Mecz name Wartość name w odpowiedzi musi być zgodna z wartością name w wywołaniu.
Liczba dopasowań Zwróć dokładnie 1 FunctionResponse za każdy otrzymany 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": "..."}]
    }]
  }'

Odpowiedzi funkcji multimodalnych

Często zdarza się, że klienci przesyłają obrazy poza odpowiedzią funkcji. Może to prowadzić do nieoczekiwanego zachowania modelu (np. wycieku myśli) i obniżać jakość wyników. Zamiast tego postępuj zgodnie z zaleceniami w dokumentacji interfejsu API odpowiedzi funkcji multimodalnych i uwzględnij treści multimodalne w częściach odpowiedzi funkcji, które wysyłasz do modelu. Model może przetworzyć te treści multimodalne w kolejnej turze, aby wygenerować bardziej przemyślaną 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 w odpowiedziach funkcji

Często zdarza się, że klienci podają dodatkowe instrukcje wraz z odpowiedziami funkcji jako kolejne Parts. Może to prowadzić do nieoczekiwanego zachowania modelu (np. wycieku myśli) i obniżać jakość wyników. Zamiast tego dołącz 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 wykorzystanie wywołań narzędzi, możesz je zminimalizować za pomocą 2 technik:

  1. Zacznij od obniżenia poziomu myślenia (medium, low lub minimal): wyższe poziomy myślenia zachęcają model do korzystania z 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 nadmierne wykorzystanie nadal występuje, rozważ użycie promptu, który ogranicza korzystanie z narzędzia. Na przykład:

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

Funkcje rodziny Gemini 3

Model Gemini 3.5 Flash dziedziczy wszystkie funkcje 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 jest 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).
  • Odpowiedzi funkcji multimodalnych: zwracanie obrazów, dźwięku i innych multimediów w wynikach wywołań funkcji.
  • Wykonanie kodu z obrazami: wykonuj kod, który przetwarza i generuje obrazy.
  • Korzystanie z połączonych narzędzi: używaj wbudowanych narzędzi i wywoływania funkcji niestandardowych w tym samym żądaniu.
  • Rozdzielczość multimediów: precyzyjna kontrola nad przydzielaniem tokenów do danych wejściowych w postaci obrazów, filmów i plików PDF. Modele Gemini 3 obsługują ustawienia rozdzielczości poszczególnych elementów treści (low,medium, high, ultra_high) w przypadku promptów o różnej jakości.
  • Podpisy myśli: zaszyfrowane reprezentacje wewnętrznego rozumowania modelu. Wymagany w przypadku wieloetapowego wywoływania funkcji w trybie bezstanowym; zarządzany automatycznie przez interfejs Interactions API i oficjalne pakiety SDK.

Sprawdzone metody dotyczące promptów

Modele Gemini 3.x to modele rozumowania, co zmienia sposób, w jaki należy je promptować.

  • Dokładne instrukcje: zadbaj o zwięzłość. Gemini 3.x najlepiej reaguje na bezpośrednie i jasne instrukcje. Rozbudowane lub złożone techniki inżynierii promptów zaprojektowane z myślą o starszych modelach mogą powodować nadmierną analizę przez model.
  • Długość odpowiedzi: domyślnie Gemini 3 i 3.1 udzielają krótszych odpowiedzi, które są bardziej bezpośrednie i zwięzłe. Jeśli Twój przypadek użycia wymaga tonu konwersacyjnego, wyraźnie nakieruj model w prompcie (np. „Wyjaśnij to jako przyjazny, rozmowny asystent”).
  • Zarządzanie kontekstem: podczas pracy z dużymi zbiorami danych (np. całymi książkami, bazami kodu lub długimi filmami) umieszczaj konkretne instrukcje lub pytania na końcu promptu, po kontekście danych. Uzasadnij rozumowanie modelu, zaczynając pytanie od frazy „Na podstawie powyższych informacji…”.

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

Ograniczenia

  • Segmentacja obrazu nie jest obsługiwana w Gemini 3.x. W przypadku zadań związanych z segmentacją nadal używaj Gemini 2.5 Flash z wyłączoną funkcją myślenia.

Najczęstsze pytania

  1. Jaka jest granica wiedzy w przypadku Gemini 3.5 Flash? Model Gemini 3.5 Flash ma granicę wiedzy w styczniu 2025 r. Aby uzyskać bardziej aktualne informacje, skorzystaj z narzędzia Search Grounding.

  2. Jakie są limity okna kontekstu? Gemini 3.5 Flash obsługuje okno kontekstu z 1 mln tokenów wejściowych i do 65 tys. tokenów wyjściowych.

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

  4. Czy Gemini 3.5 Flash obsługuje interfejs Batch API? Tak. Szczegółowe informacje 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? Gemini 3.5 Flash obsługuje wyszukiwarkę Google, powiązanie ze źródłami informacji przy użyciu Map Google, wyszukiwanie plików, wykonanie kodu, kontekst adresu URL i standardowe wywoływanie funkcji, w tym korzystanie z połączonych narzędzi i korzystanie z komputera.

Inne modele

Co dalej?