Gestisci le sessioni per l'API Live

Il Gemini Live API elabora flussi continui di audio o testo chiamati sessioni. Puoi gestire il ciclo di vita della sessione, dall'handshake iniziale alla terminazione controllata.

Limiti per le sessioni

Per l'Live API, una sessione si riferisce a una connessione persistente in cui input e output vengono trasmessi in streaming continuo sulla stessa connessione.

Se la sessione supera uno qualsiasi dei seguenti limiti, la connessione viene terminata.

  • La durata della connessione è limitata a circa 10 minuti.

  • La durata della sessione dipende dalle modalità di input:

    • Le sessioni di input solo audio sono limitate a 15 minuti.
    • L'input video + audio è limitato a 2 minuti.

  • La finestra contestuale della sessione è limitata a 128.000 token.

Prima della fine della connessione, riceverai una notifica di chiusura che ti consentirà di intraprendere ulteriori azioni.

Avviare una sessione

Per uno snippet completo che mostra come avviare una sessione, consulta la guida introduttiva Live API.

Aggiornare a metà sessione

I modelli Live API supportano le seguenti funzionalità avanzate per gli aggiornamenti a metà sessione:

Aggiungere aggiornamenti incrementali dei contenuti

Puoi aggiungere aggiornamenti incrementali durante una sessione attiva. Utilizza questa opzione per inviare input di testo, stabilire il contesto della sessione o ripristinare il contesto della sessione.

  • Per contesti più lunghi, ti consigliamo di fornire un riepilogo di un singolo messaggio per liberare la finestra contestuale per le interazioni successive.

  • Per contesti brevi, puoi inviare interazioni passo passo per rappresentare la sequenza esatta di eventi, come lo snippet riportato di seguito.

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

Aggiornare le istruzioni di sistema a metà sessione

Disponibile solo quando utilizzi Vertex AI Gemini API come fornitore di API.

Puoi aggiornare le istruzioni di sistema durante una sessione attiva. Utilizza questa opzione per adattare le risposte del modello, ad esempio per modificare la lingua della risposta o il tono.

Per aggiornare le istruzioni di sistema a metà sessione, puoi inviare contenuti di testo con il ruolo system. Le istruzioni di sistema aggiornate rimarranno in vigore per il resto della sessione.

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

Rilevare quando una sessione sta per terminare

60 secondi prima della fine della sessione, al client viene inviata una notifica di chiusura che ti consente di intraprendere ulteriori azioni.

L'esempio seguente mostra come rilevare un'imminente terminazione della sessione ascoltando una notifica di chiusura:

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