Herramientas integradas para la API de Live

Los modelos compatibles con la API en vivo tienen la capacidad integrada de usar las siguientes herramientas:

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.

Modelos compatibles

Puedes usar la API de Live con los siguientes modelos:

Versión del modelo Nivel de disponibilidad
gemini-live-2.5-flash DG privada*
gemini-live-2.5-flash-preview-native-audio Versión preliminar pública

* Comunícate con tu representante del equipo de cuentas de Google para solicitar acceso.

Llamada a función

Usa las llamadas a funciones para crear una descripción de una función y, luego, pasar 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 la llamada a funciones, incluye function_declarations en la lista tools:

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

Python

Ejecución de código

Puedes usar la ejecución de código con la API de Live para generar y ejecutar código de Python directamente. Para habilitar la ejecución de código en tus respuestas, incluye code_execution en la lista tools:

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 = [{'code_execution': {}}]
config = {"response_modalities": ["TEXT"], "tools": tools}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        prompt = "Compute the largest prime palindrome under 100000."
        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)
            
                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())

Puedes usar Fundamentación con la Búsqueda de Google con la API en vivo si incluyes google_search en la lista tools:

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 el motor de RAG de Vertex AI (versión preliminar)

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.

(Versión preliminar pública) Audio nativo

Gemini 2.5 Flash con la API de Live introduce capacidades de audio nativas, lo que mejora las funciones estándar de la API de Live. El audio nativo proporciona interacciones de voz más naturales y enriquecidas a través de 30 voces en HD en 24 idiomas. También incluye dos funciones nuevas exclusivas del audio nativo: Audio proactivo y Diálogo afectivo.

Cómo usar el audio proactivo

Audio proactivo permite que el modelo responda solo cuando sea pertinente. Cuando está habilitado, el modelo genera transcripciones de texto y respuestas de audio de forma proactiva, pero solo para las preguntas dirigidas al dispositivo. Se ignoran las búsquedas que no están dirigidas a un dispositivo.

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

Usar el diálogo basado en emociones detectadas

Affective Dialog permite que los modelos que usan audio nativo de la API de Live comprendan mejor las expresiones emocionales de los usuarios y respondan de manera adecuada, lo que genera conversaciones más matizadas.

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

Python

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

Más información

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