Në Live API, një sesion i referohet një lidhjeje të vazhdueshme ku hyrja dhe dalja transmetohen vazhdimisht në të njëjtën lidhje (lexoni më shumë se si funksionon ). Ky dizajn unik i sesionit mundëson vonesë të ulët dhe mbështet veçori unike, por gjithashtu mund të sjellë sfida, si kufijtë kohorë të sesionit dhe përfundimin e hershëm. Ky udhëzues mbulon strategjitë për tejkalimin e sfidave të menaxhimit të sesioneve që mund të lindin kur përdorni API Live.
Jetëgjatësia e seancës
Pa kompresim, seancat vetëm me audio janë të kufizuara në 15 minuta dhe seancat audio-video janë të kufizuara në 2 minuta. Tejkalimi i këtyre kufijve do të përfundojë seancën (dhe për rrjedhojë, lidhjen), por ju mund të përdorni kompresimin e dritares së kontekstit për të zgjatur seancat në një kohë të pakufizuar.
Jetëgjatësia e një lidhje është gjithashtu e kufizuar, në rreth 10 minuta. Kur lidhja përfundon, sesioni përfundon gjithashtu. Në këtë rast, mund të konfiguroni një sesion të vetëm për të qëndruar aktiv në lidhje të shumta duke përdorur rifillimin e sesionit . Do të merrni gjithashtu një mesazh GoAway përpara përfundimit të lidhjes, duke ju lejuar të ndërmerrni veprime të mëtejshme.
Kompresimi i dritares së kontekstit
Për të aktivizuar sesione më të gjata dhe për të shmangur ndërprerjen e papritur të lidhjes, mund të aktivizoni ngjeshjen e dritares së kontekstit duke vendosur fushën e kontekstitWindowCompression si pjesë e konfigurimit të sesionit.
Në ContextWindowCompressionConfig , ju mund të konfiguroni një mekanizëm me dritare rrëshqitëse dhe numrin e shenjave që nxisin kompresimin.
Python
from google.genai import types
config = types.LiveConnectConfig(
response_modalities=["AUDIO"],
context_window_compression=(
# Configures compression with default parameters.
types.ContextWindowCompressionConfig(
sliding_window=types.SlidingWindow(),
)
),
)
JavaScript
const config = {
responseModalities: [Modality.AUDIO],
contextWindowCompression: { slidingWindow: {} }
};
Rifillimi i seancës
Për të parandaluar përfundimin e sesionit kur serveri rivendos periodikisht lidhjen WebSocket, konfiguroni fushën sessionResumption brenda konfigurimit të konfigurimit .
Kalimi i këtij konfigurimi bën që serveri të dërgojë mesazhe SessionResumptionUpdate , të cilat mund të përdoren për të rifilluar seancën duke kaluar shenjën e fundit të rifillimit si SessionResumptionConfig.handle e lidhjes pasuese.
Python
import asyncio
from google import genai
from google.genai import types
client = genai.Client()
model = "gemini-live-2.5-flash-preview"
async def main():
print(f"Connecting to the service with handle {previous_session_handle}...")
async with client.aio.live.connect(
model=model,
config=types.LiveConnectConfig(
response_modalities=["AUDIO"],
session_resumption=types.SessionResumptionConfig(
# The handle of the session to resume is passed here,
# or else None to start a new session.
handle=previous_session_handle
),
),
) as session:
while True:
await session.send_client_content(
turns=types.Content(
role="user", parts=[types.Part(text="Hello world!")]
)
)
async for message in session.receive():
# Periodically, the server will send update messages that may
# contain a handle for the current state of the session.
if message.session_resumption_update:
update = message.session_resumption_update
if update.resumable and update.new_handle:
# The handle should be retained and linked to the session.
return update.new_handle
# For the purposes of this example, placeholder input is continually fed
# to the model. In non-sample code, the model inputs would come from
# the user.
if message.server_content and message.server_content.turn_complete:
break
if __name__ == "__main__":
asyncio.run(main())
JavaScript
import { GoogleGenAI, Modality } from '@google/genai';
const ai = new GoogleGenAI({});
const model = 'gemini-live-2.5-flash-preview';
async function live() {
const responseQueue = [];
async function waitMessage() {
let done = false;
let message = undefined;
while (!done) {
message = responseQueue.shift();
if (message) {
done = true;
} else {
await new Promise((resolve) => setTimeout(resolve, 100));
}
}
return message;
}
async function handleTurn() {
const turns = [];
let done = false;
while (!done) {
const message = await waitMessage();
turns.push(message);
if (message.serverContent && message.serverContent.turnComplete) {
done = true;
}
}
return turns;
}
console.debug('Connecting to the service with handle %s...', previousSessionHandle)
const session = await ai.live.connect({
model: model,
callbacks: {
onopen: function () {
console.debug('Opened');
},
onmessage: function (message) {
responseQueue.push(message);
},
onerror: function (e) {
console.debug('Error:', e.message);
},
onclose: function (e) {
console.debug('Close:', e.reason);
},
},
config: {
responseModalities: [Modality.TEXT],
sessionResumption: { handle: previousSessionHandle }
// The handle of the session to resume is passed here, or else null to start a new session.
}
});
const inputTurns = 'Hello how are you?';
session.sendClientContent({ turns: inputTurns });
const turns = await handleTurn();
for (const turn of turns) {
if (turn.sessionResumptionUpdate) {
if (turn.sessionResumptionUpdate.resumable && turn.sessionResumptionUpdate.newHandle) {
let newHandle = turn.sessionResumptionUpdate.newHandle
// ...Store newHandle and start new session with this handle here
}
}
}
session.close();
}
async function main() {
await live().catch((e) => console.error('got error', e));
}
main();
Marrja e një mesazhi përpara se seanca të shkëputet
Serveri dërgon një mesazh GoAway që sinjalizon se lidhja aktuale do të ndërpritet së shpejti. Ky mesazh përfshin timeLeft , që tregon kohën e mbetur dhe ju lejon të ndërmerrni veprime të mëtejshme përpara se lidhja të ndërpritet si E ABORTUAR.
Python
async for response in session.receive():
if response.go_away is not None:
# The connection will soon be terminated
print(response.go_away.time_left)
JavaScript
const turns = await handleTurn();
for (const turn of turns) {
if (turn.goAway) {
console.debug('Time left: %s\n', turn.goAway.timeLeft);
}
}
Marrja e një mesazhi kur gjenerimi të ketë përfunduar
Serveri dërgon një mesazh gjenerimi i plotë që sinjalizon se modeli ka përfunduar gjenerimin e përgjigjes.
Python
async for response in session.receive():
if response.server_content.generation_complete is True:
# The generation is complete
JavaScript
const turns = await handleTurn();
for (const turn of turns) {
if (turn.serverContent && turn.serverContent.generationComplete) {
// The generation is complete
}
}
Çfarë është më pas
Eksploroni më shumë mënyra për të punuar me Live API në udhëzuesin e plotë të Kapaciteteve , faqen e përdorimit të veglave ose librin e gatimit Live API .