Essayez le nouveau modèle audio-audio Gemini 3.1 Flash Live dans AI Studio.

Live API capabilities guide

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 y découvrirez 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.

Comparaison de modèles

Le tableau suivant récapitule les principales différences entre les modèles Aperçu en direct de Gemini 3.1 Flash et Aperçu en direct de Gemini 2.5 Flash :

Fonctionnalité	Aperçu en direct de Gemini 3.1 Flash	Aperçu en direct de Gemini 2.5 Flash
Réflexion	Utilise `thinkingLevel` pour contrôler la profondeur de réflexion avec des paramètres tels que `minimal`, `low`, `medium` et `high`. La valeur par défaut est `minimal` pour optimiser la latence la plus faible. Consultez Niveaux de réflexion et budgets.	Utilise `thinkingBudget` pour définir le nombre de jetons de réflexion. La pensée dynamique est activée par défaut. Définissez `thinkingBudget` sur `0` pour désactiver la fonctionnalité. Consultez Niveaux de réflexion et budgets.
Recevoir une réponse	Un même événement serveur peut contenir plusieurs parties de contenu à la fois (par exemple, `inlineData` et la transcription). Assurez-vous que votre code traite toutes les parties de chaque événement pour ne manquer aucun contenu.	Chaque événement de serveur ne contient qu'une seule partie de contenu. Les pièces sont fournies dans des événements distincts.
Contenu client	`send_client_content` n'est compatible qu'avec l'amorçage de l'historique du contexte initial (nécessite de définir `initial_history_in_client_content` dans la configuration de la session). Pour envoyer des mises à jour textuelles pendant la conversation, utilisez plutôt `send_realtime_input`.	`send_client_content` est compatible tout au long de la conversation pour envoyer des mises à jour de contenu incrémentielles et établir le contexte.
Couverture	La valeur par défaut est `TURN_INCLUDES_AUDIO_ACTIVITY_AND_ALL_VIDEO`. Le tour du modèle inclut l'activité audio détectée et toutes les images vidéo.	La valeur par défaut est `TURN_INCLUDES_ONLY_ACTIVITY`. Le tour du modèle n'inclut que l'activité détectée.
VAD personnalisée (`activity_start`/`activity_end`)	Compatible. Désactivez la détection d'activité vocale automatique et envoyez manuellement les messages `activityStart` et `activityEnd` pour contrôler les limites des tours de parole.	Compatible. Désactivez la détection d'activité vocale automatique et envoyez manuellement les messages `activityStart` et `activityEnd` pour contrôler les limites des tours de parole.
Configuration automatique de la VAD	Compatible. Configurez des paramètres tels que `start_of_speech_sensitivity`, `end_of_speech_sensitivity`, `prefix_padding_ms` et `silence_duration_ms`.	Compatible. Configurez des paramètres tels que `start_of_speech_sensitivity`, `end_of_speech_sensitivity`, `prefix_padding_ms` et `silence_duration_ms`.
Appel de fonction asynchrone (`behavior: NON_BLOCKING`)	Non compatible L'appel de fonction est séquentiel uniquement. Le modèle ne commencera à répondre que lorsque vous aurez envoyé la réponse de l'outil.	Compatible. Définissez `behavior` sur `NON_BLOCKING` dans une déclaration de fonction pour permettre au modèle de continuer à interagir pendant l'exécution de la fonction. Contrôlez la façon dont le modèle gère les réponses avec le paramètre `scheduling` (`INTERRUPT`, `WHEN_IDLE` ou `SILENT`).
Audio proactif	Not supported	Compatible. Lorsque ce paramètre est activé, le modèle peut décider de ne pas répondre de manière proactive si le contenu saisi n'est pas pertinent. Définissez `proactive_audio` sur `true` dans la configuration `proactivity` (nécessite `v1alpha`).
Dialogue affectif	Not supported	Compatible. Le modèle adapte son style de réponse en fonction de l'expression et du ton de l'entrée. Définissez `enable_affective_dialog` sur `true` dans la configuration de session (nécessite `v1alpha`).

Pour migrer de Gemini 2.5 Flash Live vers Gemini 3.1 Flash Live, consultez le guide de migration.

É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-3.1-flash-live-preview"
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-3.1-flash-live-preview';
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.

Envoi de l'audio

L'audio doit être envoyé sous forme de données PCM brutes (audio PCM 16 bits brut, 16 kHz, 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'
  }
});

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'entrée audio est nativement à 16 kHz, mais l'API Live rééchantillonne si nécessaire, de sorte que n'importe quel taux d'échantillonnage peut être envoyé. 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.

Réception de l'audio

Les réponses audio du modèle sont reçues sous forme de blocs de données.

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

Envoi d'un SMS…

Le texte peut être envoyé à l'aide de send_realtime_input (Python) ou sendRealtimeInput (JavaScript).

Python

await session.send_realtime_input(text="Hello, how are you?")

JavaScript

session.sendRealtimeInput({
  text: 'Hello, how are you?'
});

Envoi de la vidéo…

Les images vidéo sont envoyées individuellement (par exemple, au format JPEG ou PNG) à une fréquence d'images spécifique (une image par seconde maximum).

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

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-3.1-flash-live-preview"

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-3.1-flash-live-preview';

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-3.1-flash-live-preview"

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-3.1-flash-live-preview';

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

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.

Raisonnement

Les modèles Gemini 3.1 utilisent thinkingLevel pour contrôler la profondeur de réflexion, avec des paramètres tels que minimal, low, medium et high. La valeur par défaut est minimal pour optimiser la latence la plus faible. Les modèles Gemini 2.5 utilisent thinkingBudget pour définir le nombre de jetons de réflexion. Pour en savoir plus sur les niveaux et les budgets, consultez Niveaux et budgets.

Python

model = "gemini-3.1-flash-live-preview"

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"]
    thinking_config=types.ThinkingConfig(
        thinking_level="low",
    )
)

async with client.aio.live.connect(model=model, config=config) as session:
    # Send audio input and receive audio

JavaScript

const model = 'gemini-3.1-flash-live-preview';
const config = {
  responseModalities: [Modality.AUDIO],
  thinkingConfig: {
    thinkingLevel: 'low',
  },
};

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-3.1-flash-live-preview"

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"]
    thinking_config=types.ThinkingConfig(
        thinking_level="low",
        include_thoughts=True
    )
)

JavaScript

const model = 'gemini-3.1-flash-live-preview';
const config = {
  responseModalities: [Modality.AUDIO],
  thinkingConfig: {
    thinkingLevel: 'low',
    includeThoughts: true,
  },
};

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 }
}

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-3.1-flash-live-preview"

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-3.1-flash-live-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();

Avec send_realtime_input, l'API répondra automatiquement à l'audio en fonction de la VAD. 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": ["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,
    }
  }
};

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": ["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: {} })

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.AUDIO],
    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

Les modèles audio natifs n'acceptent que la modalité de réponse `AUDIO. Si vous avez besoin de la réponse du modèle sous forme de texte, utilisez la fonctionnalité Transcription audio de sortie.

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 97 langues suivantes.

Langue	Code BCP-47	Langue	Code BCP-47
Afrikaans	`af`	Letton	`lv`
Akan	`ak`	Lituanien	`lt`
Albanais	`sq`	Macédonien	`mk`
Amharique	`am`	Malaisien	`ms`
Arabe	`ar`	Malayalam	`ml`
Arménien	`hy`	Maltais	`mt`
Assamais	`as`	Maori	`mi`
Azéri	`az`	Marathi	`mr`
Basque	`eu`	Mongol	`mn`
Biélorusse	`be`	Népalais	`ne`
Bengali	`bn`	Norvégien	`no`
Bosniaque	`bs`	Odia	`or`
Bulgare	`bg`	Oromo	`om`
Birman	`my`	Pachtô	`ps`
Catalan	`ca`	Persan	`fa`
Cebuano	`ceb`	Polonais	`pl`
Chinois	`zh`	Portugais	`pt`
Croate	`hr`	Panjabi	`pa`
Tchèque	`cs`	Quechua	`qu`
Danois	`da`	Roumain	`ro`
Néerlandais	`nl`	Romanche	`rm`
Anglais	`en`	Russe	`ru`
Estonien	`et`	Serbe	`sr`
Féroïen	`fo`	Sindhî	`sd`
Tagalog	`fil`	Cingalais	`si`
Finnois	`fi`	Slovaque	`sk`
Français	`fr`	Slovène	`sl`
Galicien	`gl`	Somali	`so`
Géorgien	`ka`	Sotho du Sud	`st`
Allemand	`de`	Espagnol	`es`
Grec	`el`	Swahili	`sw`
Gujarati	`gu`	Suédois	`sv`
Haoussa	`ha`	Tadjik	`tg`
Hébreu	`iw`	Tamoul	`ta`
Hindi	`hi`	Télougou	`te`
Hongrois	`hu`	Thaï	`th`
Islandais	`is`	Tswana	`tn`
Indonésien	`id`	Turc	`tr`
Irlandais	`ga`	Turkmène	`tk`
Italien	`it`	Ukrainien	`uk`
Japonais	`ja`	Urdu	`ur`
Kannada	`kn`	Ouzbek	`uz`
Kazakh	`kk`	Vietnamien	`vi`
Khmer	`km`	Gallois	`cy`
Kinyarwanda	`rw`	Frison occidental	`fy`
Coréen	`ko`	Wolof	`wo`
Kurde	`ku`	Yoruba	`yo`
Kirghiz	`ky`	Zoulou	`zu`
Laotien	`lo`

É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.