Sitzungen für die Live API verwalten

Die Gemini Live API verarbeitet kontinuierliche Audio- oder Textstreams, die als Sitzungen bezeichnet werden. Sie können den Lebenszyklus der Sitzung verwalten, von der ersten Authentifizierung bis zur ordnungsgemäßen Beendigung.

Limits für Sitzungen

Bei der Live API bezieht sich eine Sitzung auf eine dauerhafte Verbindung, bei der Eingaben und Ausgaben kontinuierlich über dieselbe Verbindung gestreamt werden.

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

  • Verbindungslänge ist auf etwa 10 Minuten begrenzt.

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

    • Sitzungen mit reiner Audioeingabe sind auf 15 Minuten begrenzt.
    • Sitzungen mit Video- und Audioeingabe sind auf 2 Minuten begrenzt.

  • Das Kontextfenster der Sitzung ist auf 128.000 Tokens begrenzt.

Sie erhalten eine Benachrichtigung über die Beendigung notification , bevor die Verbindung beendet wird, damit Sie weitere Maßnahmen ergreifen können.

Sitzung starten

Im Startleitfaden für die Live API finden Sie ein vollständiges Code-Snippet, das zeigt, wie Sie eine Sitzung starten.

Während der Sitzung aktualisieren

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

Inkrementelle Inhaltsaktualisierungen hinzufügen

Sie können während einer aktiven Sitzung inkrementelle Aktualisierungen hinzufügen. Verwenden Sie diese Funktion, um Texteingaben zu senden, Sitzungskontext zu erstellen oder Sitzungskontext wiederherzustellen.

  • Bei längeren Kontexten empfehlen wir, eine Zusammenfassung der Nachricht zu erstellen, um das Kontextfenster für nachfolgende Interaktionen freizugeben.

  • Bei kurzen Kontexten können Sie Interaktionen schrittweise senden, um die genaue Reihenfolge der Ereignisse darzustellen, wie im folgenden Code-Snippet.

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 der Sitzung aktualisieren

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

Sie können die Systemanweisungen während einer aktiven Sitzung aktualisieren. Verwenden Sie diese Funktion, um die Antworten des Modells anzupassen, z. B. die Antwortsprache zu ändern oder den Ton zu modifizieren.

Wenn Sie die Systemanweisungen während der Sitzung aktualisieren möchten, können Sie Textinhalte mit der system Rolle 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

Eine Benachrichtigung über die Beendigung wird 60 Sekunden vor dem Ende der Sitzung an den Client gesendet, damit Sie weitere Maßnahmen ergreifen können.

Im folgenden Beispiel wird gezeigt, wie Sie eine bevorstehende Beendigung der Sitzung erkennen, indem Sie auf eine Benachrichtigung über die Beendigung 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}");
    }
}