با استفاده از Firebase AI Logic، کار با Gemini Live API را شروع کنید.


Gemini Live API امکان تعاملات صوتی و تصویری با تأخیر کم و بلادرنگ را با مدل Gemini که دو طرفه است، فراهم می‌کند.

Live API و خانواده‌ی خاص مدل‌های آن می‌توانند جریان‌های پیوسته‌ی صدا، تصویر یا متن را پردازش کنند تا پاسخ‌های گفتاری فوری و شبیه به انسان ارائه دهند و یک تجربه‌ی مکالمه‌ی طبیعی برای کاربران شما ایجاد کنند.

این صفحه نحوه شروع به کار با رایج‌ترین قابلیت - پخش ورودی و خروجی صدا - را شرح می‌دهد، اما Live API از قابلیت‌ها و گزینه‌های پیکربندی بسیار متفاوتی پشتیبانی می‌کند.

Live API یک API با وضعیت (stateful API) است که یک اتصال WebSocket برای ایجاد یک جلسه بین کلاینت و سرور Gemini ایجاد می‌کند. برای جزئیات بیشتر، به مستندات مرجع Live API ( Gemini Developer API |Vertex AI Gemini API ) مراجعه کنید.

پرش به نمونه‌های کد

منابع مفید را بررسی کنید

قبل از اینکه شروع کنی

اگر هنوز این کار را نکرده‌اید، راهنمای شروع به کار را تکمیل کنید، که نحوه راه‌اندازی پروژه Firebase، اتصال برنامه به Firebase، افزودن SDK، راه‌اندازی سرویس backend برای ارائه‌دهنده API انتخابی Gemini و ایجاد یک نمونه LiveModel شرح می‌دهد.

شما می‌توانید با استفاده از دستورالعمل‌ها و Live API در Google AI Studio یا Vertex AI Studio نمونه‌سازی اولیه انجام دهید.

مدل‌هایی که از این قابلیت پشتیبانی می‌کنند

  • رابط برنامه‌نویسی کاربردی (API) توسعه‌دهندگان جمینی

    • gemini-2.5-flash-native-audio-preview-09-2025

  • Vertex AI Gemini API

    • gemini-live-2.5-flash-preview-native-audio-09-2025

    هنگام استفاده از Vertex AI Gemini API ، مدل‌های Live API فقط در مکان us-central1 در دسترس هستند.

ورودی و خروجی صدا را پخش کنید

برای مشاهده محتوا و کد مخصوص ارائه‌دهنده در این صفحه، روی ارائه‌دهنده API Gemini خود کلیک کنید.

مثال زیر پیاده‌سازی اولیه برای ارسال ورودی صدای استریم‌شده و دریافت خروجی صدای استریم‌شده را نشان می‌دهد.

برای گزینه‌ها و قابلیت‌های بیشتر برای Live API ، بخش «چه کارهای دیگری می‌توانید انجام دهید؟» را در ادامه همین صفحه بررسی کنید.

سویفت

برای استفاده از 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-09-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 require 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-09-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-09-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-09-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-09-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
}

وحدت

برای استفاده از 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-09-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++;
  }
}


قیمت‌گذاری و شمارش توکن

می‌توانید اطلاعات قیمت‌گذاری مدل‌های Live API را در مستندات ارائه‌دهنده‌ی API Gemini انتخابی خود بیابید: Gemini Developer API |Vertex AI Gemini API .

صرف نظر از ارائه دهنده API Gemini شما، Live API از Count Tokens API پشتیبانی نمی‌کند .


چه کار دیگری می‌توانید انجام دهید؟

  • مجموعه کامل قابلیت‌های Live API ، مانند پخش روش‌های مختلف ورودی (صوتی، متنی یا ویدیویی + صوتی) را بررسی کنید.

  • با استفاده از گزینه‌های مختلف پیکربندی ، مانند اضافه کردن رونویسی یا تنظیم صدای پاسخ، پیاده‌سازی خود را سفارشی کنید.

  • با دسترسی دادن به مدل به ابزارهایی مانند فراخوانی تابع و اتصال به زمین با جستجوی گوگل، پیاده‌سازی خود را تقویت کنید. مستندات رسمی برای استفاده از ابزارها با Live API به زودی منتشر خواهد شد!

  • درباره محدودیت‌ها و مشخصات استفاده از Live API ، مانند طول جلسه، محدودیت‌های سرعت، زبان‌های پشتیبانی‌شده و غیره اطلاعات کسب کنید.