הגדרת היכולות של Gemini

במאמר הזה מוסבר איך להגדיר יכולות שונות של מודלים של Gemini כשמשתמשים ב-Gemini Live API. אתם יכולים להגדיר שימוש בכלים כמו קריאה להפעלת פונקציות ועיגון, ויכולות אודיו בזמן אמת כמו שיחה מותאמת-רגש וסינון אודיו יזום.

הגדרת השימוש בכלי

יש כמה כלים שתואמים לגרסאות שונות של מודלים שנתמכים על ידי Gemini Live API, כולל:

כדי להפעיל כלי מסוים לשימוש בתשובות שמתקבלות, צריך לכלול את שם הכלי ברשימה tools כשמפעילים את המודל. בקטעים הבאים מופיעות דוגמאות לשימוש בכל אחד מהכלים המובנים בקוד.

חשוב: Gemini API לא תומך בשילוב של כלי חיפוש (כמו googleSearch) עם כלים אחרים (כמו קריאה לפונקציות או כלי RAG של Gemini Enterprise Agent Platform‏ retrieval) באותה בקשת הגדרה. אפשר להשתמש בכמה כלים רק אם כולם כלים לחיפוש.

בקשה להפעלת פונקציה

כדאי להשתמש בבקשות להפעלת פונקציות כשרוצים שהמודל יקיים אינטראקציה עם מערכות חיצוניות או עם ממשקי API שאתם מנהלים. אפשר להשתמש בו למשימות כמו בדיקת מסד נתונים, שליחת אימייל או אינטראקציה עם API מותאם אישית. ממשק Gemini Live API תומך בבקשות אסינכרוניות להפעלת פונקציות. מידע נוסף זמין במאמר קריאה אסינכרונית לפונקציות באמצעות Gemini Live API.

המודל יוצר קריאה לפונקציה, והאפליקציה מריצה את הקוד ושולחת את התוצאות בחזרה למודל.

צריך להצהיר על כל הפונקציות בתחילת הסשן על ידי שליחת הגדרות כלי כחלק מההודעה LiveConnectConfig.

כדי להפעיל את התכונה 'הפעלת פונקציות', צריך לכלול את function_declarations ברשימה tools בהודעת ההגדרה:

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

דוגמאות לשימוש בקריאות לפונקציות בהוראות מערכת מפורטות בדוגמה לשיטות מומלצות.

כלי Model Context Protocol‏ (MCP)

‫Google Gen AI SDK לא מריץ אוטומטית קריאות לכלים של Model Context Protocol‏ (MCP) בסשנים של Gemini Live API. כדי להשתמש בכלים של MCP בסשן של Gemini Live API, אתם יכולים להשתמש באחת מהגישות הבאות:

  • ניהול ישיר של קריאות לכלים של MCP: אם אתם משתמשים ישירות ב-Google Gen AI SDK, האפליקציה שלכם צריכה לנהל את סשן הלקוח של MCP, להפעיל קריאות לכלים כשמתקבלת בקשה מהמודל ולהחזיר את התוצאות באמצעות send_tool_response.
  • שימוש בערכה לפיתוח סוכנים (ADK): אפשר להשתמש במחלקה McpToolset ב-ADK, שמספקת שילוב מובנה של MCP עם Gemini Live API. ‫ADK מגלה באופן אוטומטי כלים משרת ה-MCP, ממיר את הסכימות שלהם להצהרות פונקציות, מריץ קריאות לכלים של MCP במהלך הזרם הדו-כיווני ושולח את התשובות של הכלים בחזרה למודל.

שימוש בכלי MCP עם ADK

אתם יכולים להשתמש ב-ADK כדי לחבר כלי MCP ל-Gemini Live API באמצעות השלבים הבאים:

  1. מתקינים את חבילת google-adk עם התוסף mcp:

    pip install "google-adk[mcp]"

  2. יוצרים סקריפט בשם live_mcp_example.py שמתחבר אל McpToolset באמצעות StreamableHTTPConnectionParams ומזרים אירועים באמצעות runner.run_live().

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .
    • ‫MCP_SERVER_URL: כתובת ה-URL של שרת ה-MCP של Streamable HTTP (לדוגמה, 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())

משתמשים בעיגון באמצעות חיפוש Google כשרוצים שהמודל יספק תשובות מדויקות ועובדתיות יותר על ידי עיגון שלהן למקורות מידע שאפשר לאמת. אפשר להשתמש בהם למשימות כמו חיפוש באינטרנט.

בשונה מבקשה להפעלת פונקציה, השילוב בצד השרת מטפל באחזור המידע באופן אוטומטי.

כדי להפעיל את התכונה עיגון באמצעות חיפוש Google, צריך לכלול את google_search ברשימה tools בהודעת ההגדרה:

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

הגדרת שיחה מותאמת-רגש

הגדרת שיחה מותאמת-רגש נדרשת רק עבור gemini-live-2.5-flash-native-audio. הקטע הזה לא רלוונטי ל-gemini-3.8-live.

כשהתכונה דיאלוג רגשי מופעלת, המודל מנסה להבין ולהגיב על סמך טון הדיבור והבעות הפנים של המשתמש.

כדי להפעיל את Affective Dialog, מגדירים את enable_affective_dialog לערך true בהודעת ההגדרה:

Python

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

הגדרת סינון אודיו יזום

הגדרה פרואקטיבית של אודיו נדרשת רק עבור gemini-live-2.5-flash-native-audio. סינון אודיו יזום כלול ב-gemini-3.8-live.

התכונה 'אודיו פרואקטיבי' מאפשרת לכם לקבוע מתי המודל יגיב. לדוגמה, אתם יכולים לבקש מ-Gemini לענות רק כשאתם נותנים לו הנחיה או כשמדברים על נושאים ספציפיים. כדי לראות הדגמה של אודיו פרואקטיבי, אפשר לצפות בתצוגה מקדימה של אודיו מקורי ב-Gemini Live API.

כדי להפעיל את התכונה 'הצעות שימושיות באודיו', צריך להגדיר את השדה proactivity בהודעת ההגדרה ולהגדיר את proactive_audio לערך true:

Python

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

דוגמה לשיחה

הנה דוגמה לשיחה עם Gemini בנושא בישול:

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."

תרחישים נפוצים לדוגמה

כשמשתמשים באודיו פרואקטיבי, Gemini פועל באופן הבא:

  • תגובה עם השהיה מינימלית: Gemini מגיב אחרי שהמשתמש מסיים לדבר, וכך מצמצם את ההפרעות ועוזר ל-Gemini לא לאבד את ההקשר אם מתרחשת הפרעה.
  • מניעת הפרעות: אודיו פרואקטיבי עוזר ל-Gemini להימנע מהפרעות מרעשי רקע או מרעשים חיצוניים, ומונע מ-Gemini להגיב אם נשמעים רעשים חיצוניים במהלך שיחה.
  • טיפול בהפרעות: אם המשתמש צריך להפריע במהלך תשובה מ-Gemini, אודיו פרואקטיבי מקל על Gemini לנהל שיחה מקבילה בצורה מתאימה (כלומר, מטפל בהפרעות מתאימות), במקום שהמשתמש ישתמש במילות מילוי כמו אה או הממ.
  • האזנה משותפת לאודיו: Gemini יכול להאזין יחד עם המשתמש לקובץ אודיו שבו לא נשמע הקול של המשתמש, ואז לענות על שאלות לגבי קובץ האודיו הזה בהמשך השיחה.

חיוב

בזמן ש-Gemini מאזין לשיחה, נגבים תשלום על טוקנים של קלט אודיו.

במקרה של טוקנים של אודיו פלט, החיוב מתבצע רק כש-Gemini מגיב. אם Gemini לא מגיב או לא משמיע קול, לא נחייב אתכם על טוקני האודיו של הפלט.

למידע נוסף על התמחור של Agent Platform

המאמרים הבאים

מידע נוסף על שימוש ב-Gemini Live API: