Configurar las funciones de Gemini

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

Configurar el pensamiento

Los modelos de Gemini admiten funciones de razonamiento, con la función de razonamiento dinámico habilitada de forma predeterminada. El parámetro thinking_budget indica al modelo el número de tokens de pensamiento que debe usar. Para inhabilitar el pensamiento, asigna el valor 0 a thinking_budget.

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

Configurar el uso de herramientas

Hay varias herramientas compatibles con diferentes versiones de modelos compatibles con la API 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 cuando inicialices 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 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

El 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 la 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.)
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 cuando el usuario ha 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 interrupciones por el ruido de fondo o las conversaciones externas, e impide que Gemini responda si se producen conversaciones externas 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 mm.
  • Escucha audio junto a ti: Gemini puede escuchar un archivo de audio que no sea la voz del interlocutor y, posteriormente, responder a 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 Live, consulta los siguientes artículos: