הפניית API של Gemini Live

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

מידע נוסף על Gemini Live API זמין במאמר בנושא Gemini Live API.

יכולות

‫Gemini Live API כולל את היכולות העיקריות הבאות:

  • Multimodality: המודל יכול לראות, לשמוע ולדבר.
  • אינטראקציה בזמן אמת עם השהיה נמוכה: המודל יכול לספק תשובות מהירות.
  • זיכרון סשן: המודל שומר בזיכרון את כל האינטראקציות בסשן יחיד, ומזכיר לעצמו מידע ששמע או ראה בעבר.
  • תמיכה בהפעלת פונקציות, בהרצת קוד ובחיפוש ככלי: אתם יכולים לשלב את המודל עם שירותים חיצוניים ומקורות נתונים.

ממשק Gemini Live API מיועד לתקשורת בין שרתים.

באפליקציות לאינטרנט ולנייד, מומלץ להשתמש בשילוב של השותפים שלנו ב-Daily.

מודלים נתמכים

קדימה, מתחילים

כדי לנסות את Gemini Live API, עוברים אל Vertex AI Studio ולוחצים על Start Session (התחלת סשן).

‫Gemini Live API הוא API עם שמירת מצב שמשתמש ב-WebSockets.

בקטע הזה מוצגת דוגמה לשימוש ב-Gemini Live API ליצירת טקסט על סמך טקסט, באמצעות Python 3.9 ואילך.

Python

התקנה

pip install --upgrade google-genai

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Gen AI SDK עם Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 

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

client = genai.Client(http_options=HttpOptions(api_version="v1beta1"))
model_id = "gemini-2.0-flash-live-preview-04-09"

async with client.aio.live.connect(
    model=model_id,
    config=LiveConnectConfig(response_modalities=[Modality.TEXT]),
) as session:
    text_input = "Hello? Gemini, are you there?"
    print("> ", text_input, "\n")
    await session.send_client_content(
        turns=Content(role="user", parts=[Part(text=text_input)])
    )

    response = []

    async for message in session.receive():
        if message.text:
            response.append(message.text)

    print("".join(response))
# Example output:
# >  Hello? Gemini, are you there?
# Yes, I'm here. What would you like to talk about?

Go

כך מתקינים או מעדכנים את Go.

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Gen AI SDK עם Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/genai"
)

// generateLiveWithText demonstrates using a live Gemini model
// that performs live with text and handles responses.
func generateLiveWithText(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	modelName := "gemini-2.0-flash-live-preview-04-09"

	config := &genai.LiveConnectConfig{
		ResponseModalities: []genai.Modality{genai.ModalityText},
	}

	// Open a live session
	session, err := client.Live.Connect(ctx, modelName, config)
	if err != nil {
		return fmt.Errorf("failed to connect live: %w", err)
	}
	defer session.Close()

	// Prepare the input message
	inputText := "Hello? Gemini, are you there?"
	fmt.Fprintf(w, "> %s\n\n", inputText)

	// Send text content to the model
	err = session.SendClientContent(genai.LiveClientContentInput{
		Turns: []*genai.Content{
			{
				Role: genai.RoleUser,
				Parts: []*genai.Part{
					{Text: inputText},
				},
			},
		},
	})
	if err != nil {
		return fmt.Errorf("failed to send content: %w", err)
	}

	// Stream the response
	var response string
	for {
		chunk, err := session.Receive()
		if err != nil {
			if err == io.EOF {
				break
			}
			return fmt.Errorf("error receiving response: %w", err)
		}

		if chunk.ServerContent != nil && chunk.ServerContent.ModelTurn != nil {
			for _, part := range chunk.ServerContent.ModelTurn.Parts {
				if part.Text != "" {
					response += part.Text
				}
			}
		}
	}

	// Example output:
	//  >  Hello? Gemini are you there?
	//  Yes, I'm here. What would you like to talk about?
	fmt.Fprintln(w, response)
	return nil
}

Node.js

התקנה

npm install @google/genai

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Gen AI SDK עם Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 


'use strict';

const {GoogleGenAI, Modality} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';

async function generateLiveConversation(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const modelId = 'gemini-2.0-flash-live-preview-04-09';
  const config = {responseModalities: [Modality.TEXT]};

  const responseQueue = [];

  async function waitMessage() {
    while (responseQueue.length === 0) {
      await new Promise(resolve => setTimeout(resolve, 100));
    }
    return responseQueue.shift();
  }

  async function handleTurn() {
    const turns = [];
    let done = false;
    while (!done) {
      const message = await waitMessage();
      turns.push(message);
      if (message.serverContent && message.serverContent.turnComplete) {
        done = true;
      }
    }
    return turns;
  }

  const session = await client.live.connect({
    model: modelId,
    config: config,
    callbacks: {
      onmessage: msg => responseQueue.push(msg),
      onerror: e => console.error('Error:', e.message),
    },
  });

  const textInput = 'Hello? Gemini, are you there?';
  console.log('> ', textInput, '\n');

  await session.sendClientContent({
    turns: [{role: 'user', parts: [{text: textInput}]}],
  });

  const turns = await handleTurn();
  for (const turn of turns) {
    if (turn.text) {
      console.log('Received text:', turn.text);
    }
  }
  // Example output:
  //> Hello? Gemini, are you there?
  // Received text: Yes
  // Received text: I'm here. How can I help you today?
  session.close();
  return turns;
}

Java

כך מתקינים או מעדכנים את Java.

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Gen AI SDK עם Vertex AI: 

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True
 


import static com.google.genai.types.Modality.Known.TEXT;

import com.google.genai.AsyncSession;
import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.LiveConnectConfig;
import com.google.genai.types.LiveSendClientContentParameters;
import com.google.genai.types.LiveServerContent;
import com.google.genai.types.LiveServerMessage;
import com.google.genai.types.Part;
import java.util.concurrent.CompletableFuture;

public class LiveWithTxt {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.0-flash-live-preview-04-09";
    generateContent(modelId);
  }

  // Shows how to send a text prompt and receive messages from the live session.
  public static String generateContent(String modelId) {
    // Client Initialization. Once created, it can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("us-central1")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1beta1").build())
            .build()) {

      // Connects to the live server.
      CompletableFuture<AsyncSession> sessionFuture =
          client.async.live.connect(
              modelId, LiveConnectConfig.builder().responseModalities(TEXT).build());

      // Sends and receives messages from the live session.
      CompletableFuture<String> responseFuture =
          sessionFuture.thenCompose(
              session -> {
                // A future that completes when the model signals the end of its turn.
                CompletableFuture<Void> turnComplete = new CompletableFuture<>();
                // A variable to concatenate the text response from the model.
                StringBuilder modelResponse = new StringBuilder();
                // Starts receiving messages from the live session.
                session.receive(
                    message -> handleLiveServerMessage(message, turnComplete, modelResponse));
                // Sends content to the live session and waits for the turn to complete.
                return sendContent(session)
                    .thenCompose(unused -> turnComplete)
                    .thenCompose(
                        unused -> session.close().thenApply(result -> modelResponse.toString()));
              });

      String response = responseFuture.join();
      System.out.println(response);
      // Example output:
      // > Hello? Gemini, are you there?
      //
      // Yes, I am here. How can I help you today?
      return response;
    }
  }

  // Sends content to the live session.
  private static CompletableFuture<Void> sendContent(AsyncSession session) {
    String textInput = "Hello? Gemini, are you there?";
    System.out.printf("> %s\n", textInput);
    return session.sendClientContent(
        LiveSendClientContentParameters.builder()
            .turns(Content.builder().role("user").parts(Part.fromText(textInput)).build())
            .turnComplete(true)
            .build());
  }

  // Concatenates the output transcription from the model and signals
  // `turnComplete` when the model is done generating the response.
  private static void handleLiveServerMessage(
      LiveServerMessage message, CompletableFuture<Void> turnComplete, StringBuilder response) {
    message
        .serverContent()
        .flatMap(LiveServerContent::modelTurn)
        .flatMap(Content::parts)
        .ifPresent(parts -> parts.forEach(part -> part.text().ifPresent(response::append)));
    // Checks if the model's turn is over.
    if (message.serverContent().flatMap(LiveServerContent::turnComplete).orElse(false)) {
      turnComplete.complete(null);
    }
  }
}

מדריך שילוב

בקטע הזה מוסבר איך השילוב עובד עם Gemini Live API.

סשנים

חיבור WebSocket יוצר סשן בין הלקוח לבין שרת Gemini.

אחרי שהלקוח יוזם חיבור חדש, הסשן יכול להעביר הודעות עם השרת כדי:

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

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

לדוגמה, ההגדרה הבאה:


{
  "model": string,
  "generationConfig": {
    "candidateCount": integer,
    "maxOutputTokens": integer,
    "temperature": number,
    "topP": number,
    "topK": integer,
    "presencePenalty": number,
    "frequencyPenalty": number,
    "responseModalities": [string],
    "speechConfig": object
  },

  "systemInstruction": string,
  "tools": [object]
}

מידע נוסף זמין במאמר BidiGenerateContentSetup.

שליחת הודעות

ההודעות הן אובייקטים בפורמט JSON שמועברים דרך חיבור WebSocket.

כדי לשלוח הודעה, הלקוח צריך לשלוח אובייקט JSON דרך חיבור WebSocket פתוח. אובייקט ה-JSON חייב להכיל בדיוק אחד מהשדות מתוך קבוצת האובייקטים הבאה:


{
  "setup": BidiGenerateContentSetup,
  "clientContent": BidiGenerateContentClientContent,
  "realtimeInput": BidiGenerateContentRealtimeInput,
  "toolResponse": BidiGenerateContentToolResponse
}

הודעות לעסק שנתמכות

בטבלה הבאה מפורטות הודעות הלקוח הנתמכות:

הודעה תיאור
BidiGenerateContentSetup הגדרת הסשן שתישלח בהודעה הראשונה
BidiGenerateContentClientContent עדכון מצטבר של תוכן השיחה הנוכחית שמועבר מהלקוח
BidiGenerateContentRealtimeInput קלט אודיו או וידאו בזמן אמת
BidiGenerateContentToolResponse תגובה ל-ToolCallMessage שהתקבלה מהשרת

קבלת הודעות

כדי לקבל הודעות מ-Gemini, צריך להאזין לאירוע 'message' של WebSocket, ואז לנתח את התוצאה בהתאם להגדרה של הודעות השרת הנתמכות.

תוכלו לעיין במקורות המידע הבאים:

ws.addEventListener("message", async (evt) => {
  if (evt.data instanceof Blob) {
    // Process the received data (audio, video, etc.)
  } else {
    // Process JSON response
  }
});

הודעות מהשרת יכללו בדיוק אחד מהשדות מתוך קבוצת האובייקטים הבאה:


{
  "setupComplete": BidiGenerateContentSetupComplete,
  "serverContent": BidiGenerateContentServerContent,
  "toolCall": BidiGenerateContentToolCall,
  "toolCallCancellation": BidiGenerateContentToolCallCancellation
  "usageMetadata": UsageMetadata
  "goAway": GoAway
  "sessionResumptionUpdate": SessionResumptionUpdate
  "inputTranscription": BidiGenerateContentTranscription
  "outputTranscription": BidiGenerateContentTranscription
}

הודעות נתמכות מהשרת

בטבלה הבאה מפורטות הודעות השרת הנתמכות:

הודעה תיאור
BidiGenerateContentSetupComplete הודעה מBidiGenerateContentSetup מהלקוח, שנשלחת בסיום ההגדרה
BidiGenerateContentServerContent תוכן שנוצר על ידי המודל בתגובה להודעה של לקוח
BidiGenerateContentToolCall בקשה מהלקוח להפעיל את הקריאות לפונקציות ולהחזיר את התשובות עם המזהים התואמים
BidiGenerateContentToolCallCancellation האירוע נשלח כשבקשה להפעלת פונקציה מבוטלת כי המשתמש קוטע את הפלט של המודל
UsageMetadata דוח על מספר האסימונים שנעשה בהם שימוש בסשן עד עכשיו
GoAway אות לכך שהחיבור הנוכחי יסתיים בקרוב
SessionResumptionUpdate נקודת ביקורת של סשן, שאפשר לחזור אליה
BidiGenerateContentTranscription תמליל של הדיבור של המשתמש או של המודל

עדכונים מצטברים של תוכן

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

הנה הודעת הקשר לדוגמה:

{
  "clientContent": {
    "turns": [
      {
          "parts":[
          {
            "text": ""
          }
        ],
        "role":"user"
      },
      {
          "parts":[
          {
            "text": ""
          }
        ],
        "role":"model"
      }
    ],
    "turnComplete": true
  }
}

הערה: אמנם חלקי תוכן יכולים להיות מסוג functionResponse, אבל לא מומלץ להשתמש ב-BidiGenerateContentClientContent כדי לספק תשובה לקריאות לפונקציות שהמודל מנפיק. במקומה, צריך להשתמש ב-BidiGenerateContentToolResponse. BidiGenerateContentClientContent צריך לשמש רק כדי ליצור הקשר קודם או כדי לספק קלט טקסט לשיחה.

סטרימינג של אודיו ווידאו

הרצת קוד

מידע נוסף על הרצת קוד זמין במאמר בנושא הרצת קוד.

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

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

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

  • ‫name (מחרוזת): המזהה הייחודי של הפונקציה בקריאה ל-API.

  • ‫description (מחרוזת): הסבר מקיף על המטרה והיכולות של הפונקציה.

  • parameters (אובייקט): מגדיר את נתוני הקלט שנדרשים לפונקציה.

    • ‫type (מחרוזת): מציין את סוג הנתונים הכולל, למשל object.

    • ‫properties (אובייקט): רשימה של פרמטרים בודדים, כל אחד עם:

      • ‫type (מחרוזת): סוג הנתונים של הפרמטר, כמו מחרוזת, מספר שלם, ערך בוליאני.
      • ‫description (מחרוזת): הסבר ברור על המטרה של הפרמטר והפורמט הצפוי שלו.

    • ‫required (מערך): מערך של מחרוזות שכולל את שמות הפרמטרים שחובה להזין כדי שהפונקציה תפעל.

דוגמאות לקוד של הצהרת פונקציה באמצעות פקודות curl מופיעות במאמר הפעלת פונקציות באמצעות Gemini API. דוגמאות ליצירת הצהרות על פונקציות באמצעות ערכות ה-SDK של Gemini API מופיעות במדריך בנושא הפעלת פונקציות.

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

הלקוח צריך להגיב עם BidiGenerateContentToolResponse.

מידע נוסף זמין במאמר מבוא לקריאה לפונקציות.

פורמטים של אודיו

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

הוראות מערכת

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

ההוראות למערכת מתווספות להנחיה לפני תחילת האינטראקציה ונשארות בתוקף לאורך כל הסשן.

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

הפרעות

המשתמשים יכולים להפסיק את הפלט של המודל בכל שלב. כשמזוהה הפרעה על ידי זיהוי פעילות קולית (VAD), יצירת התמונה הנוכחית מבוטלת והתמונה נמחקת. רק המידע שכבר נשלח ללקוח נשמר בהיסטוריית הפעילות. השרת שולח הודעת BidiGenerateContentServerContent כדי לדווח על ההפרעה.

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

קולות

כדי לציין קול, מגדירים את voiceName באובייקט speechConfig, כחלק מהגדרת הסשן.

הנה ייצוג JSON של אובייקט speechConfig:

{
  "voiceConfig": {
    "prebuiltVoiceConfig": {
      "voiceName": "VOICE_NAME"
    }
  }
}

כאן אפשר לראות את רשימת הקולות הנתמכים.

מגבלות

כשמתכננים את הפרויקט, חשוב לקחת בחשבון את המגבלות הבאות של Gemini Live API ושל Gemini 2.0.

אימות לקוח

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

משך סשן מקסימלי

ברירת המחדל למשך המקסימלי של סשן שיחה היא 10 דקות. מידע נוסף זמין במאמר בנושא משך ההפעלה.

קצב פריימים של סרטון

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

זיהוי פעילות קולית (VAD)

כברירת מחדל, המודל מבצע באופן אוטומטי זיהוי פעילות קולית (VAD) בזרם רציף של קלט אודיו. אפשר להגדיר את ה-VAD באמצעות השדה RealtimeInputConfig.AutomaticActivityDetection של הודעת ההגדרה.

כשזרם האודיו מושהה למשך יותר משנייה (לדוגמה, כשהמשתמש משבית את המיקרופון), נשלח אירוע AudioStreamEndכדי לנקות את האודיו שנשמר במטמון. הלקוח יכול להמשיך לשלוח נתוני אודיו בכל שלב.

אפשר גם להשבית את ה-VAD האוטומטי על ידי הגדרת RealtimeInputConfig.AutomaticActivityDetection.disabled ל-true בהודעת ההגדרה. בהגדרה הזו, הלקוח אחראי לזיהוי הדיבור של המשתמש ולשליחת ההודעות ActivityStart ו-ActivityEnd בזמנים המתאימים. AudioStreamEnd לא נשלח בהגדרה הזו. במקום זאת, כל הפרעה לשידור מסומנת בהודעה ActivityEnd.

מגבלות נוספות

אין תמיכה בהגדרת נקודות קצה ידנית.

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

ספירת הטוקנים

אין תמיכה בספירת טוקנים.

מגבלות קצב

אלה מגבלות השימוש שחלות:

  • ‫5,000 ביקורים בו-זמניים לכל פרויקט
  • ‫4 מיליון טוקנים בדקה

הודעות ואירועים

BidiGenerateContentClientContent

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

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

שדות
turns[]

Content

זה שינוי אופציונלי. התוכן שמצורף לשיחה הנוכחית עם המודל.

בשביל שאילתות של תור יחיד, זהו מופע יחיד. בשאלות מרובות שלבים, זהו שדה חוזר שמכיל את היסטוריית השיחות והבקשה האחרונה.
turn_complete

bool

זה שינוי אופציונלי. אם הערך הוא true, המשמעות היא שיצירת התוכן בשרת צריכה להתחיל עם ההנחיה שנצברה עד עכשיו. אחרת, השרת ימתין להודעות נוספות לפני שיתחיל ליצור את התמונה.

BidiGenerateContentRealtimeInput

קלט של משתמשים שנשלח בזמן אמת.

יש כמה הבדלים בין ClientContentUpdate לבין:

  • אפשר לשלוח אותם ברציפות בלי להפריע ליצירת המודל.
  • אם יש צורך לשלב נתונים שמופיעים לסירוגין ב-ClientContentUpdate וב-RealtimeUpdate, השרת ינסה לבצע אופטימיזציה כדי לספק את התגובה הטובה ביותר, אבל אין ערובה לכך.
  • סוף התור לא מצוין באופן מפורש, אלא נגזר מפעילות המשתמש (לדוגמה, סוף הדיבור).
  • גם לפני סוף התור, הנתונים מעובדים באופן מצטבר כדי לייעל את תחילת התשובה מהמודל.
  • תמיד נחשב כקלט של המשתמש (אי אפשר להשתמש בו כדי לאכלס את היסטוריית השיחות).
שדות
media_chunks[]

Blob

זה שינוי אופציונלי. נתוני בייטים מוטבעים לקלט מדיה.
activity_start

ActivityStart

זה שינוי אופציונלי. סימון תחילת פעילות משתמש. אפשר לשלוח את הנתונים האלה רק אם השבתתם את זיהוי הפעילות האוטומטי (כלומר, בצד השרת).
activity_end

ActivityEnd

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

ActivityEnd

בסוג הזה אין שדות.

מציין את סוף פעילות המשתמש.

ActivityStart

בסוג הזה אין שדות.

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

BidiGenerateContentServerContent

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

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

שדות
turn_complete

bool

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

bool

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

bool

פלט בלבד. אם הערך הוא True, המשמעות היא שהמודל סיים את היצירה.

אם יש הפרעה ליצירת התוכן על ידי המודל, לא תופיע ההודעה generation_complete בתור שהופרע, והתהליך יהיה interrupted > turn_complete.

כשהמודל מניח שההפעלה מתבצעת בזמן אמת, יהיה עיכוב בין generation_complete לבין turn_complete, כי המודל ימתין עד שההפעלה תסתיים.
grounding_metadata

GroundingMetadata

פלט בלבד. המטא-נתונים מציינים את המקורות ששימשו ליצירת התוכן.
input_transcription

Transcription

זה שינוי אופציונלי. תמלול קלט. התמלול לא תלוי בתור של המודל, כלומר אין סדר מסוים בין התמלול לבין התור של המודל.
output_transcription

Transcription

זה שינוי אופציונלי. תמליל הפלט. התמלול לא תלוי בתור של המודל, כלומר אין סדר מסוים בין התמלול לבין התור של המודל.
model_turn

Content

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

תמלול

הודעה על תמלול אודיו.

שדות
text

string

זה שינוי אופציונלי. טקסט התמלול.
finished

bool

זה שינוי אופציונלי. הערך הבוליאני מציין את סוף התמליל.

BidiGenerateContentSetup

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

הלקוחות צריכים להמתין להודעה BidiGenerateContentSetupComplete לפני שליחת הודעות נוספות.

שדות
model

string

חובה. השם המוגדר במלואו של מודל בעל התוכן הדיגיטלי.

פורמט המודל של בעל התוכן הדיגיטלי: projects/{project}/locations/{location}/publishers/\*/models/\*
generation_config

GenerationConfig

זה שינוי אופציונלי. הגדרות ליצירה.

אין תמיכה בשדות הבאים:

  • response_logprobs
  • response_mime_type
  • logprobs
  • response_schema
  • stop_sequence
  • routing_config
  • audio_timestamp
system_instruction

Content

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

Tool

זה שינוי אופציונלי. רשימה של Tools שהמודל עשוי להשתמש בהם כדי ליצור את התשובה הבאה.

Tool הוא קטע קוד שמאפשר למערכת ליצור אינטראקציה עם מערכות חיצוניות כדי לבצע פעולה או סדרת פעולות, ללא ידיעה או היקף של המודל.
session_resumption

SessionResumptionConfig

זה שינוי אופציונלי. הגדרת מנגנון לחידוש סשן. אם הוא נכלל, השרת ישלח ללקוח הודעות SessionResumptionUpdate תקופתיות.
context_window_compression

ContextWindowCompressionConfig

זה שינוי אופציונלי. הגדרת מנגנון דחיסה של חלון ההקשר.

אם האפשרות הזו נכללת, השרת יכווץ את חלון ההקשר כדי להתאים לאורך שצוין.
realtime_input_config

RealtimeInputConfig

זה שינוי אופציונלי. הגדרת הטיפול בקלט בזמן אמת.
input_audio_transcription

AudioTranscriptionConfig

זה שינוי אופציונלי. התמלול של הקלט תואם לשפה של קלט האודיו.
output_audio_transcription

AudioTranscriptionConfig

זה שינוי אופציונלי. התמליל של הפלט תואם לקוד השפה שצוין לאודיו של הפלט.

AudioTranscriptionConfig

בסוג הזה אין שדות.

הגדרת תמלול האודיו.

BidiGenerateContentSetupComplete

נשלח בתגובה להודעה מלקוח BidiGenerateContentSetup.

שדות
session_id

string

מזהה הסשן של הסשן.

BidiGenerateContentToolCall

בקשה מהלקוח להפעיל את function_calls ולהחזיר את התשובות עם הערכים התואמים של id.

שדות
function_calls[]

FunctionCall

פלט בלבד. הבקשה להפעלת פונקציה שרוצים לבצע.

BidiGenerateContentToolCallCancellation

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

שדות
ids[]

string

פלט בלבד. המזהים של קריאות הכלים שרוצים לבטל.

BidiGenerateContentToolResponse

תגובה שנוצרה על ידי הלקוח ל-ToolCall שהתקבל מהשרת. אובייקטים ספציפיים מסוג FunctionResponse משויכים לאובייקטים המתאימים מסוג FunctionCall באמצעות השדה id.

שימו לב: בממשקי GenerateContent API של unary ושל server-streaming, קריאה לפונקציה מתבצעת על ידי החלפת החלקים Content, ואילו בממשקי GenerateContent API של bidi, קריאה לפונקציה מתבצעת באמצעות קבוצת ההודעות הייעודית הזו.

שדות
function_responses[]

FunctionResponse

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

RealtimeInputConfig

הגדרת התנהגות הקלט בזמן אמת ב-BidiGenerateContent.

שדות
automatic_activity_detection

AutomaticActivityDetection

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

ActivityHandling

זה שינוי אופציונלי. הגדרה של ההשפעה של הפעילות.
turn_coverage

TurnCoverage

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

ActivityHandling

הדרכים השונות לטיפול בפעילות המשתמשים.

טיפוסים בני מנייה (enum)
ACTIVITY_HANDLING_UNSPECIFIED אם לא מציינים ערך, ברירת המחדל היא START_OF_ACTIVITY_INTERRUPTS.
START_OF_ACTIVITY_INTERRUPTS אם הערך הוא True, התחלת הפעילות תקטע את התגובה של המודל (נקראת גם 'התפרצות'). התשובה הנוכחית של המודל תיקטע ברגע ההפרעה. זו התנהגות ברירת המחדל.
NO_INTERRUPTION התשובה של המודל לא תיקטע.

AutomaticActivityDetection

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

שדות
start_of_speech_sensitivity

StartSensitivity

זה שינוי אופציונלי. קובע את הסבירות לזיהוי דיבור.
end_of_speech_sensitivity

EndSensitivity

זה שינוי אופציונלי. קובעת את הסבירות לכך שהדיבור שזוהה הסתיים.
prefix_padding_ms

int32

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

int32

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

bool

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

EndSensitivity

סוף הרגישות לדיבור.

טיפוסים בני מנייה (enum)
END_SENSITIVITY_UNSPECIFIED ברירת המחדל היא END_SENSITIVITY_LOW.
END_SENSITIVITY_HIGH זיהוי אוטומטי מסיים את הדיבור לעיתים קרובות יותר.
END_SENSITIVITY_LOW זיהוי אוטומטי מסיים את הדיבור בתדירות נמוכה יותר.

StartSensitivity

תחילת הרגישות לדיבור.

טיפוסים בני מנייה (enum)
START_SENSITIVITY_UNSPECIFIED ברירת המחדל היא START_SENSITIVITY_LOW.
START_SENSITIVITY_HIGH הזיהוי האוטומטי יזהה את תחילת הדיבור בתדירות גבוהה יותר.
START_SENSITIVITY_LOW הזיהוי האוטומטי יזהה את תחילת הדיבור בתדירות נמוכה יותר.

TurnCoverage

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

טיפוסים בני מנייה (enum)
TURN_COVERAGE_UNSPECIFIED אם לא מציינים ערך, ברירת המחדל היא TURN_INCLUDES_ALL_INPUT.
TURN_INCLUDES_ONLY_ACTIVITY הפעילות שמתבצעת במהלך תור המשתמש כוללת רק את הפעילות שבוצעה מאז התור הקודם, לא כולל חוסר פעילות (למשל, שקט בזרם האודיו).
TURN_INCLUDES_ALL_INPUT התור של המשתמש כולל את כל הקלט בזמן אמת מאז התור האחרון, כולל חוסר פעילות (למשל, שקט בזרם האודיו). זו התנהגות ברירת המחדל.

UsageMetadata

מטא-נתונים על השימוש בתוכן שבמטמון.

שדות
total_token_count

int32

המספר הכולל של האסימונים שהתוכן שנשמר במטמון צורך.
text_count

int32

מספר התווים בטקסט.
image_count

int32

מספר התמונות.
video_duration_seconds

int32

משך הסרטון בשניות.
audio_duration_seconds

int32

משך האודיו בשניות.

GoAway

השרת לא יוכל לשרת את הלקוח בקרוב.

שדות
time_left

Duration

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

SessionResumptionUpdate

עדכון של מצב חידוש הסשן.

הערך נשלח רק אם הוגדר BidiGenerateContentSetup.session_resumption.

שדות
new_handle

string

כינוי חדש שמייצג מצב שאפשר להמשיך ממנו. השדה ריק אם resumable=false.
resumable

bool

הערך הוא True אם אפשר לחדש את הסשן בשלב הזה.

יכול להיות שלא תהיה אפשרות לחזור לסשן בשלב מסוים. במקרה כזה, נשלח עדכון ריק של new_handle ו-resumable=false. דוגמה למקרה כזה יכולה להיות מודל שמבצע קריאות לפונקציות או פשוט יוצר תוכן. המשך של סשן (באמצעות טוקן לסשן קודם) במצב כזה יגרום לאובדן נתונים.
last_consumed_client_message_index

int64

אינדקס של ההודעה האחרונה שנשלחה על ידי הלקוח, שכלולה במצב שמיוצג על ידי SessionResumptionToken הזה. ההודעה נשלחת רק אם מוגדר SessionResumptionConfig.transparent.

האינדקס הזה מאפשר למשתמשים להתחבר מחדש בצורה שקופה ולמנוע את הבעיה של אובדן חלק מהקלט האודיו או הווידאו בזמן אמת. אם הלקוח רוצה להתנתק באופן זמני (לדוגמה, כתוצאה מקבלת GoAway), הוא יכול לעשות זאת בלי לאבד את הסטטוס על ידי שמירת ההודעות שנשלחו מאז SessionResmumptionTokenUpdate בזיכרון הזמני. השדה הזה יאפשר להם להגביל את האגירה הזמנית (ולמנוע שמירת כל הבקשות ב-RAM).

הוא לא ישמש ל 'המשך הפעלה כדי לשחזר את המצב' בשלב מאוחר יותר – במקרים כאלה, סביר להניח שלא יהיה צורך בפריים חלקי של אודיו ווידאו.

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