Integrierte Tools für die Live API

Live-API-kompatible Modelle bieten die integrierte Möglichkeit, die folgenden Tools zu verwenden:

Wenn Sie ein bestimmtes Tool für die Verwendung in zurückgegebenen Antworten aktivieren möchten, fügen Sie den Namen des Tools beim Initialisieren des Modells in die Liste tools ein. In den folgenden Abschnitten finden Sie Beispiele für die Verwendung der einzelnen integrierten Tools in Ihrem Code.

Unterstützte Modelle

Sie können die Live API mit den folgenden Modellen verwenden:

Modellversion Verfügbarkeitsstufe
gemini-live-2.5-flash Privater GA-Release*
gemini-live-2.5-flash-preview-native-audio Öffentliche Vorschau

* Wenden Sie sich an Ihren Google-Kundenbetreuer, um Zugriff anzufordern.

Funktionsaufrufe

Verwenden Sie Funktionsaufrufe, um eine Beschreibung einer Funktion zu erstellen und diese dann in einer Anfrage an das Modell zu übergeben. Die Antwort des Modells enthält den Namen einer Funktion, die der Beschreibung entspricht, sowie die Argumente, um diese aufzurufen.

Alle Funktionen müssen zu Beginn der Sitzung deklariert werden, indem Tool-Definitionen als Teil der LiveConnectConfig-Nachricht gesendet werden.

Wenn Sie Funktionsaufrufe aktivieren möchten, fügen Sie function_declarations in die Liste tools ein:

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

Codeausführung

Sie können die Codeausführung mit der Live API verwenden, um Python-Code direkt zu generieren und auszuführen. Wenn Sie die Codeausführung für Ihre Antworten aktivieren möchten, fügen Sie code_execution in die Liste tools ein:

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

Sie können Grounding with Google Search mit der Live API verwenden, indem Sie google_search in die Liste tools aufnehmen:

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

Fundierung mit der Vertex AI RAG Engine (Vorschau)

Sie können die Vertex AI-RAG-Engine mit der Live API verwenden, um Kontexte zu fundieren, zu speichern und abzurufen:

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

Weitere Informationen finden Sie unter Vertex AI RAG Engine in der Gemini Live API verwenden.

(Öffentliche Vorschau) Native Audio

Gemini 2.5 Flash mit Live API bietet native Audiofunktionen, die die Standardfunktionen der Live API erweitern. Mit der nativen Audioausgabe sind natürlichere Sprachinteraktionen möglich. Dazu stehen 30 HD-Stimmen in 24 Sprachen zur Verfügung. Außerdem sind zwei neue Funktionen enthalten, die nur für natives Audio verfügbar sind: Proactive Audio und Affective Dialog.

Proaktive Audioeingabe verwenden

Mit Proactive Audio kann das Modell nur dann reagieren, wenn es relevant ist. Wenn diese Option aktiviert ist, generiert das Modell proaktiv Texttranskripte und Audioantworten, aber nur für Anfragen, die an das Gerät gerichtet sind. Anfragen, die nicht an ein Gerät gerichtet sind, werden ignoriert.

Wenn Sie Proactive Audio verwenden möchten, konfigurieren Sie das Feld proactivity in der Einrichtungsnachricht und legen Sie proactive_audio auf true fest:

Python

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

Empathischen Dialog verwenden

Mit Affective Dialog können Modelle, die die native Audiofunktion der Live API verwenden, die emotionalen Äußerungen von Nutzern besser verstehen und angemessen darauf reagieren. So werden Unterhaltungen nuancierter.

Wenn Sie Affective Dialog aktivieren möchten, legen Sie enable_affective_dialog in der Einrichtungsnachricht auf true fest:

Python

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

Weitere Informationen

Weitere Informationen zur Verwendung der Live API finden Sie hier: