Gemini-Funktionen konfigurieren

In diesem Dokument wird beschrieben, wie Sie verschiedene Funktionen von Gemini-Modellen konfigurieren, wenn Sie die Gemini Live API verwenden. Sie können die Tool-Nutzung wie Funktionsaufrufe und Grounding sowie Live-Audiofunktionen wie affektive Dialoge und proaktives Audio konfigurieren.

Tool-Nutzung konfigurieren

Mehrere Tools sind mit verschiedenen Versionen von Modellen kompatibel, die von der Gemini Live API unterstützt werden, darunter:

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

Wichtig:Die Gemini API unterstützt nicht die Kombination von Suchtools (z. B. googleSearch) mit Nicht-Suchtools (z. B. Funktionsaufrufen oder dem Tool retrieval der Gemini Enterprise Agent Platform RAG Engine) in derselben Einrichtungsanfrage. Mehrere Tools werden nur unterstützt, wenn es sich bei allen um Suchtools handelt.

Funktionsaufrufe

Verwenden Sie Funktionsaufrufe, wenn das Modell mit externen Systemen oder APIs interagieren soll, die Sie verwalten. Verwenden Sie diese Funktion für Aufgaben wie das Prüfen einer Datenbank, das Senden einer E‑Mail oder die Interaktion mit einer benutzerdefinierten API. Die Gemini Live API unterstützt asynchrone Funktionsaufrufe. Weitere Informationen finden Sie unter Asynchrone Funktionsaufrufe mit der Gemini Live API.

Das Modell generiert einen Funktionsaufruf, Ihre Anwendung führt den Code aus und sendet die Ergebnisse zurück an das Modell.

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 der Einrichtungsnachricht in die Liste tools ein:

Python

import asyncio

from google import genai
from google.genai.types import (
    Content,
    LiveConnectConfig,
    Part,
)

# Initialize the client.
client = genai.Client(
    enterprise=True,
    project="GOOGLE_CLOUD_PROJECT",  # Replace with your project ID
    location="LOCATION",  # Replace with your location
)

MODEL_ID = "gemini-3.8-live"


def get_current_weather(location: str) -> str:
    """Example method. Returns the current weather.

    Args:
        location: The city and state, e.g. San Francisco, CA
    """
    weather_map: dict[str, str] = {
        "Boston, MA": "snowing",
        "San Francisco, CA": "foggy",
        "Seattle, WA": "raining",
        "Austin, TX": "hot",
        "Chicago, IL": "windy",
    }
    return weather_map.get(location, "unknown")


async def main():
    config = LiveConnectConfig(
        response_modalities=["AUDIO"],
        tools=[get_current_weather],
    )

    async with client.aio.live.connect(
        model=MODEL_ID,
        config=config,
    ) as session:
        text_input = "Get the current weather in Boston."
        print(f"Input: {text_input}")

        await session.send_realtime_input(text=text_input)
        )

        async for message in session.receive():
            if message.tool_call:
                function_responses = []
                for function_call in message.tool_call.function_calls:
                    print(f"FunctionCall > {function_call}")
                    # Execute the tool and send the response back to the model.
                    result = get_current_weather(**function_call.args)
                    function_responses.append(
                        {
                            "name": function_call.name,
                            "response": {"result": result},
                            "id": function_call.id,
                        }
                    )
                if function_responses:
                    await session.send_tool_response(function_responses=function_responses)


if __name__ == "__main__":
    asyncio.run(main())

Beispiele für die Verwendung von Funktionsaufrufen in Systemanweisungen finden Sie im Best Practices-Beispiel.

MCP-Tools (Model Context Protocol)

Das Google Gen AI SDK führt MCP-Tool-Aufrufe (Model Context Protocol) in Gemini Live API-Sitzungen nicht automatisch aus. Wenn Sie MCP-Tools in einer Gemini Live API-Sitzung verwenden möchten, haben Sie folgende Möglichkeiten:

  • MCP-Toolaufrufe direkt verwalten: Wenn Sie das Google Gen AI SDK direkt verwenden, muss Ihre Anwendung die MCP-Clientsitzung verwalten, Toolaufrufe ausführen, wenn das Modell dies anfordert, und die Ergebnisse mit send_tool_response zurückgeben.
  • Agent Development Kit (ADK) verwenden: Verwenden Sie die Klasse McpToolset im ADK, die eine integrierte MCP-Integration für die Gemini Live API bietet. Das ADK erkennt automatisch Tools von Ihrem MCP-Server, konvertiert deren Schemas in Funktionsdeklarationen, führt MCP-Toolaufrufe während des bidirektionalen Streams aus und sendet die Toolantworten zurück an das Modell.

MCP-Tools mit ADK verwenden

So können Sie das ADK verwenden, um MCP-Tools mit der Gemini Live API zu verbinden:

  1. Installieren Sie das Paket google-adk mit dem Extra mcp:

    pip install "google-adk[mcp]"

  2. Erstellen Sie ein Script mit dem Namen live_mcp_example.py, das McpToolset über StreamableHTTPConnectionParams mit Ihrem MCP-Dienst verbindet und Ereignisse über runner.run_live() streamt.

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Projekt-ID in Google Cloud .
    • MCP_SERVER_URL: Die URL Ihres Streamable HTTP-MCP-Servers (z. B. http://127.0.0.1:8765/mcp).
    import asyncio
import contextlib
import os

from google.adk.agents import Agent, LiveRequestQueue, RunConfig
from google.adk.agents.run_config import StreamingMode
from google.adk.runners import InMemoryRunner
from google.adk.tools.mcp_tool import McpToolset, StreamableHTTPConnectionParams
from google.genai import types

os.environ.setdefault("GOOGLE_GENAI_USE_ENTERPRISE", "TRUE")
os.environ.setdefault("GOOGLE_CLOUD_PROJECT", "PROJECT_ID")
os.environ.setdefault("GOOGLE_CLOUD_LOCATION", "us-central1")

async def main() -> None:
  # 1. Connect to the Streamable HTTP MCP service
  mcp_toolset = McpToolset(
      connection_params=StreamableHTTPConnectionParams(
          url="MCP_SERVER_URL",
      )
  )

  # 2. Create the ADK Agent with a Gemini Live model and the MCP toolset
  agent = Agent(
      name="mcp_live_agent",
      model="gemini-3.8-live",
      instruction="You are a helpful assistant. Use the provided MCP tools when needed.",
      tools=[mcp_toolset],
  )

  runner = InMemoryRunner(agent=agent, app_name="mcp_live_demo")
  session = await runner.session_service.create_session(
      app_name="mcp_live_demo",
      user_id="user_1",
  )

  # 3. Configure bidirectional streaming and send a prompt
  live_request_queue = LiveRequestQueue()
  run_config = RunConfig(
      streaming_mode=StreamingMode.BIDI,
      response_modalities=[types.Modality.AUDIO],
      output_audio_transcription=types.AudioTranscriptionConfig(),
  )

  live_request_queue.send_content(
      types.Content(
          role="user",
          parts=[types.Part.from_text(text="What is the weather in Paris?")],
      )
  )

  # 4. Stream Live events (ADK automatically executes MCP tools)
  awaiting_post_tool_response = False
  saw_function_response = False
  has_model_output = False

  try:
    async with contextlib.aclosing(
        runner.run_live(
            user_id="user_1",
            session_id=session.id,
            live_request_queue=live_request_queue,
            run_config=run_config,
        )
    ) as live_events:
      async for event in live_events:
        for call in event.get_function_calls():
          print(f"[MCP Tool Call] {call.name}({call.args})")
          awaiting_post_tool_response = True
          saw_function_response = False
          has_model_output = False

        for resp in event.get_function_responses():
          print(f"[MCP Tool Response] {resp.name} -> {resp.response}")
          saw_function_response = True

        if event.output_transcription and event.output_transcription.text:
          if not awaiting_post_tool_response or saw_function_response:
            has_model_output = True
            awaiting_post_tool_response = False
          if event.output_transcription.finished:
            print(f"[Transcript] {event.output_transcription.text}")

        # Wait for the final response turn after tool execution completes
        if event.turn_complete:
          if awaiting_post_tool_response or not has_model_output:
            continue
          live_request_queue.close()
          break
  finally:
    await mcp_toolset.close()
    await runner.close()

if __name__ == "__main__":
  asyncio.run(main())

Verwenden Sie die Fundierung mit der Google Suche, wenn das Modell genauere und faktische Antworten liefern soll, indem es sie an überprüfbaren Informationsquellen verankert. Verwenden Sie diese Option für Aufgaben wie die Websuche.

Im Gegensatz zum Funktionsaufruf wird das Abrufen von Informationen bei der serverseitigen Integration automatisch gehandhabt.

Wenn Sie die Fundierung mit der Google Suche aktivieren möchten, fügen Sie google_search in der Einrichtungsnachricht in die Liste tools ein:

Python

import asyncio

from google import genai
from google.genai.types import (
    Content,
    LiveConnectConfig,
    Part,
)

# Initialize the client.
client = genai.Client(
    enterprise=True,
    project="GOOGLE_CLOUD_PROJECT",  # Replace with your project ID
    location="LOCATION",  # Replace with your location
)

MODEL_ID = "gemini-3.8-live"


async def main():
    config = LiveConnectConfig(
        response_modalities=["AUDIO"],
        tools=[{"google_search": {}}],
    )

    async with client.aio.live.connect(
        model=MODEL_ID,
        config=config,
    ) as session:
        text_input = "What is the current weather in Toronto, Canada?"
        print(f"Input: {text_input}")

        await session.send_realtime_input(text=text_input)

        async for message in session.receive():
            # Consume the messages from the model.
            # In native audio, the model response is in audio format.
            pass


if __name__ == "__main__":
    asyncio.run(main())

Empathischen Dialog konfigurieren

Die Konfiguration des empathischen Dialogs ist nur für gemini-live-2.5-flash-native-audio erforderlich. Dieser Abschnitt gilt nicht für gemini-3.8-live.

Wenn Affektiver Dialog aktiviert ist, versucht das Modell, den Tonfall und die emotionalen Äußerungen des Nutzers zu verstehen und darauf zu reagieren.

Wenn Sie den empathischen Dialog aktivieren möchten, setzen Sie enable_affective_dialog in der Einrichtungsnachricht auf true:

Python

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

Proaktive Audioeingabe konfigurieren

Die proaktive Audiokonfiguration ist nur für gemini-live-2.5-flash-native-audio erforderlich. Die proaktive Audioeingabe ist in gemini-3.8-live enthalten.

Mit der Funktion „Proaktives Audio“ können Sie festlegen, wann das Modell antwortet. Sie können Gemini beispielsweise auffordern, nur zu antworten, wenn Sie einen Prompt eingeben oder wenn bestimmte Themen besprochen werden. Eine Videodemonstration von Proactive Audio finden Sie unter Gemini LiveAPI Native Audio Preview.

So aktivieren Sie die proaktive Audioeingabe: Konfigurieren Sie das Feld proactivity in der Einrichtungsmitteilung und legen Sie proactive_audio auf true fest:

Python

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

Beispiel für eine Unterhaltung

Hier ist ein Beispiel dafür, wie eine Unterhaltung mit Gemini über das Kochen aussehen könnte:

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 triggers response from Gemini.)
Gemini Live API: "I'd be happy to help! Here's a recipe for a pizza."

Gängige Anwendungsfälle

So funktioniert die proaktive Audiofunktion mit Gemini:

  • Antwortet mit minimaler Latenz: Gemini antwortet, nachdem der Nutzer mit dem Sprechen fertig ist. So werden Unterbrechungen reduziert und Gemini verliert nicht den Kontext, wenn es doch zu einer Unterbrechung kommt.
  • Vermeidet Unterbrechungen: Proactive Audio hilft Gemini, Unterbrechungen durch Hintergrundgeräusche oder Gespräche zu vermeiden. Außerdem wird verhindert, dass Gemini antwortet, wenn während einer Unterhaltung Gespräche geführt werden.
  • Unterbrechungen werden berücksichtigt: Wenn der Nutzer während einer Antwort von Gemini unterbrechen muss, kann Gemini durch Proactive Audio leichter angemessen reagieren (d. h. angemessene Unterbrechungen werden berücksichtigt), als wenn ein Nutzer Füllwörter wie ähm oder äh verwendet.
  • Hört Audioinhalte mit: Gemini kann sich eine Audiodatei anhören, die nicht die Stimme des Sprechers enthält, und später in der Unterhaltung Fragen zu dieser Audiodatei beantworten.

Abrechnung

Während Gemini einer Unterhaltung zuhört, werden Audio-Tokens für die Eingabe berechnet.

Für Audio-Ausgabetokens werden Ihnen nur Kosten in Rechnung gestellt, wenn Gemini antwortet. Wenn Gemini nicht reagiert oder stumm bleibt, werden Ihnen keine Audio-Ausgabetokens berechnet.

Weitere Informationen finden Sie unter Preise für die Agent Platform.

Nächste Schritte

Weitere Informationen zur Verwendung der Gemini Live API finden Sie hier: