Multimodal Live API

L'API Multimodal Live permet des interactions vocales et vidéo bidirectionnelles à faible latence avec Gemini. L'API Multimodal Live vous permet de proposer aux utilisateurs finaux des conversations vocales naturelles, semblables à celles d'un être humain, et de leur permettre d'interrompre les réponses du modèle à l'aide de commandes vocales. Le modèle peut traiter des entrées textuelles, audio et vidéo, et peut fournir des sorties textuelles et audio.

Capacités

L'API Multimodal Live inclut les principales fonctionnalités suivantes:

• Multimodalité:le modèle peut voir, entendre et parler.
• Interaction en temps réel à faible latence:permet d'obtenir des réponses rapides.
• Mémoire de session:le modèle conserve la mémoire de toutes les interactions au cours d'une même session, en rappelant les informations entendues ou vues précédemment.
• Compatibilité avec l'appel de fonction, l'exécution de code et la recherche en tant qu'outil:permet l'intégration à des services et sources de données externes.
• Détection automatique de l'activité vocale (VAD) : le modèle peut reconnaître avec précision le moment où l'utilisateur commence et arrête de parler. Cela permet des interactions naturelles et conversationnelles, et permet aux utilisateurs d'interrompre le modèle à tout moment.

Vous pouvez essayer l'API Multimodal Live dans Google AI Studio.

Commencer

L'API Multimodal Live est une API avec état qui utilise des WebSockets.

Cette section montre comment utiliser l'API Multimodal Live pour la génération de texte à partir de texte, à l'aide de Python 3.9 ou version ultérieure.

Installer la bibliothèque de l'API Gemini

Pour installer le package google-genai, utilisez la commande pip suivante:

!pip3 install google-genai

Importer des dépendances

Pour importer des dépendances:

from google import genai

Envoyer et recevoir un SMS

import asyncio
from google import genai

client = genai.Client(api_key="GEMINI_API_KEY", http_options={'api_version': 'v1alpha'})
model_id = "gemini-2.0-flash-exp"
config = {"response_modalities": ["TEXT"]}

async def main():
    async with client.aio.live.connect(model=model_id, config=config) as session:
        while True:
            message = input("User> ")
            if message.lower() == "exit":
                break
            await session.send(message, end_of_turn=True)

            async for response in session.receive():
                if response.text is None:
                    continue
                print(response.text, end="")

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

Guide d'intégration

Cette section décrit le fonctionnement de l'intégration avec l'API Multimodal Live.

Sessions

Une session représente une seule connexion WebSocket entre le client et le serveur Gemini.

Une fois qu'un client a établi une nouvelle connexion, la session peut échanger des messages avec le serveur pour:

• Envoyer du texte, de l'audio ou de la vidéo au serveur Gemini
• Recevoir des réponses audio, textuelles ou d'appel de fonction du serveur Gemini

La configuration de la session est envoyée dans le premier message après la connexion. Une configuration de session comprend le modèle, les paramètres de génération, les instructions système et les outils.

Consultez l'exemple de configuration suivant:

{​​
  "model": string,
  "generation_config": {​
    "candidate_count": integer,
    "max_output_tokens": integer,
    "temperature": number,
    "top_p": number,
    "top_k": integer,
    "presence_penalty": number,
    "frequency_penalty": number,
    "response_modalities": string,
    "speech_config":object
  },

  "system_instruction": "",
  "tools":[]
}

Pour en savoir plus, consultez BidiGenerateContentSetup.

Envoyer des messages

Les messages sont des chaînes au format JSON échangées via la connexion WebSocket.

Pour envoyer un message, le client doit envoyer un message client compatible dans une chaîne au format JSON avec l'une des méthodes suivantes via une connexion WebSocket ouverte.

Messages client compatibles

Consultez les messages client acceptés dans le tableau suivant:

Recevoir des messages

Pour recevoir des messages de Gemini, écoutez l'événement "message" WebSocket, puis analysez le résultat conformément à la définition des messages de serveur compatibles.

Consultez les références suivantes :

ws.addEventListener("message", async (evt) => {
  if (evt.data instanceof Blob) {
    // Process the received data (audio, video, etc.)
  } else {
    // Process JSON response
  }
});

Messages de serveur compatibles

Consultez les messages de serveur compatibles dans le tableau suivant:

Mises à jour incrémentielles du contenu

Utilisez des mises à jour incrémentielles pour envoyer une saisie de texte, établir ou restaurer le contexte de session. Pour les contextes courts, vous pouvez envoyer des interactions par étape pour représenter la séquence exacte des événements. Pour les contextes plus longs, nous vous recommandons de fournir un seul résumé de message afin de libérer la fenêtre de contexte pour les interactions de suivi.

Consultez l'exemple de message de contexte suivant:

{
  "client_content": {
    "turns": [
      {
          "parts":[
          {
            "text": ""
          }
        ],
        "role":"user"
      },
      {
          "parts":[
          {
            "text": ""
          }
        ],
        "role":"model"
      }
    ],
    "turn_complete": true
  }
}

Notez que, bien que les parties de contenu puissent être de type functionResponse, BidiGenerateContentClientContent ne doit pas être utilisé pour fournir une réponse aux appels de fonction émis par le modèle. Utilisez BidiGenerateContentToolResponse à la place. BidiGenerateContentClientContent ne doit être utilisé que pour établir le contexte précédent ou fournir une entrée de texte à la conversation.

Streaming audio et vidéo

Appel de fonction

Toutes les fonctions doivent être déclarées au début de la session en envoyant des définitions d'outils dans le message BidiGenerateContentSetup.

Pour en savoir plus sur les appels de fonction, consultez le tutoriel sur les appels de fonction.

À partir d'une seule invite, le modèle peut générer plusieurs appels de fonction et le code nécessaire pour enchaîner leurs sorties. Ce code s'exécute dans un environnement bac à sable, générant des messages BidiGenerateContentToolCall ultérieurs. L'exécution est mise en pause jusqu'à ce que les résultats de chaque appel de fonction soient disponibles, ce qui garantit un traitement séquentiel.

Le client doit répondre avec BidiGenerateContentToolResponse.

Les entrées et les sorties audio ont un impact négatif sur la capacité du modèle à utiliser l'appel de fonction.

Formats audio

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

• Format audio d'entrée: audio PCM brut 16 bits à 16 kHz, little-endian
• Format audio de sortie: audio PCM brut 16 bits à 24 kHz, little-endian

Instructions système

Vous pouvez fournir des instructions système pour mieux contrôler la sortie du modèle et spécifier le ton et le sentiment des réponses audio.

Les instructions système sont ajoutées à l'invite avant le début de l'interaction et restent en vigueur pendant toute la session.

Les instructions système ne peuvent être définies qu'au début d'une session, immédiatement après la connexion initiale. Pour fournir d'autres informations au modèle pendant la session, utilisez des mises à jour de contenu incrémentielles.

Interruptions

Les utilisateurs peuvent interrompre la sortie du modèle à tout moment. Lorsque la détection d'activité vocale (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.

En outre, le serveur Gemini supprime tous les appels de fonction en attente et envoie un message BidiGenerateContentServerContent avec les ID des appels annulés.

Voix

L'API Multimodal Live est compatible avec les voix suivantes: Aoede, Charon, Fenrir, Kore et Puck.

Pour spécifier une voix, définissez voice_name dans l'objet speech_config, dans le cadre de la configuration de la session.

Consultez la représentation JSON suivante d'un objet speech_config:

{
  "voice_config": {
    "prebuilt_voice_config ": {
      "voice_name": <var>VOICE_NAME</var>
    }
  }
}

Limites

Tenez compte des limites suivantes de l'API Multimodal Live et de Gemini 2.0 lorsque vous planifiez votre projet.

Authentification client

L'API Multimodal Live ne fournit qu'une authentification de serveur à serveur et n'est pas recommandée pour une utilisation directe par le client. L'entrée client doit être acheminée via un serveur d'application intermédiaire pour une authentification sécurisée avec l'API Multimodal Live.

Pour les applications Web et mobiles, nous vous recommandons d'utiliser l'intégration de nos partenaires Daily.

Historique de la conversation

Bien que le modèle suive les interactions pendant la session, l'historique de la conversation n'est pas stocké. À la fin d'une session, le contexte correspondant est effacé.

Pour restaurer une session précédente ou fournir au modèle le contexte historique des interactions utilisateur, l'application doit gérer son propre journal de conversation et utiliser un message BidiGenerateContentClientContent pour envoyer ces informations au début d'une nouvelle session.

Durée maximale de la session

La durée de la session est limitée à 15 minutes pour l'audio ou à 2 minutes pour l'audio et la vidéo. Lorsque la durée de la session dépasse la limite, la connexion est interrompue.

Le modèle est également limité par la taille du contexte. L'envoi de grands blocs de contenu en plus des flux vidéo et audio peut entraîner la fin prématurée de la session.

Détection de l'activité vocale (VAD)

Le modèle effectue automatiquement la détection de l'activité vocale (VAD) sur un flux d'entrée audio continu. La suppression de la voix active est toujours activée et ses paramètres ne sont pas configurables.

Nombre de jetons

Le nombre de jetons n'est pas accepté.

Limites de débit

Les limites de débit suivantes s'appliquent:

• 3 sessions simultanées par clé API
• 4 millions de jetons par minute

Messages et événements

En savoir plus sur les types courants

Pour en savoir plus sur les types de ressources d'API couramment utilisés (Blob, Content, FunctionCall, FunctionResponse, GenerationConfig, GroundingMetadata et Tool), consultez la section Générer du contenu.