Configurar recursos do Gemini

Este documento mostra como configurar vários recursos dos modelos do Gemini ao usar a API Live. É possível configurar o pensamento, o uso de ferramentas, como chamada de função e embasamento, e recursos de áudio nativos, como diálogo afetivo e áudio proativo.

Configurar o pensamento

Os modelos do Gemini oferecem recursos de pensamento, com o pensamento dinâmico ativado por padrão. O parâmetro thinking_budget orienta o modelo sobre o número de tokens de pensamento que serão usados. Para desativar o pensamento, defina thinking_budget como 0.

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

Configurar o uso de ferramentas

Várias ferramentas são compatíveis com várias versões de modelos compatíveis com a API Live, incluindo:

Para ativar uma ferramenta específica para uso nas respostas retornadas, inclua o nome dela na lista tools ao inicializar o modelo. As seções a seguir mostram exemplos de como usar cada uma das ferramentas integradas no seu código.

Chamadas de função

Use a chamada de função para criar uma descrição de uma função e transmita essa descrição para o modelo em uma solicitação. A resposta do modelo inclui o nome de uma função que corresponde à descrição e os argumentos para chamá-la.

Todas as funções precisam ser declaradas no início da sessão enviando definições de ferramentas como parte da mensagem LiveConnectConfig.

Para ativar a chamada de função, inclua function_declarations na lista tools na mensagem de configuração:

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 exemplos de como usar a chamada de função em instruções do sistema, consulte nosso exemplo de práticas recomendadas.

É possível usar o Fundamentação com a Pesquisa Google com a API Live incluindo google_search na lista tools na mensagem de configuração:

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

Embasamento com o mecanismo RAG da Vertex AI

Você pode usar o mecanismo de RAG da Vertex AI com a API Live para embasamento, armazenamento e recuperação de 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 mais informações, consulte Usar o Mecanismo RAG da Vertex AI na API Gemini Live.

Configurar recursos de áudio nativos

Os modelos com recursos de áudio nativos oferecem suporte aos seguintes recursos:

Configurar a computação afetiva

Quando a conversa afetiva está ativada, o modelo tenta entender e responder com base no tom de voz e nas expressões emocionais do usuário.

Para ativar o diálogo afetivo, defina enable_affective_dialog como true na mensagem de configuração:

Python

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

Configurar o áudio proativo

Com o áudio proativo, você controla quando o modelo responde. Por exemplo, você pode pedir para o Gemini responder apenas quando solicitado ou quando assuntos específicos forem discutidos. Para assistir a uma demonstração em vídeo do áudio proativo, consulte Prévia de áudio nativo da API Gemini Live.

Para ativar o áudio proativo, configure o campo proactivity na mensagem de configuração e defina proactive_audio como true:

Python

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

Exemplo de conversa

Confira um exemplo de como seria uma conversa com o Gemini sobre culinária:

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 comuns

Ao usar o áudio proativo, o Gemini faz o seguinte:

  • Responde com latência mínima: o Gemini responde depois que o usuário termina de falar, reduzindo interrupções e ajudando o Gemini a não perder o contexto se uma interrupção acontecer.
  • Evita interrupções: o áudio proativo ajuda o Gemini a evitar interrupções causadas por ruídos de fundo ou conversas externas e impede que ele responda se uma conversa externa for iniciada durante uma conversa.
  • Lida com interrupções: se o usuário precisar interromper uma resposta do Gemini, o áudio proativo facilita a resposta adequada do Gemini (ou seja, as interrupções adequadas são processadas), em vez de usar palavras de preenchimento, como hum ou ãh.
  • Ouve áudio com você: o Gemini pode ouvir um arquivo de áudio que não é a voz do falante e responder a perguntas sobre ele mais tarde na conversa.

Faturamento

Enquanto o Gemini ouve uma conversa, os tokens de áudio de entrada são cobrados.

Para tokens de áudio de saída, a cobrança só é feita quando o Gemini responde. Se o Gemini não responder ou ficar em silêncio, não haverá cobrança pelos tokens de áudio de saída.

Para mais informações, consulte Preços da Vertex AI.

A seguir

Para mais informações sobre como usar a API Live, consulte: