Sitzungen für die Live API verwalten

Die Gemini Live API-Prozesse verarbeiten kontinuierliche Audio- oder Textstreams, die als Sitzungen bezeichnet werden. Sie können den Sitzungslebenszyklus vom ersten Handshake bis zum ordnungsgemäßen Beenden verwalten.

Limits für Sitzungen

Bei Live API bezieht sich eine Sitzung auf eine persistente Verbindung, über die Ein- und Ausgabe kontinuierlich über dieselbe Verbindung gestreamt werden.

Wenn die Sitzung eines der folgenden Limits überschreitet, wird die Verbindung beendet.

  • Die Verbindungsdauer ist auf etwa 10 Minuten begrenzt.

  • Die Sitzungslänge hängt von den Eingabemodalitäten ab:

    • Eingabesitzungen, die nur Audio enthalten, sind auf 15 Minuten begrenzt.
    • Video- und Audioeingaben sind auf 2 Minuten begrenzt.

  • Das Sitzungskontextfenster ist auf 128.000 Tokens begrenzt.

Sie erhalten eine Benachrichtigung über die bevorstehende Einstellung, bevor die Verbindung beendet wird. So haben Sie die Möglichkeit, weitere Maßnahmen zu ergreifen.

Sitzung starten

Im Startleitfaden für Live API finden Sie ein vollständiges Snippet, das zeigt, wie eine Sitzung gestartet wird.

Aktualisierung während der Sitzung

Die Live API-Modelle unterstützen die folgenden erweiterten Funktionen für Aktualisierungen während der Sitzung:

Inkrementelle Aktualisierungen von Inhalten hinzufügen

Sie können während einer aktiven Sitzung inkrementelle Updates hinzufügen. Damit können Sie Texteingaben senden, Sitzungskontext festlegen oder Sitzungskontext wiederherstellen.

  • Bei längeren Kontexten empfehlen wir, eine Zusammenfassung der einzelnen Nachrichten bereitzustellen, um das Kontextfenster für nachfolgende Interaktionen freizugeben.

  • Bei kurzen Kontexten können Sie die Interaktionen als Abfolge von Ereignissen senden, wie im folgenden Snippet dargestellt.

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

Einheit 

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

Systemanweisungen während einer Sitzung aktualisieren

Nur verfügbar, wenn Sie Vertex AI Gemini API als API-Anbieter verwenden.

Sie können die Systemanweisungen während einer aktiven Sitzung aktualisieren. Damit können Sie die Antworten des Modells anpassen, z. B. die Sprache oder den Ton ändern.

Wenn Sie die Systemanweisungen während der Sitzung aktualisieren möchten, können Sie Textinhalte mit der Rolle system senden. Die aktualisierten Systemanweisungen bleiben für den Rest der Sitzung in Kraft.

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');
}

Einheit 

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

Erkennen, wann eine Sitzung beendet wird

60 Sekunden vor dem Ende der Sitzung wird eine going away-Benachrichtigung an den Client gesendet, damit Sie weitere Aktionen ausführen können.

Im folgenden Beispiel wird gezeigt, wie Sie eine bevorstehende Sitzungsbeendigung erkennen, indem Sie auf eine going away-Benachrichtigung warten:

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}');
  }
}

Einheit 

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