Nowości w Gemini 3.5 Flash

3.6 Flash i 3.5 Flash-Lite Ta strona

Model Gemini 3.5 Flash jest ogólnie dostępny, stabilny i gotowy do użycia w produkcji na dużą skalę. Jest to nasz najbardziej inteligentny model Flash, który zapewnia stałą, przełomową wydajność w zakresie wykonywania zadań przez agenty, kodowania i zadań długoterminowych na dużą skalę.

Ten przewodnik zawiera omówienie ulepszeń, zmian w interfejsie API i wskazówki dotyczące migracji w przypadku Gemini 3.5 Flash.

Nowy model

Gemini 3.5 Flash obsługuje 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. Cennik znajdziesz na tej stronie.

Krótkie wprowadzenie

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

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)

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

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

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, przełomowa wydajność: nasz najbardziej inteligentny model Flash, 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 związanego z myśleniem: domyślny nakład pracy związany z myśleniem zmieniono z high na medium. Więcej informacji znajdziesz w sekcji Nowy domyślny poziom nakładu pracy.
• Ulepszone myślenie low: model low został znacznie ulepszony pod kątem zadań związanych z kodem i zadań agentowych, które wymagają mniej kroków, zapewniając wysoką jakość przy mniejszym opóźnieniu i koszcie.
• Wersja GA: stabilny model do użytku produkcyjnego na dużą skalę.

Wybór odpowiedniego modelu Flash

Gemini 3.5 Flash to nasz najbardziej inteligentny i wydajny model Flash. Jednak różne przypadki użycia mogą mieć różne wymagania dotyczące kosztów i opóźnień.

• Gemini 3.1 Flash-Lite: do tanich zadań o dużej skali, które nie wymagają zaawansowanego rozumowania modelu 3.5 Flash, zalecamy używanie Gemini 3.1 Flash-Lite. Jest to stabilny model długoterminowy zoptymalizowany pod kątem wydajności. Więcej informacji znajdziesz w przewodniku dla programistów dotyczącym Flash Lite.
• Gemini 3 Flash (wersja testowa): zalecamy przejście na model 3.5 Flash, który jest bardziej stabilny i ma lepsze możliwości rozumowania. Gemini 3 Flash (wersja testowa) jest nadal dostępny dla programistów, którzy chcą kontynuować testowanie z użyciem modelu w wersji testowej.

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 Preview 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ę.

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

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)

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

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

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:

Zachowanie myśli

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

• Interfejs API interakcji: myśli są już automatycznie zachowywane. Brak zmiany w działaniu.
• Interfejs GenerateContent API: począwszy od modelu Gemini 3.5 Flash, gdy w historii rozmów znajdują się sygnatury myśli, model używa kontekstu rozumowania ze wszystkich poprzednich tur. Aby to włączyć, przekaż pełną, niezmienioną historię rozmowy (w tym sygnatury myśli) w parametrze contents. 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.
• Używaj zasady thinking_level zamiast thinking_budget.
• 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ślnie) i high.

Wywoływanie funkcji: ścisłe dopasowywanie odpowiedzi

Interfejs API interakcji 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:

# ✅ 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)}],
    }],
)

// ✅ 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) }],
  }],
});

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

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 Multimodal Function Responses API 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 precyzyjną odpowiedź.

# ✅ 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,
                },
            ],
        }
    ],
)

// ✅ 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,
      },
    ],
  }],
});

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

Instrukcje wbudowane w odpowiedzi funkcji

Często zdarza się, że klienci podają dodatkowe instrukcje wraz z odpowiedziami funkcji w kolejnych 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.

# ✅ 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}],
    }],
)

// ✅ 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 }],
  }],
});

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

ograniczanie zbędnych wywołań narzędzia,

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.
   

Lista kontrolna migracji

Zdecydowanie zalecamy aktualizację do google-genai pakietu SDK w wersji 2.0.0 lub nowszej. Ta wersja wprowadza istotne zmiany w interfejsie Interactions API. Szczegółowe informacje znajdziesz w przewodniku po migracji dotyczącej zmian powodujących niezgodność.

Przejście z Gemini 3 Flash (wersja testowa)

• Zaktualizuj nazwę modelu: gemini-3-flash-preview → gemini-3.5-flash
• Sprawdź ceny. Gemini 3.5 Flash jest droższy niż Gemini 3 Flash (wersja testowa). Jeśli Twój przypadek użycia jest bardzo wrażliwy na koszty, rozważ migrację do Gemini 3.1 Flash-Lite. Szczegółowe informacje znajdziesz na stronie z cennikiem.
• Usuń z konfiguracji elementy temperature, top_p i top_k (nie jest to już zalecane).
• Zastąp thinking_budget tekstem thinking_level.
• Dodaj id i pasujący znak name do wszystkich części FunctionResponse.
• Przetestuj prompty. Domyślny nakład pracy zmieniono z high na medium. Sprawdź jakość, szybkość i koszt.
• Zachowywanie myśli jest teraz domyślnie włączone. Kontekst rozumowania jest przenoszony między turami, co zwiększa wydajność, ale może zwiększyć wykorzystanie tokenów.
• Ogranicz niepotrzebne wywołania narzędzi: zacznij od zmniejszenia poziomu myślenia (medium, low lub minimal); jeśli nadużywanie narzędzi będzie się utrzymywać, dodaj instrukcję systemową, która ograniczy ich używanie.
• Korzystanie z komputera jest obsługiwane.

Przenoszenie z Gemini 2.5

Wszystkie powyższe funkcje oraz dodatkowo:

• Uprość prompty. Jeśli do wymuszenia rozumowania używasz techniki promptowania typu „chain-of-thought”, spróbuj zamiast tego użyć thinking_level: "medium" lub "high" z prostszymi promptami.
• Testowanie zadań związanych z plikami PDF i multimediami. Jeśli w przypadku analizowania dokumentów o dużej gęstości informacji korzystasz z określonego działania, przetestuj ustawienie media_resolution_high, aby zapewnić dalszą dokładność. Przejście na domyślne ustawienia Gemini 3 może też zwiększyć wykorzystanie tokenów w przypadku plików PDF, ale zmniejszyć je w przypadku filmów. Jeśli żądania przekraczają okno kontekstu, wyraźnie zmniejsz media_resolution. Szczegółowe informacje znajdziesz w dokumentacji dotyczącej rozdzielczości multimediów.
• Wykorzystaj połączenie narzędzi. W tym samym żądaniu można używać wyszukiwarki Google, kontekstu adresu URL, wykonywania kodu i funkcji niestandardowych.
• Jeśli używasz odpowiedzi funkcji multimodalnych, przenieś treści multimodalne do części odpowiedzi funkcji, a nie obok nich.
• Jeśli używasz instrukcji w tekście z odpowiedziami funkcji, dołącz je do tekstu odpowiedzi funkcji, oddzielając je dwoma znakami nowego wiersza, a nie jako osobne części.
• Segmentacja obrazów nie jest obsługiwana w Gemini 3.x. W przypadku zadań związanych z segmentacją nadal korzystaj z Gemini 2.5 Flash z wyłączoną funkcją myślenia.
• Usuń candidate_count z konfiguracji (nieobsługiwane w Gemini 3.x)

Funkcje rodzinne 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 przypadku interfejsu Interactions API; domyślne w przypadku interfejsu 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.
• Łączenie 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 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. Jest 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.
• Wielosłowność odpowiedzi: domyślnie Gemini 3 i 3.1 są mniej wielosłowne i wolą udzielać bezpośrednich, zwięzłych odpowiedzi. Jeśli Twój przypadek użycia wymaga konwersacyjnego tonu, wyraźnie nakieruj model w prompcie (np. „Wyjaśnij to jako przyjazny, rozmowny asystent”).
• Zarządzanie kontekstem: podczas pracy z dużymi zbiorami danych (takimi jak całe książki, bazy kodu lub długie filmy) umieszczaj konkretne instrukcje lub pytania na końcu promptu, po kontekście danych. Uzasadnij rozumowanie modelu, zaczynając pytanie od wyrażenia „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 korzystaj z 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ć najnowsze 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 ze względu na zgodność z wcześniejszymi rozwiązaniami, ale zalecamy przejście na thinking_level, aby uzyskać bardziej przewidywalną skuteczność. Nie używaj obu tych parametrów 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, wykonywanie kodu, kontekst adresu URL i standardowe wywoływanie funkcji, w tym korzystanie z połączonych narzędzi i korzystanie z komputera.

Dalsze kroki

• Więcej informacji o strategiach projektowania promptów znajdziesz w przewodniku po inżynierii promptów.
• Pierwsze kroki z Gemini 3 Cookbook
• Dowiedz się więcej o optymalizacji i wnioskowaniu w interfejsie Gemini API