Configurer les fonctionnalités Gemini

Ce document vous 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 fonctions et l'ancrage, ainsi que les fonctionnalités audio natives telles que le dialogue affectif et l'audio proactif.

Configurer l'utilisation des outils

Plusieurs outils sont compatibles avec différentes versions des modèles compatibles avec l'API Gemini 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 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'information 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 Vertex AI

Vous pouvez utiliser le moteur RAG 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 que vous avez 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 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 le dialogue est activée, le modèle tente de comprendre et de répondre en fonction du ton de voix et des expressions émotionnelles de l'utilisateur.

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

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.)
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é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.
  • Évite 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 répondre de manière appropriée (c'est-à-dire de gérer les interruptions appropriées), 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 Gemini Live, consultez les ressources suivantes :