Ky është një udhëzues gjithëpërfshirës që mbulon aftësitë dhe konfigurimet e disponueshme me Live API. Shihni faqen "Filloni me Live API" për një përmbledhje dhe kod shembull për rastet e përdorimit të zakonshëm.
Para se të filloni
- Njihuni me konceptet kryesore: Nëse nuk e keni bërë ende, lexoni më parë faqen "Filloni me Live API" . Kjo do t'ju prezantojë me parimet themelore të Live API, mënyrën e funksionimit të tij dhe qasjet e ndryshme të zbatimit .
- Provoni API-n Live në AI Studio: Mund ta gjeni të dobishme të provoni API-n Live në Google AI Studio përpara se të filloni ndërtimin. Për të përdorur API-n Live në Google AI Studio, zgjidhni Transmetim .
Vendosja e një lidhjeje
Shembulli i mëposhtëm tregon se si të krijoni një lidhje me një çelës API:
Python
import asyncio
from google import genai
client = genai.Client()
model = "gemini-2.5-flash-native-audio-preview-12-2025"
config = {"response_modalities": ["AUDIO"]}
async def main():
async with client.aio.live.connect(model=model, config=config) as session:
print("Session started")
# Send content...
if __name__ == "__main__":
asyncio.run(main())
JavaScript
import { GoogleGenAI, Modality } from '@google/genai';
const ai = new GoogleGenAI({});
const model = 'gemini-2.5-flash-native-audio-preview-12-2025';
const config = { responseModalities: [Modality.AUDIO] };
async function main() {
const session = await ai.live.connect({
model: model,
callbacks: {
onopen: function () {
console.debug('Opened');
},
onmessage: function (message) {
console.debug(message);
},
onerror: function (e) {
console.debug('Error:', e.message);
},
onclose: function (e) {
console.debug('Close:', e.reason);
},
},
config: config,
});
console.debug("Session started");
// Send content...
session.close();
}
main();
Modalitetet e ndërveprimit
Seksionet e mëposhtme ofrojnë shembuj dhe kontekst mbështetës për modalitetet e ndryshme të hyrjes dhe daljes të disponueshme në Live API.
Duke dërguar audion
Audio duhet të dërgohet si të dhëna të papërpunuara PCM (audio PCM 16-bit i papërpunuar, 16kHz, little-endian).
Python
# Assuming 'chunk' is your raw PCM audio bytes
await session.send_realtime_input(
audio=types.Blob(
data=chunk,
mime_type="audio/pcm;rate=16000"
)
)
JavaScript
// Assuming 'chunk' is a Buffer of raw PCM audio
session.sendRealtimeInput({
audio: {
data: chunk.toString('base64'),
mimeType: 'audio/pcm;rate=16000'
}
});
Formatet audio
Të dhënat audio në Live API janë gjithmonë të papërpunuara, little-endian, PCM 16-bit. Dalja audio përdor gjithmonë një shpejtësi mostrimi prej 24kHz. Audio hyrëse është natyrshëm 16kHz, por Live API do të rimodelojë nëse është e nevojshme, në mënyrë që të mund të dërgohet çdo shpejtësi mostrimi. Për të përcjellë shpejtësinë e mostrimit të audios hyrëse, vendosni llojin MIME të çdo Blob që përmban audio në një vlerë si audio/pcm;rate=16000 .
Duke marrë audion
Përgjigjet audio të modelit merren si pjesë të të dhënave.
Python
async for response in session.receive():
if response.server_content and response.server_content.model_turn:
for part in response.server_content.model_turn.parts:
if part.inline_data:
audio_data = part.inline_data.data
# Process or play the audio data
JavaScript
// Inside the onmessage callback
const content = response.serverContent;
if (content?.modelTurn?.parts) {
for (const part of content.modelTurn.parts) {
if (part.inlineData) {
const audioData = part.inlineData.data;
// Process or play audioData (base64 encoded string)
}
}
}
Duke dërguar mesazh
Teksti mund të dërgohet duke përdorur send_realtime_input (Python) ose sendRealtimeInput (JavaScript).
Python
await session.send_realtime_input(text="Hello, how are you?")
JavaScript
session.sendRealtimeInput({
text: 'Hello, how are you?'
});
Duke dërguar videon
Kornizat video dërgohen si imazhe individuale (p.sh., JPEG ose PNG) me një shpejtësi specifike të kuadrove (maksimumi 1 kornizë për sekondë).
Python
# Assuming 'frame' is your JPEG-encoded image bytes
await session.send_realtime_input(
video=types.Blob(
data=frame,
mime_type="image/jpeg"
)
)
JavaScript
// Assuming 'frame' is a Buffer of JPEG-encoded image data
session.sendRealtimeInput({
video: {
data: frame.toString('base64'),
mimeType: 'image/jpeg'
}
});
Përditësime shtesë të përmbajtjes
Përdorni përditësime graduale për të dërguar tekst, për të krijuar kontekstin e sesionit ose për të rivendosur kontekstin e sesionit. Për kontekste të shkurtra, mund të dërgoni ndërveprime hap pas hapi për të përfaqësuar sekuencën e saktë të ngjarjeve:
Python
turns = [
{"role": "user", "parts": [{"text": "What is the capital of France?"}]},
{"role": "model", "parts": [{"text": "Paris"}]},
]
await session.send_client_content(turns=turns, turn_complete=False)
turns = [{"role": "user", "parts": [{"text": "What is the capital of Germany?"}]}]
await session.send_client_content(turns=turns, turn_complete=True)
JavaScript
let inputTurns = [
{ "role": "user", "parts": [{ "text": "What is the capital of France?" }] },
{ "role": "model", "parts": [{ "text": "Paris" }] },
]
session.sendClientContent({ turns: inputTurns, turnComplete: false })
inputTurns = [{ "role": "user", "parts": [{ "text": "What is the capital of Germany?" }] }]
session.sendClientContent({ turns: inputTurns, turnComplete: true })
Për kontekste më të gjata, rekomandohet të jepni një përmbledhje të vetme mesazhi për të liruar dritaren e kontekstit për ndërveprimet pasuese. Shihni Rifillimin e Sesionit për një metodë tjetër për ngarkimin e kontekstit të sesionit.
Transkriptime audio
Përveç përgjigjes së modelit, mund të merrni edhe transkriptime si të daljes audio ashtu edhe të hyrjes audio.
Për të aktivizuar transkriptimin e daljes audio të modelit, dërgoni output_audio_transcription në konfigurimin e konfigurimit. Gjuha e transkriptimit nxirret nga përgjigja e modelit.
Python
import asyncio
from google import genai
from google.genai import types
client = genai.Client()
model = "gemini-2.5-flash-native-audio-preview-12-2025"
config = {
"response_modalities": ["AUDIO"],
"output_audio_transcription": {}
}
async def main():
async with client.aio.live.connect(model=model, config=config) as session:
message = "Hello? Gemini are you there?"
await session.send_client_content(
turns={"role": "user", "parts": [{"text": message}]}, turn_complete=True
)
async for response in session.receive():
if response.server_content.model_turn:
print("Model turn:", response.server_content.model_turn)
if response.server_content.output_transcription:
print("Transcript:", response.server_content.output_transcription.text)
if __name__ == "__main__":
asyncio.run(main())
JavaScript
import { GoogleGenAI, Modality } from '@google/genai';
const ai = new GoogleGenAI({});
const model = 'gemini-2.5-flash-native-audio-preview-12-2025';
const config = {
responseModalities: [Modality.AUDIO],
outputAudioTranscription: {}
};
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;
}
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: config,
});
const inputTurns = 'Hello how are you?';
session.sendClientContent({ turns: inputTurns });
const turns = await handleTurn();
for (const turn of turns) {
if (turn.serverContent && turn.serverContent.outputTranscription) {
console.debug('Received output transcription: %s\n', turn.serverContent.outputTranscription.text);
}
}
session.close();
}
async function main() {
await live().catch((e) => console.error('got error', e));
}
main();
Për të aktivizuar transkriptimin e të dhënave audio të modelit, dërgoni input_audio_transcription në konfigurimin e konfigurimit.
Python
import asyncio
from pathlib import Path
from google import genai
from google.genai import types
client = genai.Client()
model = "gemini-2.5-flash-native-audio-preview-12-2025"
config = {
"response_modalities": ["AUDIO"],
"input_audio_transcription": {},
}
async def main():
async with client.aio.live.connect(model=model, config=config) as session:
audio_data = Path("16000.pcm").read_bytes()
await session.send_realtime_input(
audio=types.Blob(data=audio_data, mime_type='audio/pcm;rate=16000')
)
async for msg in session.receive():
if msg.server_content.input_transcription:
print('Transcript:', msg.server_content.input_transcription.text)
if __name__ == "__main__":
asyncio.run(main())
JavaScript
import { GoogleGenAI, Modality } from '@google/genai';
import * as fs from "node:fs";
import pkg from 'wavefile';
const { WaveFile } = pkg;
const ai = new GoogleGenAI({});
const model = 'gemini-2.5-flash-native-audio-preview-12-2025';
const config = {
responseModalities: [Modality.AUDIO],
inputAudioTranscription: {}
};
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;
}
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: config,
});
// Send Audio Chunk
const fileBuffer = fs.readFileSync("16000.wav");
// Ensure audio conforms to API requirements (16-bit PCM, 16kHz, mono)
const wav = new WaveFile();
wav.fromBuffer(fileBuffer);
wav.toSampleRate(16000);
wav.toBitDepth("16");
const base64Audio = wav.toBase64();
// If already in correct format, you can use this:
// const fileBuffer = fs.readFileSync("sample.pcm");
// const base64Audio = Buffer.from(fileBuffer).toString('base64');
session.sendRealtimeInput(
{
audio: {
data: base64Audio,
mimeType: "audio/pcm;rate=16000"
}
}
);
const turns = await handleTurn();
for (const turn of turns) {
if (turn.text) {
console.debug('Received text: %s\n', turn.text);
}
else if (turn.data) {
console.debug('Received inline data: %s\n', turn.data);
}
else if (turn.serverContent && turn.serverContent.inputTranscription) {
console.debug('Received input transcription: %s\n', turn.serverContent.inputTranscription.text);
}
}
session.close();
}
async function main() {
await live().catch((e) => console.error('got error', e));
}
main();
Ndrysho zërin dhe gjuhën
Modelet e daljes audio vendase mbështesin çdo zë të disponueshëm për modelet tona Tekst-në-Fjalë (TTS) . Ju mund t'i dëgjoni të gjithë zërat në AI Studio .
Për të specifikuar një zë, vendosni emrin e zërit brenda objektit speechConfig si pjesë e konfigurimit të sesionit:
Python
config = {
"response_modalities": ["AUDIO"],
"speech_config": {
"voice_config": {"prebuilt_voice_config": {"voice_name": "Kore"}}
},
}
JavaScript
const config = {
responseModalities: [Modality.AUDIO],
speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } } }
};
API-ja Live mbështet shumë gjuhë . Modelet e daljes audio vendase zgjedhin automatikisht gjuhën e duhur dhe nuk mbështesin caktimin e qartë të kodit të gjuhës.
Aftësi audio vendase
Modelet tona më të fundit kanë dalje audio native , e cila ofron të folur natyrale dhe realiste dhe performancë të përmirësuar shumëgjuhëshe. Audio native gjithashtu mundëson veçori të përparuara si dialog afektiv (i vetëdijshëm për emocionet) , audio proaktive (ku modeli vendos në mënyrë inteligjente se kur t'i përgjigjet të dhënave hyrëse) dhe "të menduarit" .
Dialog afektiv
Kjo veçori i lejon Gemini-t të përshtasë stilin e tij të përgjigjes sipas shprehjes dhe tonit të hyrjes.
Për të përdorur dialogun affective, caktoni versionin api në v1alpha dhe caktoni enable_affective_dialog në true në mesazhin e konfigurimit:
Python
client = genai.Client(http_options={"api_version": "v1alpha"})
config = types.LiveConnectConfig(
response_modalities=["AUDIO"],
enable_affective_dialog=True
)
JavaScript
const ai = new GoogleGenAI({ httpOptions: {"apiVersion": "v1alpha"} });
const config = {
responseModalities: [Modality.AUDIO],
enableAffectiveDialog: true
};
Audio proaktive
Kur kjo veçori është e aktivizuar, Gemini mund të vendosë në mënyrë proaktive të mos përgjigjet nëse përmbajtja nuk është relevante.
Për ta përdorur, caktoni versionin api në v1alpha dhe konfiguroni fushën e proactivity në mesazhin e konfigurimit dhe caktoni proactive_audio në true :
Python
client = genai.Client(http_options={"api_version": "v1alpha"})
config = types.LiveConnectConfig(
response_modalities=["AUDIO"],
proactivity={'proactive_audio': True}
)
JavaScript
const ai = new GoogleGenAI({ httpOptions: {"apiVersion": "v1alpha"} });
const config = {
responseModalities: [Modality.AUDIO],
proactivity: { proactiveAudio: true }
}
Të menduarit
Modeli më i fundit i daljes audio native gemini-2.5-flash-native-audio-preview-12-2025 mbështet aftësitë e të menduarit , me të menduarit dinamik të aktivizuar si parazgjedhje.
Parametri thinkingBudget udhëzon modelin për numrin e tokenëve të të menduarit që duhet të përdoren kur gjenerohet një përgjigje. Mund ta çaktivizoni të menduarit duke e vendosur thinkingBudget në 0 Për më shumë informacion mbi detajet e konfigurimit të thinkingBudget të modelit, shihni dokumentacionin e buxheteve të të menduarit .
Python
model = "gemini-2.5-flash-native-audio-preview-12-2025"
config = types.LiveConnectConfig(
response_modalities=["AUDIO"]
thinking_config=types.ThinkingConfig(
thinking_budget=1024,
)
)
async with client.aio.live.connect(model=model, config=config) as session:
# Send audio input and receive audio
JavaScript
const model = 'gemini-2.5-flash-native-audio-preview-12-2025';
const config = {
responseModalities: [Modality.AUDIO],
thinkingConfig: {
thinkingBudget: 1024,
},
};
async function main() {
const session = await ai.live.connect({
model: model,
config: config,
callbacks: ...,
});
// Send audio input and receive audio
session.close();
}
main();
Për më tepër, mund të aktivizoni përmbledhjet e mendimeve duke vendosur includeThoughts në true në konfigurimin tuaj. Shihni përmbledhjet e mendimeve për më shumë informacion:
Python
model = "gemini-2.5-flash-native-audio-preview-12-2025"
config = types.LiveConnectConfig(
response_modalities=["AUDIO"]
thinking_config=types.ThinkingConfig(
thinking_budget=1024,
include_thoughts=True
)
)
JavaScript
const model = 'gemini-2.5-flash-native-audio-preview-12-2025';
const config = {
responseModalities: [Modality.AUDIO],
thinkingConfig: {
thinkingBudget: 1024,
includeThoughts: true,
},
};
Zbulimi i Aktivitetit të Zërit (VAD)
Zbulimi i Aktivitetit të Zërit (VAD) i lejon modelit të njohë kur një person po flet. Kjo është thelbësore për krijimin e bisedave natyrale, pasi i lejon një përdoruesi ta ndërpresë modelin në çdo kohë.
Kur VAD zbulon një ndërprerje, gjenerimi në vazhdim anulohet dhe hidhet poshtë. Vetëm informacioni që i është dërguar tashmë klientit ruhet në historikun e seancës. Serveri më pas dërgon një mesazh BidiGenerateContentServerContent për të raportuar ndërprerjen.
Serveri Gemini më pas hedh poshtë çdo thirrje funksioni në pritje dhe dërgon një mesazh BidiGenerateContentServerContent me ID-të e thirrjeve të anuluara.
Python
async for response in session.receive():
if response.server_content.interrupted is True:
# The generation was interrupted
# If realtime playback is implemented in your application,
# you should stop playing audio and clear queued playback here.
JavaScript
const turns = await handleTurn();
for (const turn of turns) {
if (turn.serverContent && turn.serverContent.interrupted) {
// The generation was interrupted
// If realtime playback is implemented in your application,
// you should stop playing audio and clear queued playback here.
}
}
VAD automatik
Si parazgjedhje, modeli kryen automatikisht VAD në një rrjedhë të vazhdueshme hyrëse audio. VAD mund të konfigurohet me fushën realtimeInputConfig.automaticActivityDetection të konfigurimit të konfigurimit .
Kur transmetimi audio ndalet për më shumë se një sekondë (për shembull, sepse përdoruesi e ka fikur mikrofonin), duhet të dërgohet një ngjarje audioStreamEnd për të pastruar çdo audio të ruajtur në memorien e përkohshme. Klienti mund të rifillojë dërgimin e të dhënave audio në çdo kohë.
Python
# example audio file to try:
# URL = "https://storage.googleapis.com/generativeai-downloads/data/hello_are_you_there.pcm"
# !wget -q $URL -O sample.pcm
import asyncio
from pathlib import Path
from google import genai
from google.genai import types
client = genai.Client()
model = "gemini-2.5-flash-native-audio-preview-12-2025"
config = {"response_modalities": ["AUDIO"]}
async def main():
async with client.aio.live.connect(model=model, config=config) as session:
audio_bytes = Path("sample.pcm").read_bytes()
await session.send_realtime_input(
audio=types.Blob(data=audio_bytes, mime_type="audio/pcm;rate=16000")
)
# if stream gets paused, send:
# await session.send_realtime_input(audio_stream_end=True)
async for response in session.receive():
if response.text is not None:
print(response.text)
if __name__ == "__main__":
asyncio.run(main())
JavaScript
// example audio file to try:
// URL = "https://storage.googleapis.com/generativeai-downloads/data/hello_are_you_there.pcm"
// !wget -q $URL -O sample.pcm
import { GoogleGenAI, Modality } from '@google/genai';
import * as fs from "node:fs";
const ai = new GoogleGenAI({});
const model = 'gemini-live-2.5-flash-preview';
const config = { responseModalities: [Modality.AUDIO] };
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;
}
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: config,
});
// Send Audio Chunk
const fileBuffer = fs.readFileSync("sample.pcm");
const base64Audio = Buffer.from(fileBuffer).toString('base64');
session.sendRealtimeInput(
{
audio: {
data: base64Audio,
mimeType: "audio/pcm;rate=16000"
}
}
);
// if stream gets paused, send:
// session.sendRealtimeInput({ audioStreamEnd: true })
const turns = await handleTurn();
for (const turn of turns) {
if (turn.text) {
console.debug('Received text: %s\n', turn.text);
}
else if (turn.data) {
console.debug('Received inline data: %s\n', turn.data);
}
}
session.close();
}
async function main() {
await live().catch((e) => console.error('got error', e));
}
main();
Me send_realtime_input , API do t'i përgjigjet audios automatikisht bazuar në VAD. Ndërsa send_client_content shton mesazhe në kontekstin e modelit sipas radhës, send_realtime_input është optimizuar për reagim në kurriz të renditjes deterministike.
Konfigurimi automatik i VAD-it
Për më shumë kontroll mbi aktivitetin VAD, mund të konfiguroni parametrat e mëposhtëm. Shihni referencën API për më shumë informacion.
Python
from google.genai import types
config = {
"response_modalities": ["AUDIO"],
"realtime_input_config": {
"automatic_activity_detection": {
"disabled": False, # default
"start_of_speech_sensitivity": types.StartSensitivity.START_SENSITIVITY_LOW,
"end_of_speech_sensitivity": types.EndSensitivity.END_SENSITIVITY_LOW,
"prefix_padding_ms": 20,
"silence_duration_ms": 100,
}
}
}
JavaScript
import { GoogleGenAI, Modality, StartSensitivity, EndSensitivity } from '@google/genai';
const config = {
responseModalities: [Modality.AUDIO],
realtimeInputConfig: {
automaticActivityDetection: {
disabled: false, // default
startOfSpeechSensitivity: StartSensitivity.START_SENSITIVITY_LOW,
endOfSpeechSensitivity: EndSensitivity.END_SENSITIVITY_LOW,
prefixPaddingMs: 20,
silenceDurationMs: 100,
}
}
};
Çaktivizo VAD-in automatik
Si alternativë, VAD automatik mund të çaktivizohet duke vendosur realtimeInputConfig.automaticActivityDetection.disabled në true në mesazhin e konfigurimit. Në këtë konfigurim, klienti është përgjegjës për zbulimin e të folurit të përdoruesit dhe dërgimin e mesazheve activityStart dhe activityEnd në kohën e duhur. Një audioStreamEnd nuk dërgohet në këtë konfigurim. Në vend të kësaj, çdo ndërprerje e transmetimit shënohet nga një mesazh activityEnd .
Python
config = {
"response_modalities": ["AUDIO"],
"realtime_input_config": {"automatic_activity_detection": {"disabled": True}},
}
async with client.aio.live.connect(model=model, config=config) as session:
# ...
await session.send_realtime_input(activity_start=types.ActivityStart())
await session.send_realtime_input(
audio=types.Blob(data=audio_bytes, mime_type="audio/pcm;rate=16000")
)
await session.send_realtime_input(activity_end=types.ActivityEnd())
# ...
JavaScript
const config = {
responseModalities: [Modality.AUDIO],
realtimeInputConfig: {
automaticActivityDetection: {
disabled: true,
}
}
};
session.sendRealtimeInput({ activityStart: {} })
session.sendRealtimeInput(
{
audio: {
data: base64Audio,
mimeType: "audio/pcm;rate=16000"
}
}
);
session.sendRealtimeInput({ activityEnd: {} })
Numri i tokenëve
Mund ta gjeni numrin total të tokenëve të konsumuar në fushën usageMetadata të mesazhit të kthyer të serverit.
Python
async for message in session.receive():
# The server will periodically send messages that include UsageMetadata.
if message.usage_metadata:
usage = message.usage_metadata
print(
f"Used {usage.total_token_count} tokens in total. Response token breakdown:"
)
for detail in usage.response_tokens_details:
match detail:
case types.ModalityTokenCount(modality=modality, token_count=count):
print(f"{modality}: {count}")
JavaScript
const turns = await handleTurn();
for (const turn of turns) {
if (turn.usageMetadata) {
console.debug('Used %s tokens in total. Response token breakdown:\n', turn.usageMetadata.totalTokenCount);
for (const detail of turn.usageMetadata.responseTokensDetails) {
console.debug('%s\n', detail);
}
}
}
Rezolucioni i medias
Mund të specifikoni rezolucionin e medias për median hyrëse duke vendosur fushën mediaResolution si pjesë të konfigurimit të sesionit:
Python
from google.genai import types
config = {
"response_modalities": ["AUDIO"],
"media_resolution": types.MediaResolution.MEDIA_RESOLUTION_LOW,
}
JavaScript
import { GoogleGenAI, Modality, MediaResolution } from '@google/genai';
const config = {
responseModalities: [Modality.AUDIO],
mediaResolution: MediaResolution.MEDIA_RESOLUTION_LOW,
};
Kufizime
Merrni parasysh kufizimet e mëposhtme të Live API kur planifikoni projektin tuaj.
Modalitetet e reagimit
Modelet audio vendase mbështesin vetëm modalitetin e përgjigjes `AUDIO. Nëse ju nevojitet përgjigja e modelit si tekst, përdorni veçorinë e transkriptimit të audios së daljes .
Autentifikimi i klientit
API-ja Live ofron vetëm autentifikim server-me-server si parazgjedhje. Nëse po e implementoni aplikacionin tuaj Live API duke përdorur një qasje klient-me-server , duhet të përdorni tokena kalimtarë për të zbutur rreziqet e sigurisë.
Kohëzgjatja e seancës
Sesionet vetëm me audio janë të kufizuara në 15 minuta, dhe sesionet me audio plus video janë të kufizuara në 2 minuta. Megjithatë, mund të konfiguroni teknika të ndryshme të menaxhimit të sesionit për zgjatje të pakufizuara të kohëzgjatjes së sesionit.
Dritarja e kontekstit
Një seancë ka një limit të dritares së kontekstit prej:
- 128 mijë tokena për modelet e daljes audio vendase
- 32 mijë tokena për modele të tjera të API-t Live
Gjuhët e mbështetura
Live API mbështet 70 gjuhët e mëposhtme.
| Gjuha | Kodi BCP-47 | Gjuha | Kodi BCP-47 |
|---|---|---|---|
| Afrikanisht | af | Kannada | kn |
| shqip | sq | Kazake | kk |
| Amarike | am | Khmer | km |
| Arabisht | ar | Koreane | ko |
| armenisht | hy | Lao | lo |
| Asamezisht | as | letonisht | lv |
| Azerbajxhanisht | az | lituanisht | lt |
| bask | eu | maqedonase | mk |
| Bjellorusisht | be | Malajisht | ms |
| Bengalisht | bn | Malajalamisht | ml |
| boshnjak | bs | Marathi | mr |
| bullgar | bg | mongolisht | mn |
| Katalanisht | ca | Nepalisht | ne |
| kinez | zh | Norvegjisht | no |
| Kroatisht | hr | Odia | or |
| Çeke | cs | polak | pl |
| danez | da | portugalisht | pt |
| holandez | nl | Punjabi | pa |
| Anglisht | en | rumanisht | ro |
| Estonisht | et | ruse | ru |
| Filipinase | fil | serbisht | sr |
| finlandez | fi | Sllovakisht | sk |
| frëngjisht | fr | sllovenisht | sl |
| galike | gl | Spanjisht | es |
| gjeorgjian | ka | Suahili | sw |
| gjermanisht | de | suedeze | sv |
| grek | el | Tamil | ta |
| Guxharatisht | gu | Teluguisht | te |
| Hebraisht | iw | Tajlandeze | th |
| Hindisht | hi | turk | tr |
| hungareze | hu | ukrainas | uk |
| Islandeze | is | Urdu | ur |
| Indonezisht | id | Uzbekisht | uz |
| italiane | it | Vietnamez | vi |
| Japonez | ja | Zulu | zu |
Çfarë vjen më pas
- Lexoni udhëzuesit e Përdorimit të Mjeteve dhe Menaxhimit të Sesioneve për informacion thelbësor mbi përdorimin efektiv të Live API.
- Provo API-n Live në Google AI Studio .
- Për më shumë informacion rreth modeleve Live API, shihni Gemini 2.5 Flash Native Audio në faqen e Modeleve.
- Provoni më shumë shembuj në librin e gatimit Live API , librin e gatimit Live API Tools dhe skriptin Live API Get Started .