Ce guide complet présente les fonctionnalités et les configurations disponibles avec l'API Live. Consultez la page Premiers pas avec l'API Live pour obtenir une présentation et des exemples de code pour les cas d'utilisation courants.
Avant de commencer
- Familiarisez-vous avec les concepts de base : si vous ne l'avez pas encore fait, commencez par lire la page Premiers pas avec l'API Live . Vous allez découvrir les principes fondamentaux de l'API Live, son fonctionnement et les différentes approches d'implémentation.
- Essayez l'API Live dans AI Studio : il peut être utile d'essayer l'API Live dans Google AI Studio avant de commencer à développer. Pour utiliser l'API Live dans Google AI Studio, sélectionnez Stream.
Établir une connexion
L'exemple suivant montre comment créer une connexion avec une clé 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();
Modalités d'interaction
Les sections suivantes fournissent des exemples et un contexte pour les différentes modalités d'entrée et de sortie disponibles dans l'API Live.
Envoyer et recevoir des messages audio
L'exemple audio le plus courant, audio vers audio, est abordé dans le guide Premiers pas.
Formats audio
Les données audio de l'API Live sont toujours brutes, little-endian et PCM 16 bits. La sortie audio utilise toujours un taux d'échantillonnage de 24 kHz. L'audio d'entrée est nativement à 16 kHz, mais l'API Live le rééchantillonne si nécessaire. Vous pouvez donc envoyer n'importe quel taux d'échantillonnage. Pour indiquer la fréquence d'échantillonnage de l'entrée audio, définissez le type MIME de chaque Blob contenant de l'audio sur une valeur telle que audio/pcm;rate=16000.
Envoi d'un SMS…
Voici comment envoyer du texte :
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 });
Mises à jour incrémentielles du contenu
Utilisez des mises à jour incrémentielles pour envoyer une entrée textuelle, ou établir ou restaurer le contexte de la session. Pour les contextes courts, vous pouvez envoyer des interactions au fur et à mesure pour représenter la séquence exacte des événements :
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 })
Pour les contextes plus longs, il est recommandé de fournir un seul résumé des messages afin de libérer la fenêtre de contexte pour les interactions ultérieures. Consultez la section Reprise de session pour découvrir une autre méthode de chargement du contexte de session.
Transcriptions audio
En plus de la réponse du modèle, vous pouvez également recevoir les transcriptions de la sortie audio et de l'entrée audio.
Pour activer la transcription de la sortie audio du modèle, envoyez output_audio_transcription dans la configuration. La langue de transcription est déduite de la réponse du modèle.
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();
Pour activer la transcription de l'entrée audio du modèle, envoyez input_audio_transcription dans la configuration.
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();
Diffuser du contenu audio et vidéo en streaming
Modifier la voix et la langue
Les modèles Native audio output sont compatibles avec toutes les voix disponibles pour nos modèles Text-to-Speech (TTS). Vous pouvez écouter toutes les voix dans AI Studio.
Pour spécifier une voix, définissez son nom dans l'objet speechConfig lors de la configuration de la session :
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" } } }
};
L'API Live est compatible avec plusieurs langues. Les modèles Native audio output (Sortie audio native) choisissent automatiquement la langue appropriée et ne permettent pas de définir explicitement le code de langue.
Fonctionnalités audio natives
Nos derniers modèles sont dotés d'une sortie audio native, qui offre une voix naturelle et réaliste, et améliore les performances multilingues. L'audio natif permet également d'utiliser des fonctionnalités avancées telles que le dialogue affectif (sensible aux émotions), l'audio proactif (où le modèle décide intelligemment quand répondre à une entrée) et la "réflexion".
Dialogue affectif
Cette fonctionnalité permet à Gemini d'adapter son style de réponse en fonction de l'expression et du ton de l'entrée.
Pour utiliser le dialogue affectif, définissez la version de l'API sur v1alpha et définissez enable_affective_dialog sur true dans le message de configuration :
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 proactif
Lorsque cette fonctionnalité est activée, Gemini peut décider de ne pas répondre de manière proactive si le contenu n'est pas pertinent.
Pour l'utiliser, définissez la version de l'API sur v1alpha, configurez le champ proactivity dans le message de configuration et définissez proactive_audio sur 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 }
}
Réflexion…
Le dernier modèle de sortie audio natif gemini-2.5-flash-native-audio-preview-09-2025 est compatible avec les capacités de réflexion, avec la réflexion dynamique activée par défaut.
Le paramètre thinkingBudget fournit au modèle des indications sur le nombre de jetons de réflexion qu'il peut utiliser pour générer une réponse. Vous pouvez désactiver la réflexion en définissant thinkingBudget sur 0. Pour en savoir plus sur les détails de la configuration thinkingBudget du modèle, consultez la documentation sur les budgets de réflexion.
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();
Vous pouvez également activer les résumés de réflexion en définissant includeThoughts sur true dans votre configuration. Pour en savoir plus, consultez Résumés de la pensée :
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,
},
};
Détection de l'activité vocale (VAD)
La détection de l'activité vocale (VAD) permet au modèle de reconnaître quand une personne parle. C'est essentiel pour créer des conversations naturelles, car cela permet à un utilisateur d'interrompre le modèle à tout moment.
Lorsque la VAD détecte une interruption, la génération en cours est annulée et supprimée. Seules les informations déjà envoyées au client sont conservées dans l'historique de la session. Le serveur envoie ensuite un message BidiGenerateContentServerContent pour signaler l'interruption.
Le serveur Gemini supprime ensuite tous les appels de fonction en attente et envoie un message BidiGenerateContentServerContent avec les ID des appels annulés.
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 automatique
Par défaut, le modèle effectue automatiquement la détection d'activité vocale (VAD) sur un flux d'entrée audio continu. La VAD peut être configurée avec le champ realtimeInputConfig.automaticActivityDetection de la configuration.
Lorsque le flux audio est mis en pause pendant plus d'une seconde (par exemple, parce que l'utilisateur a désactivé le micro), un événement audioStreamEnd doit être envoyé pour vider l'audio mis en cache. Le client peut reprendre l'envoi des données audio à tout moment.
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();
Avec send_realtime_input, l'API répond automatiquement à l'audio en fonction de la détection d'activité vocale. Alors que send_client_content ajoute des messages au contexte du modèle dans l'ordre, send_realtime_input est optimisé pour la réactivité au détriment de l'ordre déterministe.
Configuration automatique de la VAD
Pour mieux contrôler l'activité VAD, vous pouvez configurer les paramètres suivants. Pour en savoir plus, consultez la documentation de référence de l'API.
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,
}
}
};
Désactiver la détection automatique d'activité vocale
Vous pouvez également désactiver la VAD automatique en définissant realtimeInputConfig.automaticActivityDetection.disabled sur true dans le message de configuration. Dans cette configuration, le client est chargé de détecter la parole de l'utilisateur et d'envoyer les messages activityStart et activityEnd au moment opportun. Un audioStreamEnd n'est pas envoyé dans cette configuration. Au lieu de cela, toute interruption du flux est marquée par un message 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: {} })
Nombre de jetons
Vous trouverez le nombre total de jetons consommés dans le champ usageMetadata du message serveur renvoyé.
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);
}
}
}
Résolution du contenu multimédia
Vous pouvez spécifier la résolution du contenu multimédia d'entrée en définissant le champ mediaResolution dans la configuration de la session :
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,
};
Limites
Tenez compte des limites suivantes de l'API Live lorsque vous planifiez votre projet.
Modalités de réponse
Vous ne pouvez définir qu'une seule modalité de réponse (TEXT ou AUDIO) par session dans la configuration de la session. Si vous définissez les deux, un message d'erreur de configuration s'affiche. Cela signifie que vous pouvez configurer le modèle pour qu'il réponde avec du texte ou de l'audio, mais pas les deux dans la même session.
Authentification client
L'API Live ne fournit qu'une authentification de serveur à serveur par défaut. Si vous implémentez votre application API Live à l'aide d'une approche client-serveur, vous devez utiliser des jetons éphémères pour atténuer les risques de sécurité.
Durée de la session
Les sessions audio uniquement sont limitées à 15 minutes, et les sessions audio et vidéo sont limitées à 2 minutes. Toutefois, vous pouvez configurer différentes techniques de gestion des sessions pour étendre la durée des sessions de manière illimitée.
Fenêtre de contexte
La limite de la fenêtre de contexte d'une session est la suivante :
- 128 000 jetons pour les modèles de sortie audio native
- 32 000 jetons pour les autres modèles de l'API Live
Langues disponibles
L'API Live est compatible avec les langues suivantes.
| Langue | Code BCP-47 | Langue | Code BCP-47 |
|---|---|---|---|
| Allemand (Allemagne) | de-DE |
Anglais (Australie)* | en-AU |
| Anglais (Royaume-Uni)* | en-GB |
Anglais (Inde) | en-IN |
| Anglais (États-Unis) | en-US |
Espagnol (États-Unis) | es-US |
| Français (France) | fr-FR |
Hindi (Inde) | hi-IN |
| Portugais (Brésil) | pt-BR |
Arabe (générique) | ar-XA |
| Espagnol (Espagne)* | es-ES |
Français (Canada)* | fr-CA |
| Indonésien (Indonésie) | id-ID |
Italien (Italie) | it-IT |
| Japonais (Japon) | ja-JP |
Turc (Turquie) | tr-TR |
| Vietnamien (Viêt Nam) | vi-VN |
Bengali (Inde) | bn-IN |
| Gujarati (Inde)* | gu-IN |
Kannada (Inde)* | kn-IN |
| Marathi (Inde) | mr-IN |
Malayalam (Inde)* | ml-IN |
| Tamoul (Inde) | ta-IN |
Télougou (Inde) | te-IN |
| Néerlandais (Pays-Bas) | nl-NL |
Coréen (Corée du Sud) | ko-KR |
| Chinois mandarin (Chine)* | cmn-CN |
Polonais (Pologne) | pl-PL |
| Russe (Russie) | ru-RU |
Thaï (Thaïlande) | th-TH |
Les langues marquées d'un astérisque (*) ne sont pas disponibles pour l'audio natif.
Étape suivante
- Consultez les guides Utilisation des outils et Gestion des sessions pour obtenir des informations essentielles sur l'utilisation efficace de l'API Live.
- Essayez l'API Live dans Google AI Studio.
- Pour en savoir plus sur les modèles de l'API Live, consultez Gemini 2.5 Flash Native Audio sur la page "Modèles".
- Essayez d'autres exemples dans le livre de recettes de l'API Live, le livre de recettes des outils de l'API Live et le script de démarrage de l'API Live.