Ferramentas integradas para a API Live

Para ver um exemplo da API Live, execute o bloco de notas "Introdução ao áudio nativo da API Live" num dos seguintes ambientes:

Abrir no Colab | Abrir no Colab Enterprise | Abrir no Vertex AI Workbench | Ver no GitHub

Os modelos suportados pela API Live incluem a capacidade integrada de usar as seguintes ferramentas:

• Chamada de funções
• Execução de código
• Fundamentação com a Pesquisa Google
• Fundamentação com o Vertex AI RAG Engine (pré-visualização)

Para ativar uma ferramenta específica para utilização nas respostas devolvidas, inclua o nome da ferramenta na lista tools quando inicializar o modelo. As seguintes secções fornecem exemplos de como usar cada uma das ferramentas incorporadas no seu código.

Modelos suportados

Pode usar a API Live com os seguintes modelos:

Versão do modelo	Nível de disponibilidade
gemini-live-2.5-flash	GA privado^*
gemini-live-2.5-flash-preview-native-audio	Pré-visualização pública
gemini-live-2.5-flash-preview-native-audio-09-2025	Pré-visualização pública

^* Contacte o representante da equipa da sua Conta Google para pedir acesso.

Chamada de funções

Use a chamada de funções para criar uma descrição de uma função e, em seguida, transmita essa descrição ao modelo num pedido. A resposta do modelo inclui o nome de uma função que corresponde à descrição e os argumentos para a chamar.

Todas as funções têm de ser declaradas no início da sessão através do envio de definições de ferramentas como parte da mensagem LiveConnectConfig.

Para ativar a Chamada de funções, inclua function_declarations na 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

Para ver exemplos de utilização da Chamada de função em instruções do sistema, consulte o nosso exemplo de práticas recomendadas.

Execução de código

Pode usar a execução de código com a API Live para gerar e executar código Python diretamente. Para ativar a execução de código nas suas respostas, inclua code_execution na 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())
  

Validação com a Pesquisa Google

Pode usar a Fundamentação com a Pesquisa Google com a API Live incluindo google_search na 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())
  

Fundamentação com o Vertex AI RAG Engine (pré-visualização)

Pode usar o motor RAG do Vertex AI com a API Live para fundamentar, armazenar e obter 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 o artigo Use o Vertex AI RAG Engine na API Gemini Live.

(Pré-visualização pública) Áudio nativo

Pré-visualização

Esta funcionalidade está sujeita aos "Termos das Ofertas de Pré-DG" na secção Termos Gerais de Serviço dos Termos Específicos do Serviço. As funcionalidades de pré-DG estão disponíveis "tal como estão" e podem ter apoio técnico limitado. Para mais informações, consulte as descrições das fases de lançamento.

O Gemini 2.5 Flash com a API Live introduz capacidades de áudio nativas, melhorando as funcionalidades padrão da API Live. O áudio nativo oferece interações de voz mais ricas e naturais através de 30 vozes HD em 24 idiomas. Também inclui duas novas funcionalidades exclusivas do áudio nativo: áudio proativo e diálogo afetivo.

Nota: response_modalities=["TEXT"] não é compatível com áudio nativo.

Use o diálogo afetivo

Importante: o diálogo afetivo pode produzir resultados inesperados.

O diálogo afetivo permite que os modelos que usam áudio nativo da API Live compreendam melhor e respondam adequadamente às expressões emocionais dos utilizadores, o que leva a conversas mais detalhadas.

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

Mais informações

Para mais informações sobre a utilização da API Live, consulte:

• Vista geral da API Live
• Guia de referência da API Live
• Conversas interativas