Configurer les fonctionnalités Gemini

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

Configurer l'utilisation d'outils

Plusieurs outils sont compatibles avec différentes versions des modèles compatibles avec l'API Gemini Live, y compris les 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.

Appel de fonction

Utilisez l'appel de fonction lorsque vous souhaitez que le modèle interagisse avec des systèmes ou des API externes que vous gérez. Utilisez-le pour des tâches telles que la vérification d'une base de données, l'envoi d'un e-mail ou l'interaction avec une API personnalisée.

Le modèle génère un appel de fonction, et votre application exécute le code et renvoie les résultats au modèle.

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.types import (
    Content,
    LiveConnectConfig,
    Part,
)

# Initialize the client.
client = genai.Client(
    vertexai=True,
    project="GOOGLE_CLOUD_PROJECT",  # Replace with your project ID
    location="LOCATION",  # Replace with your location
)

MODEL_ID = "gemini-live-2.5-flash-native-audio"


def get_current_weather(location: str) -> str:
    """Example method. Returns the current weather.

    Args:
        location: The city and state, e.g. San Francisco, CA
    """
    weather_map: dict[str, str] = {
        "Boston, MA": "snowing",
        "San Francisco, CA": "foggy",
        "Seattle, WA": "raining",
        "Austin, TX": "hot",
        "Chicago, IL": "windy",
    }
    return weather_map.get(location, "unknown")


async def main():
    config = LiveConnectConfig(
        response_modalities=["AUDIO"],
        tools=[get_current_weather],
    )

    async with client.aio.live.connect(
        model=MODEL_ID,
        config=config,
    ) as session:
        text_input = "Get the current weather in Boston."
        print(f"Input: {text_input}")

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

        async for message in session.receive():
            if message.tool_call:
                function_responses = []
                for function_call in message.tool_call.function_calls:
                    print(f"FunctionCall > {function_call}")
                    # Execute the tool and send the response back to the model.
                    result = get_current_weather(**function_call.args)
                    function_responses.append(
                        {
                            "name": function_call.name,
                            "response": {"result": result},
                            "id": function_call.id,
                        }
                    )
                if function_responses:
                    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.

Utilisez l'ancrage avec la recherche Google lorsque vous souhaitez que le modèle fournisse des réponses plus précises et factuelles en les ancrant à des sources d'informations vérifiables. Utilisez-le pour des tâches telles que la recherche sur le Web.

Contrairement à l'appel de fonction, l'intégration côté serveur gère automatiquement la récupération des informations.

Pour activer l'ancrage avec la recherche Google, incluez google_search dans la liste tools du message de configuration :

Python

import asyncio

from google import genai
from google.genai.types import (
    Content,
    LiveConnectConfig,
    Part,
)

# Initialize the client.
client = genai.Client(
    vertexai=True,
    project="GOOGLE_CLOUD_PROJECT",  # Replace with your project ID
    location="LOCATION",  # Replace with your location
)

MODEL_ID = "gemini-live-2.5-flash-native-audio"


async def main():
    config = LiveConnectConfig(
        response_modalities=["AUDIO"],
        tools=[{"google_search": {}}],
    )

    async with client.aio.live.connect(
        model=MODEL_ID,
        config=config,
    ) as session:
        text_input = "What is the current weather in Toronto, Canada?"
        print(f"Input: {text_input}")

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

        async for message in session.receive():
            # Consume the messages from the model.
            # In native audio, the model response is in audio format.
            pass


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

Ancrage avec le moteur RAG de Vertex AI

Vous pouvez utiliser le moteur RAG de Vertex AI avec l'API Live pour ancrer, stocker et récupérer des contextes. Utilisez-le pour des tâches telles que la récupération d'informations à partir d'un corpus de documents. Comme l'ancrage avec la recherche Google, l'ancrage RAG est géré côté serveur et récupère automatiquement les informations du corpus spécifié :

Python

import asyncio

from google import genai
from google.genai.types import (
    Content,
    LiveConnectConfig,
    Part,
    Retrieval,
    Tool,
    VertexRagStore,
    VertexRagStoreRagResource,
)

# Initialize the client.
client = genai.Client(
    vertexai=True,
    project="GOOGLE_CLOUD_PROJECT",  # Replace with your project ID
    location="LOCATION",  # Replace with your location
)

MODEL_ID = "gemini-live-2.5-flash-native-audio"


async def main():
    rag_store = VertexRagStore(
        rag_resources=[
            VertexRagStoreRagResource(
                rag_corpus="RESOURCE_NAME"  # Replace with your corpus resource name
            )
        ],
        # Set `store_context` to true to allow Live API sink context into your memory corpus.
        store_context=True,
    )

    config = LiveConnectConfig(
        response_modalities=["AUDIO"],
        tools=[Tool(retrieval=Retrieval(vertex_rag_store=rag_store))],
    )

    async with client.aio.live.connect(
        model=MODEL_ID,
        config=config,
    ) as session:
        text_input = "YOUR_TEXT_INPUT"
        print(f"Input: {text_input}")

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

        async for message in session.receive():
            # Consume the messages from the model.
            # In native audio, the model response is in audio format.
            pass


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

Pour en savoir plus, consultez Utiliser le moteur RAG de 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 le dialogue affectif est activé, le modèle tente de comprendre et de répondre en fonction du ton de la voix et des expressions émotionnelles de l'utilisateur.

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 le moment où le modèle répond. Par exemple, vous pouvez demander à Gemini de ne répondre que lorsqu'il est invité à le faire 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.)
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 se comporte comme suit :

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

Facturation

Lorsque Gemini écoute une conversation, les jetons audio d'entrée sont facturés.

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 seront pas facturés.

Pour en savoir plus, consultez Tarifs de Gemini Enterprise Agent Platform.

Étape suivante

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