Zarządzanie sesjami w interfejsie Live API

Usługa Gemini Live API przetwarza ciągłe strumienie audio lub tekstu, które nazywamy sesjami. Możesz zarządzać cyklem życia sesji, od początkowego uzgadniania połączenia po prawidłowe zakończenie.

Limity sesji

W przypadku Live API sesja to trwałe połączenie, w ramach którego dane wejściowe i wyjściowe są przesyłane strumieniowo w sposób ciągły za pomocą tego samego połączenia.

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 rodzaju danych wejściowych:

    • Sesje wejściowe tylko z dźwiękiem są ograniczone do 15 minut.
    • Wejście wideo i audio jest ograniczone do 2 minut.

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

Zanim połączenie zostanie zakończone, otrzymasz powiadomienie o wycofaniu, które umożliwi Ci podjęcie dalszych działań.

Rozpocznij sesję

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

Aktualizacja 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ć aktualizacje przyrostowe. Użyj tego, aby wysłać dane wejściowe w postaci tekstu, utworzyć kontekst sesji lub przywrócić kontekst 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 przedstawić dokładną sekwencję zdarzeń, jak w poniższym fragmencie kodu.

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.

Instrukcje systemowe możesz aktualizować podczas aktywnej sesji. Użyj tej funkcji, aby dostosować odpowiedzi modelu, np. zmienić język odpowiedzi lub zmodyfikować ton.

Aby zaktualizować instrukcje systemowe w trakcie sesji, możesz wysłać treść tekstową z system role. 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}");
}

wykrywać, kiedy sesja ma się zakończyć;

60 sekund przed zakończeniem sesji klient otrzymuje powiadomienie o jej wygaśnięciu, co umożliwia podjęcie dalszych działań.

W przykładzie poniżej pokazujemy, jak wykryć zbliżające się zakończenie sesji przez nasłuchiwanie 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}");
    }
}