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 Toolnutzung wie Funktionsaufrufe und Fundierung sowie Live-Audiofunktionen wie empathische Dialoge und proaktive Audioeingabe konfigurieren.

Toolnutzung konfigurieren

Mehrere Tools sind mit verschiedenen Versionen von Gemini Live API-unterstützten Modellen kompatibel, darunter:

Wenn Sie ein bestimmtes Tool in zurückgegebenen Antworten verwenden 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. Funktionsaufrufe oder das Tool retrieval der Gemini Enterprise Agent Platform RAG Engine) in derselben Einrichtungsanfrage. Mehrere Tools werden nur unterstützt, wenn es sich ausschließlich 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 Gemini Live API.

Das Modell generiert einen Funktionsaufruf und 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 Sie Tooldefinitionen als Teil der Nachricht LiveConnectConfig senden.

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 Beispiel für Best Practices.

MCP-Tools (Model Context Protocol)

Das Google Gen AI SDK führt MCP-Toolaufrufe (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, Tool aufrufe ausführen, wenn das Modell dies anfordert, und die Ergebnisse mit send_tool_response zurückgeben.
  • Das Agent Development Kit (ADK) verwenden: Verwenden Sie die McpToolset Klasse im ADK, die eine integrierte MCP Integration für die Gemini Live API bietet. Das ADK erkennt automatisch Tools von Ihrem MCP-Server, konvertiert ihre 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 dem ADK verwenden

Mit dem ADK können Sie MCP-Tools mit der Gemini Live API verbinden. Gehen Sie dazu so vor:

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

    pip install "google-adk[mcp]"

  2. Erstellen Sie ein Skript mit dem Namen live_mcp_example.py, das McpToolset mit Ihrem MCP-Dienst verbindet. Verwenden Sie dazu StreamableHTTPConnectionParams und streamen Sie Ereignisse mit runner.run_live().

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Ihre Google Cloud Projekt-ID.
    • MCP_SERVER_URL: URL Ihres streamfähigen 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 Fundierung mit der Google Suche, wenn das Modell genauere und sachlichere Antworten geben soll, indem es sie mit überprüfbaren Informationsquellen verknüpft. Verwenden Sie diese Funktion für Aufgaben wie die Websuche.

Im Gegensatz zu Funktionsaufrufen wird das Abrufen von Informationen automatisch durch die serverseitige Integration verarbeitet.

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 Empathischer 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 Konfiguration der proaktiven Audioeingabe ist nur für gemini-live-2.5-flash-native-audio erforderlich. Die proaktive Audioeingabe ist in gemini-3.8-live enthalten.

Mit der proaktiven Audioeingabe können Sie steuern, wann das Modell antwortet. Sie können Gemini beispielsweise auffordern, nur zu antworten, wenn Sie dazu aufgefordert werden oder wenn bestimmte Themen besprochen werden. Eine Videodemonstration der proaktiven Audioeingabe finden Sie unter Gemini Live API Native Audio Preview.

Wenn Sie die proaktive Audioeingabe aktivieren möchten, konfigurieren Sie das Feld proactivity in der Einrichtungsnachricht und setzen Sie proactive_audio auf true:

Python

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

Beispiel für eine Unterhaltung

Das folgende Beispiel zeigt, 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

Bei Verwendung der proaktiven Audioeingabe verhält sich Gemini so:

  • Antwortet mit minimaler Latenz: Gemini antwortet, nachdem der Nutzer mit dem Sprechen fertig ist. So werden Unterbrechungen reduziert und Gemini verliert den Kontext nicht, wenn es zu einer Unterbrechung kommt.
  • Vermeidet Unterbrechungen: Die proaktive Audioeingabe hilft Gemini, Unterbrechungen durch Hintergrundgeräusche oder externe Gespräche zu vermeiden. Außerdem verhindert sie, dass Gemini antwortet, wenn während einer Unterhaltung externe Gespräche geführt werden.
  • Verarbeitet Unterbrechungen: Wenn der Nutzer während einer Antwort von Gemini unterbrechen muss, kann Gemini mit der proaktiven Audioeingabe besser angemessen reagieren (d. h. angemessene Unterbrechungen werden verarbeitet), als wenn ein Nutzer Füllwörter wie äh oder hm verwendet.
  • Hört Audio 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 Audioeingabetokens in Rechnung gestellt.

Für Audioausgabetokens werden nur Kosten berechnet, wenn Gemini antwortet. Wenn Gemini nicht antwortet oder schweigt, werden keine Kosten für Ihre Audioausgabetokens berechnet.

Weitere Informationen finden Sie unter Agent Platform – Preise.

Nächste Schritte

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