API Live

L'API Live permet des interactions vocales et vidéo bidirectionnelles à faible latence avec Gemini. Utilisez l'API Live pour proposer aux utilisateurs finaux des conversations vocales naturelles et leur permettre d'interrompre les réponses du modèle à l'aide de commandes vocales.

Ce document aborde les principes de base de l'utilisation de l'API Live, y compris ses fonctionnalités, des exemples pour commencer et des exemples de code de cas d'utilisation de base. Si vous souhaitez savoir comment démarrer une conversation interactive à l'aide de l'API Live, consultez Conversations interactives avec l'API Live. Si vous recherchez des informations sur les outils que l'API Live peut utiliser, consultez Outils intégrés.

Modèles compatibles

L'API Live est compatible avec le SDK Google Gen AI et Vertex AI Studio. Certaines fonctionnalités (comme l'entrée et la sortie de texte) ne sont disponibles qu'avec le SDK Gen AI.

Vous pouvez utiliser l'API Live avec les modèles suivants :

Version de modèle Niveau de disponibilité
gemini-live-2.5-flash DG privée*
gemini-live-2.5-flash-preview-native-audio Version Preview publique

* Contactez le représentant de l'équipe chargée de votre compte Google pour demander l'accès.

Pour en savoir plus, y compris sur les spécifications techniques et les limites, consultez le guide de référence de l'API Live.

Exemples de déclencheurs

Pour commencer à utiliser l'API Live, vous pouvez vous appuyer sur l'un de nos exemples :

Notebooks Jupyter :

Applications et guides de démonstration :

Fonctionnalités de l'API Live

  • Compréhension multimodale en temps réel : discutez avec Gemini de ce qu'il voit dans un flux vidéo ou via le partage d'écran, grâce à la prise en charge intégrée du streaming audio et vidéo.
  • Utilisation d'outils intégrés : intégrez facilement des outils tels que l'appel de fonction et l' ancrage avec la recherche Google dans vos conversations pour des interactions plus pratiques et dynamiques.
  • Interactions à faible latence : profitez d'interactions à faible latence et semblables à des dialogues humains avec Gemini.
  • Compatibilité multilingue : discutez dans l'une des 24 langues disponibles.
  • (Versions en disponibilité générale uniquement) Compatibilité avec le débit provisionné : utilisez un abonnement à coût fixe et à durée fixe disponible en plusieurs durées, qui réserve du débit pour les modèles d'IA générative compatibles sur Vertex AI, y compris l'API Live.

Gemini 2.5 Flash avec l'API Live inclut également l'audio natif en version Preview publique. Voici les nouveautés de l'audio natif :

  • Dialogues affectifs : l'API Live comprend le ton de voix de l'utilisateur et y répond. Les mêmes mots prononcés de différentes manières peuvent donner lieu à des conversations très différentes et plus nuancées.
  • Audio proactif et conscience du contexte : l'API Live ignore intelligemment les conversations ambiantes et les autres sons non pertinents, et sait quand écouter et quand rester silencieuse.

Pour en savoir plus sur l'audio natif, consultez Outils intégrés.

Formats audio acceptés

L'API Live est compatible avec les formats audio suivants :

  • Audio d'entrée : audio PCM 16 bits brut à 16 kHz, little-endian
  • Sortie audio : audio PCM 16 bits brut à 24 kHz, little-endian

Obtenir des réponses textuelles à partir d'une entrée audio

Vous pouvez envoyer des fichiers audio et recevoir des réponses textuelles en convertissant l'audio au format PCM 16 bits, 16 kHz, mono. L'exemple suivant lit un fichier WAV et l'envoie au format approprié :

Python

# Test file: https://storage.googleapis.com/generativeai-downloads/data/16000.wav
# Install helpers for converting files: pip install librosa soundfile

import asyncio
import io
from pathlib import Path
from google import genai
from google.genai import types
import soundfile as sf
import librosa

client = genai.Client(
    vertexai=True,
    project=GOOGLE_CLOUD_PROJECT,
    location=GOOGLE_CLOUD_LOCATION,
)
model = "gemini-live-2.5-flash"
config = {"response_modalities": ["TEXT"]}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:

        buffer = io.BytesIO()
        y, sr = librosa.load("sample.wav", sr=16000)
        sf.write(buffer, y, sr, format="RAW", subtype="PCM_16")
        buffer.seek(0)
        audio_bytes = buffer.read()

        # If already in correct format, you can use this:
        # audio_bytes = Path("sample.pcm").read_bytes()

        await session.send_realtime_input(
            audio=types.Blob(data=audio_bytes, mime_type="audio/pcm;rate=16000")
        )

        async for response in session.receive():
            if response.text is not None:
                print(response.text)

if __name__ == "__main__":
    asyncio.run(main())

Obtenir des réponses vocales à partir d'une entrée de texte

Utilisez cet exemple pour envoyer une entrée de texte et recevoir des réponses vocales synthétisées :

Python

import asyncio
import numpy as np
from IPython.display import Audio, Markdown, display
from google import genai
from google.genai.types import (
  Content,
  LiveConnectConfig,
  HttpOptions,
  Modality,
  Part,
  SpeechConfig,
  VoiceConfig,
  PrebuiltVoiceConfig,
)

client = genai.Client(
  vertexai=True,
  project=GOOGLE_CLOUD_PROJECT,
  location=GOOGLE_CLOUD_LOCATION,
)

voice_name = "Aoede"

config = LiveConnectConfig(
  response_modalities=["AUDIO"],
  speech_config=SpeechConfig(
      voice_config=VoiceConfig(
          prebuilt_voice_config=PrebuiltVoiceConfig(
              voice_name=voice_name,
          )
      ),
  ),
)

async with client.aio.live.connect(
  model="gemini-live-2.5-flash",
  config=config,
) as session:
  text_input = "Hello? Gemini are you there?"
  display(Markdown(f"**Input:** {text_input}"))

  await session.send_client_content(
      turns=Content(role="user", parts=[Part(text=text_input)]))

  audio_data = []
  async for message in session.receive():
      if (
          message.server_content.model_turn
          and message.server_content.model_turn.parts
      ):
          for part in message.server_content.model_turn.parts:
              if part.inline_data:
                  audio_data.append(
                      np.frombuffer(part.inline_data.data, dtype=np.int16)
                  )

  if audio_data:
      display(Audio(np.concatenate(audio_data), rate=24000, autoplay=True))

Pour obtenir d'autres exemples d'envoi de texte, consultez notre guide de démarrage.

Transcrire l'audio

L'API Live peut transcrire à la fois l'audio d'entrée et de sortie. Utilisez l'exemple suivant pour activer la transcription :

Python

import asyncio
from google import genai
from google.genai import types

client = genai.Client(
    vertexai=True,
    project=GOOGLE_CLOUD_PROJECT,
    location=GOOGLE_CLOUD_LOCATION,
)
model = "gemini-live-2.5-flash"

config = {
    "response_modalities": ["AUDIO"],
    "input_audio_transcription": {},
    "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.input_transcription:
                print("Input transcript:", response.server_content.input_transcription.text)
            if response.server_content.output_transcription:
                print("Output transcript:", response.server_content.output_transcription.text)

if __name__ == "__main__":
    asyncio.run(main())

WebSockets

# Set model generation_config
CONFIG = {
    'response_modalities': ['AUDIO'],
}

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {bearer_token[0]}",
}

# Connect to the server
async with connect(SERVICE_URL, additional_headers=headers) as ws:
    # Setup the session
    await ws.send(
        json.dumps(
            {
                "setup": {
                    "model": "gemini-2.0-flash-live-preview-04-09",
                    "generation_config": CONFIG,
                    'input_audio_transcription': {},
                    'output_audio_transcription': {}
                }
            }
        )
    )

    # Receive setup response
    raw_response = await ws.recv(decode=False)
    setup_response = json.loads(raw_response.decode("ascii"))

    # Send text message
    text_input = "Hello? Gemini are you there?"
    display(Markdown(f"**Input:** {text_input}"))

    msg = {
        "client_content": {
            "turns": [{"role": "user", "parts": [{"text": text_input}]}],
            "turn_complete": True,
        }
    }

    await ws.send(json.dumps(msg))

    responses = []
    input_transcriptions = []
    output_transcriptions = []

    # Receive chucks of server response
    async for raw_response in ws:
        response = json.loads(raw_response.decode())
        server_content = response.pop("serverContent", None)
        if server_content is None:
            break

        if (input_transcription := server_content.get("inputTranscription")) is not None:
            if (text := input_transcription.get("text")) is not None:
                input_transcriptions.append(text)
        if (output_transcription := server_content.get("outputTranscription")) is not None:
            if (text := output_transcription.get("text")) is not None:
                output_transcriptions.append(text)

        model_turn = server_content.pop("modelTurn", None)
        if model_turn is not None:
            parts = model_turn.pop("parts", None)
            if parts is not None:
                for part in parts:
                    pcm_data = base64.b64decode(part["inlineData"]["data"])
                    responses.append(np.frombuffer(pcm_data, dtype=np.int16))

        # End of turn
        turn_complete = server_content.pop("turnComplete", None)
        if turn_complete:
            break

    if input_transcriptions:
        display(Markdown(f"**Input transcription >** {''.join(input_transcriptions)}"))

    if responses:
        # Play the returned audio message
        display(Audio(np.concatenate(responses), rate=24000, autoplay=True))

    if output_transcriptions:
        display(Markdown(f"**Output transcription >** {''.join(output_transcriptions)}"))

En savoir plus

Pour en savoir plus sur l'utilisation de l'API Live, consultez les ressources suivantes :