Get started with Gemini Live API using the Google GenAI SDK

L'API Gemini Live permet une interaction bidirectionnelle en temps réel avec les modèles Gemini, en acceptant les entrées audio, vidéo et texte, et les sorties audio natives. Ce guide explique comment intégrer l'API à l'aide du SDK Google GenAI sur votre serveur.

Essayer l'API Live dans Google AI Studio Cloner l'exemple d'application depuis GitHub Utiliser les compétences de l'agent de codage

Présentation

L'API Gemini Live utilise WebSockets pour la communication en temps réel. Le SDK google-genai fournit une interface asynchrone de haut niveau pour gérer ces connexions.

Concepts clés :

  • Session : connexion persistante au modèle.
  • Config : configuration des modalités (audio/texte), de la voix et des instructions système.
  • Entrée en temps réel : envoi de frames audio et vidéo sous forme de blobs.

Se connecter à l'API Live

Démarrez une session Live API avec une clé API :

Python

import asyncio
from google import genai

client = genai.Client(api_key="YOUR_API_KEY")

model = "gemini-2.5-flash-native-audio-preview-12-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({ apiKey: "YOUR_API_KEY"});
const model = 'gemini-2.5-flash-native-audio-preview-12-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();

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

Pour obtenir un exemple de récupération de l'audio à partir de l'appareil client (par exemple, le navigateur), consultez l'exemple de bout en bout sur GitHub.

Envoi de la vidéo…

Les images vidéo sont envoyées individuellement (par exemple, JPEG ou PNG) à une fréquence d'images spécifique (1 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'
  }
});

Pour obtenir un exemple de récupération de la vidéo à partir de l'appareil client (par exemple, le navigateur), consultez l'exemple de bout en bout sur GitHub.

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

Consultez l'exemple d'application sur GitHub pour savoir comment recevoir l'audio sur votre serveur et le lire dans le navigateur.

Réception d'un SMS…

Les transcriptions des entrées utilisateur et des sorties du modèle sont disponibles dans le contenu du serveur.

Python

async for response in session.receive():
    content = response.server_content
    if content:
        if content.input_transcription:
            print(f"User: {content.input_transcription.text}")
        if content.output_transcription:
            print(f"Gemini: {content.output_transcription.text}")

JavaScript

// Inside the onmessage callback
const content = response.serverContent;
if (content?.inputTranscription) {
  console.log('User:', content.inputTranscription.text);
}
if (content?.outputTranscription) {
  console.log('Gemini:', content.outputTranscription.text);
}

Gérer les appels d'outils

L'API est compatible avec l'appel d'outils (appel de fonction). Lorsque le modèle demande un appel d'outil, vous devez exécuter la fonction et renvoyer la réponse.

Python

async for response in session.receive():
    if response.tool_call:
        function_responses = []
        for fc in response.tool_call.function_calls:
            # 1. Execute the function locally
            result = my_tool_function(**fc.args)

            # 2. Prepare the response
            function_responses.append(types.FunctionResponse(
                name=fc.name,
                id=fc.id,
                response={"result": result}
            ))

        # 3. Send the tool response back to the session
        await session.send_tool_response(function_responses=function_responses)

JavaScript

// Inside the onmessage callback
if (response.toolCall) {
  const functionResponses = [];
  for (const fc of response.toolCall.functionCalls) {
    const result = myToolFunction(fc.args);
    functionResponses.push({
      name: fc.name,
      id: fc.id,
      response: { result }
    });
  }
  session.sendToolResponse({ functionResponses });
}

Étape suivante