Configurer les fonctionnalités Gemini

Ce document vous explique comment configurer différentes fonctionnalités des modèles Gemini lorsque vous utilisez l'API Live. Vous pouvez configurer la réflexion, l'utilisation d'outils tels que l'appel de fonction et l'ancrage, ainsi que les fonctionnalités audio natives telles que le dialogue affectif et l'audio proactif.

Configurer la réflexion

Les modèles Gemini sont compatibles avec les capacités de réflexion, avec la réflexion dynamique activée par défaut. Le paramètre thinking_budget fournit au modèle des indications sur le nombre de jetons de réflexion qu'il peut utiliser. Pour désactiver la réflexion, définissez thinking_budget sur 0.

config = {
    "response_modalities": ["audio"],
    "thinking_config": {
        "thinking_budget": 256,
    },
}

Configurer l'utilisation des outils

Plusieurs outils sont compatibles avec différentes versions des modèles compatibles avec l'API Live, y compris :

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.

Appel de fonction

Utilisez l'appel de fonction pour créer une description de 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 du message de configuration :

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

Pour obtenir des exemples d'utilisation de l'appel de fonction dans les instructions système, consultez notre exemple de bonnes pratiques.

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

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

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.

Configurer les fonctionnalités audio natives

Les modèles dotés de fonctionnalités audio natives sont compatibles avec les fonctionnalités suivantes :

Configurer le dialogue affectif

Lorsque l'affectivité dans les dialogues est activée, le modèle tente de comprendre l'intonation et les expressions émotionnelles de l'utilisateur et d'y répondre.

Pour activer le dialogue affectif, définissez enable_affective_dialog sur true dans le message de configuration :

Python

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

Configurer l'audio proactif

L'audio proactif vous permet de contrôler quand le modèle répond. Par exemple, vous pouvez demander à Gemini de ne répondre que lorsqu'il est sollicité ou lorsque des sujets spécifiques sont abordés. Pour voir une démonstration vidéo de l'audio proactif, consultez Aperçu de l'audio natif de l'API Gemini Live.

Pour activer 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),
)

Exemple de conversation

Voici un exemple de conversation avec Gemini sur la cuisine :

Prompt: "You are an AI assistant in Italian cooking; only chime in when the topic is about Italian cooking."

Speaker A: "I really love cooking!" (No response from Gemini.)

Speaker B: "Oh yes, me too! My favorite is French cuisine." (No response from
Gemini.)

Speaker A: "I really like Italian food; do you know how to make a pizza?"

(Italian cooking topic will trigger response from Gemini.)
Live API: "I'd be happy to help! Here's a recipe for a pizza."

Cas d'utilisation courants

Lorsque vous utilisez l'audio proactif, Gemini procède comme suit :

  • Réponse avec une latence minimale : Gemini répond une fois que l'utilisateur a fini de parler, ce qui réduit les interruptions et permet à Gemini de ne pas perdre le contexte en cas d'interruption.
  • Éviter les interruptions : l'audio proactif aide Gemini à éviter les interruptions dues aux bruits de fond ou aux conversations externes, et empêche Gemini de répondre si des conversations externes sont introduites pendant une conversation.
  • Gère les interruptions : si l'utilisateur doit interrompre Gemini pendant une réponse, l'audio proactif permet à Gemini de gérer correctement les interruptions (c'est-à-dire de répondre de manière appropriée), plutôt que si l'utilisateur utilise des mots de remplissage tels que euh ou hum.
  • Écoute conjointe de l'audio : Gemini peut écouter conjointement un fichier audio qui n'est pas la voix de l'interlocuteur, puis répondre à des questions sur ce fichier audio plus tard dans la conversation.

Facturation

Des jetons audio d'entrée seront facturés lorsque Gemini écoute une conversation.

Pour les jetons audio de sortie, vous n'êtes facturé que lorsque Gemini répond. Si Gemini ne répond pas ou reste silencieux, vos jetons audio de sortie ne vous seront pas facturés.

Pour en savoir plus, consultez les tarifs de Vertex AI.

Étapes suivantes

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