Strumenti integrati per l'API Live

I modelli supportati dall'API Live sono dotati della funzionalità integrata per utilizzare i seguenti strumenti:

Per attivare un particolare strumento per l'utilizzo nelle risposte restituite, includi il nome dello strumento nell'elenco tools quando inizializzi il modello. Le sezioni seguenti forniscono esempi di come utilizzare ciascuno degli strumenti integrati nel codice.

Modelli supportati

Puoi utilizzare l'API Live con i seguenti modelli:

Versione del modello Livello di disponibilità
gemini-live-2.5-flash GA privato*
gemini-live-2.5-flash-preview-native-audio Anteprima pubblica

* Contatta il rappresentante del team dedicato al tuo Account Google per richiedere l'accesso.

Chiamata di funzione

Utilizza le chiamate di funzione per creare una descrizione di una funzione, quindi passa questa descrizione al modello in una richiesta. La risposta del modello include il nome di una funzione che corrisponde alla descrizione e gli argomenti con cui chiamarla.

Tutte le funzioni devono essere dichiarate all'inizio della sessione inviando le definizioni degli strumenti come parte del messaggio LiveConnectConfig.

Per attivare la chiamata di funzioni, includi function_declarations nell'elenco 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

Esecuzione del codice

Puoi utilizzare l'esecuzione del codice con l'API Live per generare ed eseguire direttamente il codice Python. Per attivare l'esecuzione del codice per le tue risposte, includi code_execution nell'elenco 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())

Puoi utilizzare Grounding con la Ricerca Google con l'API Live includendo google_search nell'elenco 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())

Grounding con Vertex AI RAG Engine (anteprima)

Puoi utilizzare Vertex AI RAG Engine con l'API Live per il grounding, l'archiviazione e il recupero dei contesti:

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

Per saperne di più, consulta Utilizzare il motore RAG di Vertex AI nell'API Gemini Live.

(Anteprima pubblica) Audio nativo

Gemini 2.5 Flash con API Live introduce funzionalità audio native, migliorando le funzionalità standard dell'API Live. L'audio nativo offre interazioni vocali più ricche e naturali grazie a 30 voci HD in 24 lingue. Sono incluse anche due nuove funzionalità esclusive per l'audio nativo: audio proattivo e dialogo affettivo.

Utilizzare l'audio proattivo

L'audio proattivo consente al modello di rispondere solo quando è pertinente. Se attivato, il modello genera in modo proattivo trascrizioni di testo e risposte audio, ma solo per le query indirizzate al dispositivo. Le query non indirizzate a un dispositivo vengono ignorate.

Per utilizzare l'audio proattivo, configura il campo proactivity nel messaggio di configurazione e imposta proactive_audio su true:

Python

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

Utilizzare il dialogo empatico

Affective Dialog consente ai modelli che utilizzano l'audio nativo dell'API Live di comprendere meglio e rispondere in modo appropriato alle espressioni emotive degli utenti, portando a conversazioni più sfumate.

Per attivare il dialogo empatico, imposta enable_affective_dialog su true nel messaggio di configurazione:

Python

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

Ulteriori informazioni

Per ulteriori informazioni sull'utilizzo dell'API Live, consulta: