Firebase AI Logic'i kullanarak Gemini Live API'yi kullanmaya başlama

Önizleme: Firebase AI Logic SDK'larının Gemini Live API ile kullanılması, Önizleme aşamasında olan bir özelliktir. Bu nedenle, herhangi bir HDS'ye veya kullanımdan kaldırma politikasına tabi değildir ve geriye dönük olarak uyumsuz olacak şekilde değişebilir.

Gemini Live API, iki yönlü bir Gemini modeliyle düşük gecikmeli, gerçek zamanlı sesli ve görüntülü etkileşimler sağlar.

Live API ve özel model ailesi, ses, video veya metin akışlarını kesintisiz olarak işleyerek anında, insan benzeri sözlü yanıtlar verebilir. Böylece kullanıcılarınız için doğal bir sohbet deneyimi oluşturur.

Bu sayfada, en yaygın özellik olan ses giriş ve çıkışını aktarma ile nasıl başlayacağınız açıklanmaktadır. Ancak Live API, birçok farklı özelliği ve yapılandırma seçeneğini destekler.

Önemli: Gemini Live API simgesi, çift yönlü olan ve özellikle sesli yanıtlar için kullanılan canlı anlık yayın özelliğini ifade eder.
Metin yanıtlarının temel akışını (generateContentStream veya sendMessageStream kullanarak) istiyorsanız metin yanıtlarını nasıl yayınlayacağımızla ilgili genel bakışımıza göz atın.

Live API, istemci ile Gemini sunucusu arasında oturum oluşturmak için WebSocket bağlantısı oluşturan durum bilgisi olan bir API'dir. Ayrıntılar için Live API referans belgelerine (Gemini Developer API | Vertex AI Gemini API) bakın.

Kod örneklerine gitme

Faydalı kaynaklara göz atın

• Swift - Çok yakında! | Android - hızlı başlangıç uygulaması | Web - hızlı başlangıç uygulaması | Flutter - hızlı başlangıç uygulaması | Unity - yakında!

• Gemini Live API özelliğini gerçek bir uygulamada deneyin. Firebase konsolundan erişilebilen Flutter AI Playground uygulamasını inceleyin.

Başlamadan önce

Henüz yapmadıysanız başlangıç kılavuzunu tamamlayın. Bu kılavuzda Firebase projenizi ayarlama, uygulamanızı Firebase'e bağlama, SDK'yı ekleme, seçtiğiniz Gemini API sağlayıcısı için arka uç hizmetini başlatma ve LiveModel örneği oluşturma hakkında bilgiler yer almaktadır.

Google AI Studio veya Vertex AI Studio içinde istemler ve Live API ile prototip oluşturabilirsiniz.

Bu özelliği destekleyen modeller

Gemini 2.5 Flash Live modelleri, Gemini Live API'ü destekleyen doğal ses modelleridir. Modelin Gemini API sağlayıcısına bağlı olarak farklı model adları olsa da modelin davranışı ve özellikleri aynıdır.

• Gemini Developer API

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

  Bu modeller önizleme sürümü olsa da Gemini Developer API'nın "ücretsiz katmanında" kullanılabilir.

• Vertex AI Gemini API

  • gemini-live-2.5-flash-native-audio (Aralık 2025'te yayınlandı)
  • gemini-live-2.5-flash-preview-native-audio-09-2025

  Vertex AI Gemini API kullanılırken Live API modelleri global konumunda desteklenmez.

Ses giriş ve çıkışını yayınlama

Bu sayfada sağlayıcıya özel içerikleri ve kodu görüntülemek için Gemini API sağlayıcınızı tıklayın. Gemini Developer API Vertex AI Gemini API

Aşağıdaki örnekte, akışlı ses girişi göndermek ve akışlı ses çıkışı almak için temel uygulama gösterilmektedir.

Live API ile ilgili ek seçenekler ve özellikler için bu sayfanın ilerleyen bölümlerinde "Başka neler yapabilirsiniz?" bölümünü inceleyin.

Swift

Live API özelliğini kullanmak için LiveModel örneği oluşturun ve yanıt biçimini audio olarak ayarlayın.

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 require to send more requests.
      if content.isTurnComplete {
        await session.close()
      }
    }
  }
} catch {
  fatalError(error.localizedDescription)
}

Kotlin

Live API özelliğini kullanmak için LiveModel örneği oluşturun ve yanıt biçimini AUDIO olarak ayarlayın.

// 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 özelliğini kullanmak için LiveModel örneği oluşturun ve yanıt biçimini AUDIO olarak ayarlayın.

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 özelliğini kullanmak için LiveGenerativeModel örneği oluşturun ve yanıt biçimini AUDIO olarak ayarlayın.

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 özelliğini kullanmak için LiveGenerativeModel örneği oluşturun ve yanıt biçimini audio olarak ayarlayın.

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 özelliğini kullanmak için LiveModel örneği oluşturun ve yanıt biçimini Audio olarak ayarlayın.

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++;
  }
}

---

Fiyatlandırma ve jeton sayma

Live API modellerinin fiyatlandırma bilgilerini, seçtiğiniz Gemini API sağlayıcının dokümanlarında bulabilirsiniz: Gemini Developer API | Vertex AI Gemini API.

Gemini API sağlayıcınızdan bağımsız olarak Live API, Count Tokens API'yi desteklemez.

Not: Firebase AI Logic, yanıtta UsageMetadata alma özelliğini henüz desteklememektedir.

---

Başka ne yapabilirsin?

• Live API için özelliklerin tamamına göz atın. Örneğin, çeşitli giriş biçimlerini (ses, metin veya video + ses) yayınlayabilirsiniz.

• Çeşitli yapılandırma seçeneklerini kullanarak uygulamanızı özelleştirin. Örneğin, transkripsiyon ekleyebilir veya yanıt sesini ayarlayabilirsiniz.

• Modele işlev çağırma ve Google Arama ile temellendirme gibi araçlara erişim izni vererek uygulamanızı güçlendirin. Araçları Live API ile kullanmayla ilgili resmi belgeler yakında kullanıma sunulacak.

• Oturum uzunluğu, hız sınırları, desteklenen diller gibi Live API kullanımına ilişkin sınırlar ve özellikler hakkında bilgi edinin.