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-09-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-09-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.
Dërgimi dhe marrja e audios
Shembulli më i zakonshëm i audios, audio-në-audio , trajtohet në udhëzuesin "Si të fillojmë" .
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 dërguar mesazh
Ja se si mund të dërgoni tekst:
Python
message = "Hello, how are you?"
await session.send_client_content(turns=message, turn_complete=True)
JavaScript
const message = 'Hello, how are you?';
session.sendClientContent({ turns: message, turnComplete: true });
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-09-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-09-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-09-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-09-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();
Transmeto audio dhe video
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-09-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-09-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-09-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-09-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-09-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-live-2.5-flash-preview"
config = {"response_modalities": ["TEXT"]}
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.TEXT] };
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": ["TEXT"],
"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.TEXT],
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": ["TEXT"],
"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.TEXT],
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.TEXT],
mediaResolution: MediaResolution.MEDIA_RESOLUTION_LOW,
};
Kufizime
Merrni parasysh kufizimet e mëposhtme të Live API kur planifikoni projektin tuaj.
Modalitetet e reagimit
Mund të caktoni vetëm një modalitet përgjigjeje ( TEXT ose AUDIO ) për seancë në konfigurimin e seancës. Vendosja e të dyve rezulton në një mesazh gabimi konfigurimi. Kjo do të thotë që mund ta konfiguroni modelin që të përgjigjet me tekst ose audio, por jo me të dyja në të njëjtën seancë.
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 gjuhët e mëposhtme.
| Gjuha | Kodi BCP-47 | Gjuha | Kodi BCP-47 |
|---|---|---|---|
| Gjermanisht (Gjermani) | de-DE | Anglisht (Australi)* | en-AU |
| Anglisht (MB)* | en-GB | Anglisht (India) | en-IN |
| Anglisht (SHBA) | en-US | Spanjisht (SHBA) | es-US |
| Frëngjisht (Francë) | fr-FR | Hindisht (Indi) | hi-IN |
| Portugalisht (Brazil) | pt-BR | Arabisht (Gjenerike) | ar-XA |
| Spanjisht (Spanjë)* | es-ES | Frëngjisht (Kanada)* | fr-CA |
| Indonezisht (Indonezi) | id-ID | Italisht (Itali) | it-IT |
| Japoneze (Japoni) | ja-JP | Turqisht (Turqi) | tr-TR |
| Vietnamisht (Vietnam) | vi-VN | Bengalisht (Indi) | bn-IN |
| Guxharatisht (India)* | gu-IN | Kannada (India)* | kn-IN |
| Marathi (Indi) | mr-IN | Malajalamisht (India)* | ml-IN |
| Tamilisht (India) | ta-IN | Teluguisht (Indi) | te-IN |
| holandisht (Holandë) | nl-NL | Koreane (Koreja e Jugut) | ko-KR |
| Mandarinisht Kinezisht (Kinë)* | cmn-CN | Polonisht (Poloni) | pl-PL |
| Rusisht (Rusia) | ru-RU | Tajlandisht (Tajlandë) | th-TH |
Gjuhët e shënuara me një yll (*) nuk janë të disponueshme për audion vendase .
Ç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 .