Herramientas integradas para la API Live

Los modelos compatibles con la API Live incluyen la función integrada para usar las siguientes herramientas:

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.

Modelos admitidos

Puedes usar la API Live con los siguientes modelos:

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

* Ponte en contacto con el representante del equipo de tu cuenta de Google para solicitar acceso.

Llamada de funciones

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:

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 Live para generar y ejecutar código 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 Grounding con la Búsqueda de Google con la API Live incluyendo 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())

Fundamentos con el motor de RAG de Vertex AI (vista previa)

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 el motor de RAG de Vertex AI en la API Live de Gemini.

(Vista previa pública) Audio nativo

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

Usar 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 consultas dirigidas al dispositivo. Las consultas que no se dirigen a un dispositivo se ignoran.

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

Usar el diálogo afectivo

Diálogo afectivo permite que los modelos que usan la API Live de audio nativo entiendan mejor las expresiones emocionales de los usuarios y respondan de forma adecuada, lo que da lugar a conversaciones más matizadas.

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

Más información

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