Configurar las funciones de Gemini

En este documento se explica cómo configurar varias funciones de los modelos de Gemini al usar la API Gemini Live. Puedes configurar el uso de herramientas, como la llamada a funciones y la fundamentación, así como las funciones de audio nativas, como el diálogo afectivo y el audio proactivo.

Configurar el uso de herramientas

Hay varias herramientas compatibles con distintas versiones de los modelos admitidos por la API Gemini Live, entre las que se incluyen las siguientes:

Para habilitar una herramienta concreta para que se use en las respuestas devueltas, incluye el nombre de la herramienta en la lista tools al inicializar el modelo. En las secciones siguientes se ofrecen ejemplos de cómo usar cada una de las herramientas integradas en tu código.

Llamadas de función

Usa la llamada a funciones para crear una descripción de una función y, a continuación, pasa esa descripción al modelo en una solicitud. La respuesta del modelo incluye el nombre de una función que coincide con la descripción y los argumentos para llamarla.

Todas las funciones deben declararse al inicio de la sesión enviando tool definitions como parte del mensaje LiveConnectConfig.

Para habilitar las llamadas a funciones, incluye function_declarations en la lista tools del mensaje de configuración:

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

Para ver ejemplos de uso de la función de llamada en instrucciones del sistema, consulta nuestro ejemplo de prácticas recomendadas.

Puedes usar Grounding with Google Search con la API Gemini Live incluyendo google_search en la lista tools del mensaje de configuración:

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

Fundamentos con Vertex AI RAG Engine

Puedes usar Vertex AI RAG Engine con la API Live para fundamentar, almacenar y recuperar contextos:

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

Para obtener más información, consulta Usar Vertex AI RAG Engine en la API Live de Gemini.

Configurar las funciones de audio nativas

Los modelos que tienen funciones de audio nativas admiten las siguientes funciones:

Configurar Affective Dialog

Cuando Affective Dialog está habilitado, el modelo intenta entender y responder en función del tono de voz y las expresiones emocionales del usuario.

Para habilitar Affective Dialog, asigna el valor true a enable_affective_dialog en el mensaje de configuración:

Python

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

Configurar Audio proactivo

Audio proactivo te permite controlar cuándo responde el modelo. Por ejemplo, puedes pedirle a Gemini que solo responda cuando se le indique o cuando se hablen de temas concretos. Para ver una demostración en vídeo de Audio proactivo, consulta Vista previa de audio nativo de la API Gemini Live.

Para habilitar Audio proactivo, configura el campo proactivity en el mensaje de configuración y asigna el valor true a proactive_audio:

Python

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

Conversación de ejemplo

A continuación, se muestra un ejemplo de cómo podría ser una conversación con Gemini sobre cocina:

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."

Casos prácticos habituales

Cuando se usa Audio proactivo, Gemini funciona de la siguiente manera:

  • Responde con una latencia mínima: Gemini responde después de que el usuario haya terminado de hablar, lo que reduce las interrupciones y ayuda a Gemini a no perder el contexto si se produce una interrupción.
  • Evita interrupciones: Audio proactivo ayuda a Gemini a evitar las interrupciones del ruido de fondo o de las conversaciones externas, e impide que Gemini responda si se produce una conversación externa durante una conversación.
  • Gestiona las interrupciones: si el usuario necesita interrumpir una respuesta de Gemini, la función de audio proactivo facilita que Gemini responda de forma adecuada (es decir, que se gestionen las interrupciones apropiadas), en lugar de que el usuario utilice muletillas como eh o um.
  • Escucha audio: Gemini puede escuchar un archivo de audio que no sea la voz del interlocutor y, posteriormente, responder preguntas sobre ese archivo de audio en la conversación.

Facturación

Mientras Gemini escucha una conversación, se cobrarán tokens de audio de entrada.

En el caso de los tokens de audio de salida, solo se te cobrará cuando Gemini responda. Si Gemini no responde o se queda en silencio, no se te cobrarán los tokens de audio de salida.

Para obtener más información, consulta los precios de Vertex AI.

Siguientes pasos

Para obtener más información sobre cómo usar la API de Gemini Live, consulta los siguientes artículos: