Configurare le funzionalità di Gemini

Questo documento mostra come configurare varie funzionalità dei modelli Gemini quando utilizzi l'API Live. Puoi configurare il pensiero, l'utilizzo di strumenti come le chiamate di funzione e il grounding e le funzionalità audio native come il dialogo affettivo e l'audio proattivo.

Configurare il pensiero

I modelli Gemini supportano le funzionalità di pensiero, con il pensiero dinamico attivato per impostazione predefinita. Il parametro thinking_budget indica al modello il numero di token di pensiero da utilizzare. Per disattivare la funzionalità di ragionamento, imposta thinking_budget su 0.

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

Configurare l'utilizzo degli strumenti

Diversi strumenti sono compatibili con varie versioni dei modelli supportati dall'API Live, tra cui:

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.

usa la 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 abilitare la chiamata di funzione, includi function_declarations nell'elenco tools nel messaggio di configurazione:

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

Per esempi di utilizzo della chiamata di funzioni nelle istruzioni di sistema, consulta il nostro esempio di best practice.

Puoi utilizzare Grounding con la Ricerca Google con l'API Live includendo google_search nell'elenco tools nel messaggio di configurazione:

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

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.

Configurare le funzionalità audio native

I modelli con funzionalità audio native supportano le seguenti funzionalità:

Configurare il dialogo empatico

Quando Dialogo affettivo è attivato, il modello tenta di comprendere e rispondere in base al tono di voce e alle espressioni emotive dell'utente.

Per attivare la funzionalità di dialogo affettivo, imposta enable_affective_dialog su true nel messaggio di configurazione:

Python

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

Configurare l'audio proattivo

L'audio proattivo ti consente di controllare quando il modello risponde. Ad esempio, puoi chiedere a Gemini di rispondere solo quando richiesto o quando vengono trattati argomenti specifici. Per vedere una dimostrazione video di Proactive Audio, guarda Anteprima audio nativa dell'API Gemini Live.

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

Esempio di conversazione

Di seguito è riportato un esempio di conversazione con Gemini sulla cucina:

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."

Casi d'uso comuni

Quando utilizzi l'audio proattivo, Gemini si comporta nel seguente modo:

  • Risponde con una latenza minima: Gemini risponde dopo che l'utente ha finito di parlare, riducendo le interruzioni e aiutando Gemini a non perdere il contesto in caso di interruzione.
  • Evita interruzioni: Proactive Audio aiuta Gemini a evitare interruzioni dovute a rumori di sottofondo o chiacchiere esterne e impedisce a Gemini di rispondere se vengono introdotte chiacchiere esterne durante una conversazione.
  • Gestisce le interruzioni: se l'utente deve interrompere la risposta di Gemini, Proactive Audio consente a Gemini di gestire in modo appropriato il canale secondario (ovvero le interruzioni appropriate), anziché se l'utente utilizza parole di riempimento come ehm o uhm.
  • Ascolto congiunto dell'audio: Gemini può ascoltare congiuntamente un file audio che non è la voce dell'oratore e rispondere successivamente alle domande sul file audio nel corso della conversazione.

Fatturazione

Mentre Gemini ascolta una conversazione, verranno addebitati i token audio di input.

Per i token audio di output, l'addebito viene effettuato solo quando Gemini risponde. Se Gemini non risponde o rimane in silenzio, non verranno addebitati token audio di output.

Per saperne di più, consulta la pagina Prezzi di Vertex AI.

Passaggi successivi

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