Configura las capacidades de Gemini

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

Configura el pensamiento

Los modelos de Gemini admiten capacidades de razonamiento, con el razonamiento dinámico habilitado de forma predeterminada. El parámetro thinking_budget guía al modelo sobre la cantidad de tokens de pensamiento que debe usar. Para inhabilitar el pensamiento, establece thinking_budget en 0.

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

Configura el uso de herramientas

Varias herramientas son compatibles con diferentes versiones de los modelos compatibles con la API de Live, incluidas las siguientes:

Para habilitar una herramienta en particular para su uso en las respuestas devueltas, incluye el nombre de la herramienta en la lista tools cuando inicialices el modelo. En las siguientes secciones, se proporcionan ejemplos de cómo usar cada una de las herramientas integradas en tu código.

Llamada a función

Usa las llamadas a funciones para crear una descripción de una función y, luego, 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 con los que se la llama.

Todas las funciones se deben declarar al comienzo de la sesión enviando definiciones de herramientas 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 del uso de la llamada a función en instrucciones del sistema, consulta nuestro ejemplo de prácticas recomendadas.

Puedes usar Grounding with Google Search con la API en vivo si incluyes 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())

Fundamentación con Vertex AI RAG Engine

Puedes usar el motor de RAG de Vertex AI con la API de 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 Cómo usar Vertex AI RAG Engine en la API de Gemini Live.

Configura las capacidades de audio nativas

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

Cómo configurar el diálogo basado en emociones detectadas

Cuando se habilita Diálogo Afectivo, el modelo intenta comprender y responder en función del tono de voz y las expresiones emocionales del usuario.

Para habilitar el diálogo afectivo, establece enable_affective_dialog en true en el mensaje de configuración:

Python

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

Cómo configurar el 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 específicos. Para ver una demostración en video de Audio Proactivo, consulta Gemini LiveAPI Native Audio Preview.

Para habilitar el audio proactivo, configura el campo proactivity en el mensaje de configuración y establece proactive_audio en true:

Python

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

Ejemplo de conversación

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 de uso habituales

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

  • Responde con latencia mínima: Gemini responde después de que el usuario termina de hablar, lo que reduce las interrupciones y ayuda a Gemini a no perder el contexto si se produce una interrupción.
  • Evita interrupciones: El Audio proactivo ayuda a Gemini a evitar interrupciones por ruido de fondo o charlas externas, y evita que Gemini responda si se introduce una charla externa durante una conversación.
  • Maneja interrupciones: Si el usuario necesita interrumpir una respuesta de Gemini, el Audio Proactivo facilita que Gemini realice una retroalimentación adecuada (es decir, se manejan las interrupciones apropiadas), en lugar de que un usuario use palabras de relleno como eh o um.
  • Escucha audio en conjunto: Gemini puede escuchar un archivo de audio en conjunto que no sea la voz del orador y, luego, responder preguntas sobre ese archivo de audio más adelante en la conversación.

Facturación

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

En el caso de los tokens de audio de salida, solo se te cobra cuando Gemini responde. Si Gemini no responde o permanece 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.

¿Qué sigue?

Para obtener más información sobre el uso de la API de Live, consulta los siguientes recursos: