إمكانيات Live API

معاينة: إنّ استخدام Firebase AI Logic مع Gemini Live API هي ميزة في مرحلة المعاينة، ما يعني أنّها لا تخضع لأي اتفاقية مستوى خدمة أو سياسة إيقاف، وقد يتم تغييرها بطرق غير متوافقة مع الأنظمة القديمة.

تصف هذه الصفحة إمكانات Live API عند استخدامه من خلال Firebase AI Logic، بما في ذلك:

• طرق الإدخال المتاحة، بما في ذلك:

  • إدخال الصوت
  • إدخال النص + الصوت
  • إدخال الفيديو + الصوت

  يُرجى العِلم أنّ Live API يتيح أيضًا إدخال الصورة + الصوت.

• قوائم الميزات غير المتاحة ، والتي سيتوفّر العديد منها قريبًا

يمكنك الانتقال إلى صفحات أخرى للتعرّف على كيفية تخصيص عملية التنفيذ باستخدام خيارات إعداد متنوعة، مثل إضافة عملية تحويل الكلام إلى نص أو ضبط صوت الردّ. يمكنك أيضًا التعرّف على إدارة الجلسات.

---

طرق الإدخال

يصف هذا القسم كيفية إرسال أنواع مختلفة من الإدخالات إلى نموذج Live API. تتطلّب نماذج الصوت الأصلية دائمًا إدخال الصوت (بالإضافة إلى طرق الإدخال الإضافية الاختيارية للنص أو الفيديو)، وتُرجع دائمًا مصدر إخراج الصوت.

• إدخال الصوت

• إدخال النص + الصوت

• إدخال الفيديو + الصوت

يُرجى العِلم أنّ Live API يتيح أيضًا إدخال الصورة + الصوت.

بث إدخال الصوت

انقر على موفّر Gemini API لعرض المحتوى الخاص بالموفّر والتعليمات البرمجية على هذه الصفحة. Gemini Developer API Agent Platform Gemini API

إنّ الإمكانية الأكثر شيوعًا في Live API هي البث الصوتي ثنائي الاتجاه، ما يعني البث في الوقت الفعلي لكلّ من إدخال الصوت وإخراجه.

يدعم Live API تنسيقات الصوت التالية:

• تنسيق الصوت المُدخَل: صوت PCM غير معالَج بـ 16 بت بمعدّل 16 كيلوهرتز little-endian

• تنسيق الصوت المُخرَج: صوت PCM غير معالَج بـ 16 بت بمعدّل 24 كيلوهرتز little-endian

• أنواع MIME المتاحة: audio/x-aac، audio/flac، audio/mp3، audio/m4a، audio/mpeg، audio/mpga، audio/mp4، audio/ogg، audio/pcm، audio/wav، audio/webm

لنقل معدّل نموذج الصوت المُدخَل، اضبط نوع MIME لكلّ Blob يحتوي على صوت على قيمة مثل audio/pcm;rate=16000.

Swift

لاستخدام Live API، أنشئ LiveModel مثيلاً واضبط طريقة الردّ على audio.

import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
// Create a `liveModel` instance with a model that supports the Live API.
let liveModel = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
  modelName: "gemini-2.5-flash-native-audio-preview-12-2025",
  // Configure the model to respond with audio.
  generationConfig: LiveGenerationConfig(
    responseModalities: [.audio]
  )
)

do {
  let session = try await liveModel.connect()

  // Load the audio file, or tap a microphone.
  guard let audioFile = NSDataAsset(name: "audio.pcm") else {
    fatalError("Failed to load audio file")
  }

  // Provide the audio data.
  await session.sendAudioRealtime(audioFile.data)

  var outputText = ""
  for try await message in session.responses {
    if case let .content(content) = message.payload {
      content.modelTurn?.parts.forEach { part in
        if let part = part as? InlineDataPart, part.mimeType.starts(with: "audio/pcm") {
          // Handle 16bit pcm audio data at 24khz
          playAudio(part.data)
        }
      }
      // Optional: if you don't need to send more requests.
      if content.isTurnComplete {
        await session.close()
      }
    }
  }
} catch {
  fatalError(error.localizedDescription)
}

Kotlin

لاستخدام Live API، أنشئ مثيلاً من LiveModel واضبط طريقة الردّ على AUDIO.

// Initialize the Gemini Developer API backend service.
// Create a `liveModel` instance with a model that supports the Live API.
val liveModel = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    // Configure the model to respond with audio.
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
   }
)

val session = liveModel.connect()

// This is the recommended approach.
// However, you can create your own recorder and handle the stream.
session.startAudioConversation()

Java

لاستخدام Live API، أنشئ مثيلاً من LiveModel واضبط طريقة الردّ على AUDIO.

ExecutorService executor = Executors.newFixedThreadPool(1);
// Initialize the Gemini Developer API backend service.
// Create a `liveModel` instance with a model that supports the Live API.
LiveGenerativeModel lm = FirebaseAI.getInstance(GenerativeBackend.googleAI()).liveModel(
        "gemini-2.5-flash-native-audio-preview-12-2025",
        // Configure the model to respond with audio.
        new LiveGenerationConfig.Builder()
                .setResponseModality(ResponseModality.AUDIO)
                .build()
);
LiveModelFutures liveModel = LiveModelFutures.from(lm);

ListenableFuture<LiveSession> sessionFuture =  liveModel.connect();

Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
	 LiveSessionFutures session = LiveSessionFutures.from(ses);
        session.startAudioConversation();
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

Web

لاستخدام Live API، أنشئ LiveGenerativeModel مثيلاً واضبط طريقة الردّ على AUDIO.

import { initializeApp } from "firebase/app";
import { getAI, getLiveGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `LiveGenerativeModel` instance with a model that supports the Live API.
const liveModel = getLiveGenerativeModel(ai, {
  model: "gemini-2.5-flash-native-audio-preview-12-2025",
  // Configure the model to respond with audio.
  generationConfig: {
    responseModalities: [ResponseModality.AUDIO],
  },
});

const session = await liveModel.connect();

// Start the audio conversation.
const audioConversationController = await startAudioConversation(session);

// ... Later, to stop the audio conversation
// await audioConversationController.stop()

Dart

لاستخدام Live API، أنشئ مثيلاً من LiveGenerativeModel واضبط طريقة الردّ على audio.

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
import 'package:your_audio_recorder_package/your_audio_recorder_package.dart';

late LiveModelSession _session;
final _audioRecorder = YourAudioRecorder();

await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service.
// Create a `liveGenerativeModel` instance with a model that supports the Live API.
final liveModel = FirebaseAI.googleAI().liveGenerativeModel(
  model: 'gemini-2.5-flash-native-audio-preview-12-2025',
  // Configure the model to respond with audio.
  liveGenerationConfig: LiveGenerationConfig(
    responseModalities: [ResponseModalities.audio],
  ),
);

_session = await liveModel.connect();

final audioRecordStream = _audioRecorder.startRecordingStream();
// Map the Uint8List stream to InlineDataPart stream.
final mediaChunkStream = audioRecordStream.map((data) {
  return InlineDataPart('audio/pcm', data);
});
await _session.startMediaStream(mediaChunkStream);

// In a separate thread, receive the audio response from the model.
await for (final message in _session.receive()) {
   // Process the received message.
}

Unity

لاستخدام Live API، أنشئ LiveModel مثيلاً واضبط طريقة الردّ على Audio.

using Firebase;
using Firebase.AI;

async Task SendTextReceiveAudio() {
  // Initialize the Gemini Developer API backend service.
  // Create a `LiveModel` instance with a model that supports the Live API.
  var liveModel = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetLiveModel(
      modelName: "gemini-2.5-flash-native-audio-preview-12-2025",
      // Configure the model to respond with audio.
      liveGenerationConfig: new LiveGenerationConfig(
          responseModalities: new[] { ResponseModality.Audio })
    );

  LiveSession session = await liveModel.ConnectAsync();

  // Start a coroutine to send audio from the Microphone.
  var recordingCoroutine = StartCoroutine(SendAudio(session));

  // Start receiving the response.
  await ReceiveAudio(session);
}

IEnumerator SendAudio(LiveSession liveSession) {
  string microphoneDeviceName = null;
  int recordingFrequency = 16000;
  int recordingBufferSeconds = 2;

  var recordingClip = Microphone.Start(microphoneDeviceName, true,
                                       recordingBufferSeconds, recordingFrequency);

  int lastSamplePosition = 0;
  while (true) {
    if (!Microphone.IsRecording(microphoneDeviceName)) {
      yield break;
    }

    int currentSamplePosition = Microphone.GetPosition(microphoneDeviceName);

    if (currentSamplePosition != lastSamplePosition) {
      // The Microphone uses a circular buffer, so we need to check if the
      // current position wrapped around to the beginning, and handle it accordingly.
      int sampleCount;
      if (currentSamplePosition > lastSamplePosition) {
        sampleCount = currentSamplePosition - lastSamplePosition;
      } else {
        sampleCount = recordingClip.samples - lastSamplePosition + currentSamplePosition;
      }

      if (sampleCount > 0) {
        // Get the audio chunk.
        float[] samples = new float[sampleCount];
        recordingClip.GetData(samples, lastSamplePosition);

        // Send the data, discarding the resulting Task to avoid the warning.
        _ = liveSession.SendAudioAsync(samples);

        lastSamplePosition = currentSamplePosition;
      }
    }

    // Wait for a short delay before reading the next sample from the Microphone.
    const float MicrophoneReadDelay = 0.5f;
    yield return new WaitForSeconds(MicrophoneReadDelay);
  }
}

Queue audioBuffer = new();

async Task ReceiveAudio(LiveSession liveSession) {
  int sampleRate = 24000;
  int channelCount = 1;

  // Create a looping AudioClip to fill with the received audio data.
  int bufferSamples = (int)(sampleRate * channelCount);
  AudioClip clip = AudioClip.Create("StreamingPCM", bufferSamples, channelCount,
                                    sampleRate, true, OnAudioRead);

  // Attach the clip to an AudioSource and start playing it.
  AudioSource audioSource = GetComponent();
  audioSource.clip = clip;
  audioSource.loop = true;
  audioSource.Play();

  // Start receiving the response.
  await foreach (var message in liveSession.ReceiveAsync()) {
    // Process the received message
    foreach (float[] pcmData in message.AudioAsFloat) {
      lock (audioBuffer) {
        foreach (float sample in pcmData) {
          audioBuffer.Enqueue(sample);
        }
      }
    }
  }
}

// This method is called by the AudioClip to load audio data.
private void OnAudioRead(float[] data) {
  int samplesToProvide = data.Length;
  int samplesProvided = 0;

  lock(audioBuffer) {
    while (samplesProvided < samplesToProvide && audioBuffer.Count > 0) {
      data[samplesProvided] = audioBuffer.Dequeue();
      samplesProvided++;
    }
  }

  while (samplesProvided < samplesToProvide) {
    data[samplesProvided] = 0.0f;
    samplesProvided++;
  }
}

بث إدخال النص + الصوت

انقر على موفّر Gemini API لعرض المحتوى الخاص بالموفّر والتعليمات البرمجية على هذه الصفحة. Gemini Developer API Agent Platform Gemini API

إذا لزم الأمر، يمكنك إرسال إدخال نصي مع إدخال الصوت وتلقّي إخراج صوتي يتم بثه.

Swift

لاستخدام Live API، أنشئ LiveModel مثيلاً واضبط طريقة الردّ على audio.

import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
// Create a `liveModel` instance with a model that supports the Live API.
let liveModel = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
  modelName: "gemini-2.5-flash-native-audio-preview-12-2025",
  // Configure the model to respond with audio.
  generationConfig: LiveGenerationConfig(
    responseModalities: [.audio]
  )
)

do {
  let session = try await liveModel.connect()

  // Provide a text prompt.
  let text = "tell a short story"

  await session.sendTextRealtime(text)

  var outputText = ""
  for try await message in session.responses {
    if case let .content(content) = message.payload {
      content.modelTurn?.parts.forEach { part in
        if let part = part as? InlineDataPart, part.mimeType.starts(with: "audio/pcm") {
          // Handle 16-bit PCM audio data at 24 kHz.
          playAudio(part.data)
        }
      }
      // Optional: if you don't need to send more requests.
      if content.isTurnComplete {
        await session.close()
      }
    }
  }
} catch {
  fatalError(error.localizedDescription)
}

Kotlin

لاستخدام Live API، أنشئ مثيلاً من LiveModel واضبط طريقة الردّ على AUDIO.

// Initialize the Gemini Developer API backend service.
// Create a `liveModel` instance with a model that supports the Live API.
val liveModel = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    // Configure the model to respond with audio.
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
   }
)

val session = liveModel.connect()

// Provide a text prompt.
val text = "tell a short story"

session.send(text)

session.receive().collect {
    if(it.turnComplete) {
        // Optional: if you don't need to send more requests.
        session.stopReceiving();
    }
    // Handle 16bit pcm audio data at 24khz.
    playAudio(it.data)
}

Java

لاستخدام Live API، أنشئ مثيلاً من LiveModel واضبط طريقة الردّ على AUDIO.

ExecutorService executor = Executors.newFixedThreadPool(1);
// Initialize the Gemini Developer API backend service.
// Create a `liveModel` instance with a model that supports the Live API.
LiveGenerativeModel lm = FirebaseAI.getInstance(GenerativeBackend.googleAI()).liveModel(
        "gemini-2.5-flash-native-audio-preview-12-2025",
        // Configure the model to respond with audio.
        new LiveGenerationConfig.Builder()
                .setResponseModality(ResponseModality.AUDIO)
                .build()
);
LiveModelFutures model = LiveModelFutures.from(lm);
ListenableFuture<LiveSession> sessionFuture =  model.connect();
class LiveContentResponseSubscriber implements Subscriber<LiveContentResponse> {
    @Override
    public void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE); // Request an unlimited number of items
    }
    @Override
    public void onNext(LiveContentResponse liveContentResponse) {
        // Handle 16bit pcm audio data at 24khz.
	liveContentResponse.getData();
    }
    @Override
    public void onError(Throwable t) {
        System.err.println("Error: " + t.getMessage());
    }
    @Override
    public void onComplete() {
        System.out.println("Done receiving messages!");
    }
}
Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
	 LiveSessionFutures session = LiveSessionFutures.from(ses);
        // Provide a text prompt.
        String text = "tell me a short story?";
        session.send(text);
        Publisher<LiveContentResponse> publisher = session.receive();
        publisher.subscribe(new LiveContentResponseSubscriber());
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

Web

لاستخدام Live API، أنشئ LiveGenerativeModel مثيلاً واضبط طريقة الردّ على AUDIO.

import { initializeApp } from "firebase/app";
import { getAI, getLiveGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `LiveGenerativeModel` instance with a model that supports the Live API.
const liveModel = getLiveGenerativeModel(ai, {
  model: "gemini-2.5-flash-native-audio-preview-12-2025",
  // Configure the model to respond with audio
  generationConfig: {
    responseModalities: [ResponseModality.AUDIO],
  },
});

const session = await liveModel.connect();

// Provide a text prompt.
const prompt = "tell a short story";
session.send(prompt);

// Handle the model's audio output.
const messages = session.receive();
for await (const message of messages) {
  switch (message.type) {
    case "serverContent":
      if (message.turnComplete) {
        // TODO(developer): Handle turn completion
      } else if (message.interrupted) {
        // TODO(developer): Handle the interruption
        break;
      } else if (message.modelTurn) {
        const parts = message.modelTurn?.parts;
        parts?.forEach((part) => {
          if (part.inlineData) {
            // TODO(developer): Play the audio chunk
          }
        });
      }
      break;
    case "toolCall":
      // Ignore
    case "toolCallCancellation":
      // Ignore
  }
}

Dart

لاستخدام Live API، أنشئ مثيلاً من LiveGenerativeModel واضبط طريقة الردّ على audio.

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
import 'dart:async';
import 'dart:typed_data';

late LiveModelSession _session;

Future<Stream<Uint8List>> textToAudio(String textPrompt) async {
  WidgetsFlutterBinding.ensureInitialized();

  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );

  // Initialize the Gemini Developer API backend service.
  // Create a `liveGenerativeModel` instance with a model that supports the Live API.
  final liveModel = FirebaseAI.googleAI().liveGenerativeModel(
    model: 'gemini-2.5-flash-native-audio-preview-12-2025',
    // Configure the model to respond with audio.
    liveGenerationConfig: LiveGenerationConfig(
      responseModalities: [ResponseModalities.audio],
    ),
  );

  _session = await liveModel.connect();

  final prompt = Content.text(textPrompt);

  await _session.send(input: prompt);

  return _session.receive().asyncMap((response) async {
    if (response is LiveServerContent && response.modelTurn?.parts != null) {
       for (final part in response.modelTurn!.parts) {
         if (part is InlineDataPart) {
           return part.bytes;
         }
       }
    }
    throw Exception('Audio data not found');
  });
}

Future<void> main() async {
  try {
    final audioStream = await textToAudio('Convert this text to audio.');

    await for (final audioData in audioStream) {
      // Process the audio data (e.g., play it using an audio player package).
      print('Received audio data: ${audioData.length} bytes');
      // Example using flutter_sound (replace with your chosen package):
      // await _flutterSoundPlayer.startPlayer(fromDataBuffer: audioData);
    }
  } catch (e) {
    print('Error: $e');
  }
}

Unity

لاستخدام Live API، أنشئ LiveModel مثيلاً واضبط طريقة الردّ على Audio.

using Firebase;
using Firebase.AI;

async Task SendTextReceiveAudio() {
  // Initialize the Gemini Developer API backend service.
  // Create a `LiveModel` instance with a model that supports the Live API.
  var liveModel = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetLiveModel(
    modelName: "gemini-2.5-flash-native-audio-preview-12-2025",
    // Configure the model to respond with audio.
    liveGenerationConfig: new LiveGenerationConfig(
        responseModalities: new[] { ResponseModality.Audio })
  );

  LiveSession session = await liveModel.ConnectAsync();

  // Provide a text prompt.
  var prompt = ModelContent.Text("Convert this text to audio.");
  await session.SendAsync(content: prompt, turnComplete: true);

  // Start receiving the response.
  await ReceiveAudio(session);
}

Queue<float> audioBuffer = new();

async Task ReceiveAudio(LiveSession session) {
  int sampleRate = 24000;
  int channelCount = 1;

  // Create a looping AudioClip to fill with the received audio data.
  int bufferSamples = (int)(sampleRate * channelCount);
  AudioClip clip = AudioClip.Create("StreamingPCM", bufferSamples, channelCount,
                                    sampleRate, true, OnAudioRead);

  // Attach the clip to an AudioSource and start playing it.
  AudioSource audioSource = GetComponent<AudioSource>();
  audioSource.clip = clip;
  audioSource.loop = true;
  audioSource.Play();

  // Start receiving the response.
  await foreach (var message in session.ReceiveAsync()) {
    // Process the received message.
    foreach (float[] pcmData in message.AudioAsFloat) {
      lock (audioBuffer) {
        foreach (float sample in pcmData) {
          audioBuffer.Enqueue(sample);
        }
      }
    }
  }
}

// This method is called by the AudioClip to load audio data.
private void OnAudioRead(float[] data) {
  int samplesToProvide = data.Length;
  int samplesProvided = 0;

  lock(audioBuffer) {
    while (samplesProvided < samplesToProvide && audioBuffer.Count > 0) {
      data[samplesProvided] = audioBuffer.Dequeue();
      samplesProvided++;
    }
  }

  while (samplesProvided < samplesToProvide) {
    data[samplesProvided] = 0.0f;
    samplesProvided++;
  }
}

يُرجى العِلم أنّه يمكنك أيضًا إرسال نص كـ عمليات تعديل متزايدة للمحتوى أثناء جلسة نشطة.

بث إدخال الفيديو + الصوت

يوفّر محتوى الفيديو المُدخَل سياقًا مرئيًا للصوت المُدخَل.

يتوقّع Live API سلسلة من لقطات الصور المنفصلة ويتيح إدخال لقطات الفيديو بمعدّل لقطة واحدة في الثانية.

• الإدخال المقترَح: دقة عرض أصلية تبلغ 768 × 768 بمعدّل لقطة واحدة في الثانية

• أنواع MIME المتاحة: video/x-flv، video/quicktime، video/mpeg، video/mpegs، video/mpg، video/mp4، video/webm، video/wmv، video/3gpp

إنّ بث إدخال الفيديو + الصوت هو عملية تنفيذ أكثر تقدّمًا، لذا اطّلِع على ا نموذج تطبيق للتعرّف على كيفية تنفيذ هذه الإمكانية: Swift : ستتوفّر قريبًا | Android : نموذج تطبيق | الويب : ستتوفّر قريبًا | Flutter : نموذج تطبيق | Unity : ستتوفّر قريبًا

---

الميزات غير المتاحة

• الميزات التي لم يتوافق معها Firebase AI Logic بعد عند استخدام Live API، ولكنّها ستتوفّر قريبًا

  • ضبط عملية التفكير (الإعداد التلقائي هو minimal لنموذج Gemini Live 3.x)

  • التعامل مع المقاطعات

  • إيقاف ميزة رصد النشاط الصوتي (VAD) وضبطها

  • ضبط دقة عرض الوسائط المُدخَلة

  • إضافة إعدادات التفكير

  • تفعيل الحوار العاطفي أو التحكم الاستباقي بالصوت (لا ينطبق ذلك إلا على نماذج Gemini Live 2.x)

  • تلقّي UsageMetadata في الردّ

• الميزات غير المتوافقة مع Firebase AI Logic عند استخدام Live API، ولا يتم التخطيط لها حاليًا.

  • نماذج الطلبات على الخادم

  • الاستدلال الهجين أو على الجهاز فقط

  • تتبّع استخدام الذكاء الاصطناعي في Firebase Console

ملاحظة: Firebase AI Logic لا يتيح بعد استخدام نماذج تحويل الكلام إلى كلام (S2S) أو نماذج Lyria.

---

ما المهام الأخرى التي يمكنك تنفيذها؟

• يمكنك تخصيص عملية التنفيذ باستخدام خيارات إعداد متنوعة، مثل إضافة عملية تحويل الكلام إلى نص أو ضبط صوت الردّ.

• يمكنك التعرّف على إدارة الجلسات، بما في ذلك تعديل المحتوى في منتصف الجلسة، وضغط قدرة استيعاب، ورصد اقتراب انتهاء الجلسة ، واستئناف الجلسة.

• يمكنك تحسين عملية التنفيذ من خلال منح النموذج إمكانية الوصول إلى الأدوات، مثل استدعاء الدوال وGrounding with Google Search. ستتوفّر قريبًا المستندات الرسمية لاستخدام الأدوات مع Live API.

• يمكنك التعرّف على الحدود والمواصفات، الخاصة باستخدام Live API، مثل مدة الجلسة وحدود المعدّل واللغات المتاحة وما إلى ذلك.