Zarządzanie sesjami w interfejsie Live API

Gemini Live API przetwarza ciągłe strumienie dźwięku lub tekstu nazywane sesjami. Możesz zarządzać cyklem życia sesji – od początkowego uzgadniania połączenia po jego prawidłowe zakończenie.

Limity sesji

W przypadku Live API, sesja to trwałe połączenie, w którym dane wejściowe i wyjściowe są przesyłane strumieniowo w sposób ciągły przez to samo połączenie.

Jeśli sesja przekroczy którykolwiek z tych limitów, połączenie zostanie zakończone.

  • Długość połączenia jest ograniczona do około 10 minut.

  • Długość sesji zależy od metod wprowadzania danych:

    • Sesje, w których dane wejściowe są tylko dźwiękowe, są ograniczone do 15 minut.
    • Sesje, w których dane wejściowe to obraz i dźwięk, są ograniczone do 2 minut.

  • Okno kontekstu sesji jest ograniczone do 128 tys. tokenów.

Zanim połączenie się zakończy, otrzymasz powiadomienie going away , które pozwoli Ci podjąć dalsze działania.

Rozpoczynanie sesji

Aby zobaczyć pełny fragment kodu pokazujący, jak rozpocząć sesję, zapoznaj się z przewodnikiem dla początkujących dotyczącym Live API.

Aktualizowanie w trakcie sesji

Modele Live API obsługują te zaawansowane funkcje aktualizacji w trakcie sesji:

Dodawanie przyrostowych aktualizacji treści

Podczas aktywnej sesji możesz dodawać przyrostowe aktualizacje. Używaj tej funkcji do wysyłania danych tekstowych, tworzenia kontekstu sesji lub przywracania kontekstu sesji.

  • W przypadku dłuższych kontekstów zalecamy podanie podsumowania pojedynczej wiadomości, aby zwolnić okno kontekstu na potrzeby kolejnych interakcji.

  • W przypadku krótkich kontekstów możesz wysyłać interakcje krok po kroku, aby odzwierciedlić dokładną sekwencję zdarzeń, tak jak w przypadku fragmentu kodu poniżej.

Swift 

// Define initial turns (history/context).
let turns: [ModelContent] = [
  ModelContent(role: "user", parts: [TextPart("What is the capital of France?")]),
  ModelContent(role: "model", parts: [TextPart("Paris")]),
]

// Send history, keeping the conversational turn OPEN (false).
await session.sendContent(turns, turnComplete: false)

// Define the new user query.
let newTurn: [ModelContent] = [
  ModelContent(role: "user", parts: [TextPart("What is the capital of Germany?")]),
]

// Send the final query, CLOSING the turn (true) to trigger the model response.
await session.sendContent(newTurn, turnComplete: true)

Kotlin 

Not yet supported for Android apps - check back soon!

Java 

Not yet supported for Android apps - check back soon!

Web 

const turns = [{ text: "Hello from the user!" }];

await session.send(
  turns,
  false // turnComplete: false
);

console.log("Sent history. Waiting for next input...");

// Define the new user query.
const newTurn [{ text: "And what is the capital of Germany?" }];

// Send the final query, CLOSING the turn (true) to trigger the model response.
await session.send(
    newTurn,
    true // turnComplete: true
);
console.log("Sent final query. Model response expected now.");

Dart 

// Define initial turns (history/context).
final List turns = [
  Content(
    "user",
    [Part.text("What is the capital of France?")],
  ),
  Content(
    "model",
    [Part.text("Paris")],
  ),
];

// Send history, keeping the conversational turn OPEN (false).
await session.send(
  input: turns,
  turnComplete: false,
);

// Define the new user query.
final List newTurn = [
  Content(
    "user",
    [Part.text("What is the capital of Germany?")],
  ),
];

// Send the final query, CLOSING the turn (true) to trigger the model response.
await session.send(
  input: newTurn,
  turnComplete: true,
);

Unity 

// Define initial turns (history/context).
List turns = new List {
    new ModelContent("user", new ModelContent.TextPart("What is the capital of France?") ),
    new ModelContent("model", new ModelContent.TextPart("Paris") ),
};

// Send history, keeping the conversational turn OPEN (false).
foreach (ModelContent turn in turns)
{
    await session.SendAsync(
        content: turn,
        turnComplete: false
    );
}

// Define the new user query.
ModelContent newTurn = ModelContent.Text("What is the capital of Germany?");

// Send the final query, CLOSING the turn (true) to trigger the model response.
await session.SendAsync(
    content: newTurn,
    turnComplete: true
);

Aktualizowanie instrukcji systemowych w trakcie sesji

Dostępne tylko wtedy, gdy jako dostawcę interfejsu API używasz Vertex AI Gemini API.

Podczas aktywnej sesji możesz aktualizować instrukcje systemowe. Używaj tej funkcji, aby dostosowywać odpowiedzi modelu, np. zmieniać język odpowiedzi lub modyfikować ton.

Aby zaktualizować instrukcje systemowe w trakcie sesji, możesz wysłać treść tekstową z rolą system. Zaktualizowane instrukcje systemowe będą obowiązywać do końca sesji.

Swift 

await session.sendContent(
  [ModelContent(
    role: "system",
    parts: [TextPart("new system instruction")]
  )],
  turnComplete: false
)

Kotlin 

Not yet supported for Android apps - check back soon!

Java 

Not yet supported for Android apps - check back soon!

Web 

Not yet supported for Web apps - check back soon!

Dart 

try {
  await _session.send(
    input: Content(
      'system',
      [Part.text('new system instruction')],
    ),
    turnComplete: false,
  );
} catch (e) {
  print('Failed to update system instructions: $e');
}

Unity 

try
{
    await session.SendAsync(
        content: new ModelContent(
            "system",
            new ModelContent.TextPart("new system instruction")
        ),
        turnComplete: false
    );
}
catch (Exception e)
{
    Debug.LogError($"Failed to update system instructions: {e.Message}");
}

Wykrywanie, kiedy sesja się zakończy

60 sekund przed zakończeniem sesji do klienta wysyłane jest powiadomienie going away, które pozwala podjąć dalsze działania.

Poniższy przykład pokazuje, jak wykryć zbliżające się zakończenie sesji, nasłuchując powiadomienia going away:

Swift 

for try await response in session.responses {
  switch response.payload {

  case .goingAwayNotice(let goingAwayNotice):
    // Prepare for the session to close soon
    if let timeLeft = goingAwayNotice.timeLeft {
        print("Server going away in \(timeLeft) seconds")
    }
  }
}

Kotlin 

for (response in session.responses) {
    when (val message = response.payload) {
        is LiveServerGoAway -> {
            // Prepare for the session to close soon
            val remaining = message.timeLeft
            logger.info("Server going away in $remaining")
        }
    }
}

Java 

session.getResponses().forEach(response -> {
    if (response.getPayload() instanceof LiveServerResponse.GoingAwayNotice) {
        LiveServerResponse.GoingAwayNotice notice = (LiveServerResponse.GoingAwayNotice) response.getPayload();
        // Prepare for the session to close soon
        Duration timeLeft = notice.getTimeLeft();
    }
});

Web 

for await (const message of session.receive()) {
  switch (message.type) {

  ...
  case "goingAwayNotice":
    console.log("Server going away. Time left:", message.timeLeft);
    break;
  }
}

Dart 

Future _handleLiveServerMessage(LiveServerResponse response) async {
  final message = response.message;
  if (message is GoingAwayNotice) {
     // Prepare for the session to close soon
     developer.log('Server going away. Time left: ${message.timeLeft}');
  }
}

Unity 

foreach (var response in session.Responses) {
    if (response.Payload is LiveSessionGoingAway notice) {
        // Prepare for the session to close soon
        TimeSpan timeLeft = notice.TimeLeft;
        Debug.Log($"Server going away notice received. Remaining: {timeLeft}");
    }
}