Outils intégrés pour l'API Live

Les modèles compatibles avec l'API Live sont dotés de la capacité intégrée d'utiliser les outils suivants :

Pour activer un outil spécifique dans les réponses renvoyées, incluez son nom dans la liste tools lorsque vous initialisez le modèle. Les sections suivantes fournissent des exemples d'utilisation de chacun des outils intégrés dans votre code.

Modèles compatibles

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.

Appel de fonction

Utilisez l'appel de fonction pour créer une description d'une fonction, puis transmettez cette description au modèle dans une requête. La réponse du modèle inclut le nom d'une fonction correspondant à la description et les arguments avec lesquels l'appeler.

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

Pour activer l'appel de fonction, incluez function_declarations dans la liste tools :

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"

# Simple function definitions
turn_on_the_lights = {"name": "turn_on_the_lights"}
turn_off_the_lights = {"name": "turn_off_the_lights"}

tools = [{"function_declarations": [turn_on_the_lights, turn_off_the_lights]}]
config = {"response_modalities": ["TEXT"], "tools": tools}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        prompt = "Turn on the lights please"
        await session.send_client_content(turns={"parts": [{"text": prompt}]})

        async for chunk in session.receive():
            if chunk.server_content:
                if chunk.text is not None:
                    print(chunk.text)
            elif chunk.tool_call:
                function_responses = []
                for fc in tool_call.function_calls:
                    function_response = types.FunctionResponse(
                        name=fc.name,
                        response={ "result": "ok" } # simple, hard-coded function response
                    )
                    function_responses.append(function_response)

                await session.send_tool_response(function_responses=function_responses)


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

Python

Exécution du code

Vous pouvez utiliser l'exécution de code avec l'API Live pour générer et exécuter directement du code Python. Pour activer l'exécution de code pour vos réponses, incluez code_execution dans la liste tools :

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"

tools = [{'code_execution': {}}]
config = {"response_modalities": ["TEXT"], "tools": tools}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        prompt = "Compute the largest prime palindrome under 100000."
        await session.send_client_content(turns={"parts": [{"text": prompt}]})

        async for chunk in session.receive():
            if chunk.server_content:
                if chunk.text is not None:
                    print(chunk.text)
            
                model_turn = chunk.server_content.model_turn
                if model_turn:
                    for part in model_turn.parts:
                      if part.executable_code is not None:
                        print(part.executable_code.code)

                      if part.code_execution_result is not None:
                        print(part.code_execution_result.output)

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

Vous pouvez utiliser l'ancrage avec la recherche Google avec l'API Live en incluant google_search dans la liste tools :

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"


tools = [{'google_search': {}}]
config = {"response_modalities": ["TEXT"], "tools": tools}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        prompt = "When did the last Brazil vs. Argentina soccer match happen?"
        await session.send_client_content(turns={"parts": [{"text": prompt}]})

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

                # The model might generate and execute Python code to use Search
                model_turn = chunk.server_content.model_turn
                if model_turn:
                    for part in model_turn.parts:
                        if part.executable_code is not None:
                        print(part.executable_code.code)

                        if part.code_execution_result is not None:
                        print(part.code_execution_result.output)

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

Ancrage avec le moteur RAG Vertex AI (aperçu)

Vous pouvez utiliser le moteur RAG Vertex AI avec l'API Live pour ancrer, stocker et récupérer des contextes :

Python

from google import genai
from google.genai import types
from google.genai.types import (Content, LiveConnectConfig, HttpOptions, Modality, Part)
from IPython import display

PROJECT_ID=YOUR_PROJECT_ID
LOCATION=YOUR_LOCATION
TEXT_INPUT=YOUR_TEXT_INPUT
MODEL_NAME="gemini-live-2.5-flash"

client = genai.Client(
   vertexai=True,
   project=PROJECT_ID,
   location=LOCATION,
)

rag_store=types.VertexRagStore(
   rag_resources=[
       types.VertexRagStoreRagResource(
           rag_corpus=  # Use memory corpus if you want to store context.
       )
   ],
   # Set `store_context` to true to allow Live API sink context into your memory corpus.
   store_context=True
)

async with client.aio.live.connect(
   model=MODEL_NAME,
   config=LiveConnectConfig(response_modalities=[Modality.TEXT],
                            tools=[types.Tool(
                                retrieval=types.Retrieval(
                                    vertex_rag_store=rag_store))]),
) as session:
   text_input=TEXT_INPUT
   print("> ", text_input, "\n")
   await session.send_client_content(
       turns=Content(role="user", parts=[Part(text=text_input)])
   )

   async for message in session.receive():
       if message.text:
           display.display(display.Markdown(message.text))
           continue

Pour en savoir plus, consultez Utiliser le moteur RAG Vertex AI dans l'API Gemini Live.

(Aperçu public) Audio natif

Gemini 2.5 Flash avec l'API Live introduit des fonctionnalités audio natives, ce qui améliore les fonctionnalités standards de l'API Live. L'audio natif offre des interactions vocales plus riches et plus naturelles grâce à 30 voix HD dans 24 langues. Il inclut également deux nouvelles fonctionnalités exclusives à l'audio natif : Proactive Audio et Affective Dialog.

Utiliser l'audio proactif

La réponse audio proactive permet au modèle de ne répondre que lorsque cela est pertinent. Lorsqu'elle est activée, le modèle génère proactivement des transcriptions textuelles et des réponses audio, mais uniquement pour les requêtes adressées à l'appareil. Les requêtes non adressées à un appareil sont ignorées.

Pour utiliser l'audio proactif, configurez le champ proactivity dans le message de configuration et définissez proactive_audio sur true :

Python

config = LiveConnectConfig(
    response_modalities=["AUDIO"],
    proactivity=ProactivityConfig(proactive_audio=True),
)

Utiliser le dialogue affectif

Affective Dialog permet aux modèles utilisant l'audio natif de l'API Live de mieux comprendre les expressions émotionnelles des utilisateurs et d'y répondre de manière appropriée, ce qui permet d'avoir des conversations plus nuancées.

Pour activer Affective Dialog, définissez enable_affective_dialog sur true dans le message de configuration :

Python

config = LiveConnectConfig(
    response_modalities=["AUDIO"],
    enable_affective_dialog=True,
)

En savoir plus

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