Firebase AI Logic का इस्तेमाल करके, Gemini Live API का इस्तेमाल शुरू करना

खास जानकारी: Firebase AI Logic SDK टूल का इस्तेमाल करके Gemini Live API की सुविधा, फ़िलहाल झलक के तौर पर उपलब्ध है. इसका मतलब है कि इस पर कोई एसएलए या बंद करने की नीति लागू नहीं होती. साथ ही, इसमें ऐसे बदलाव किए जा सकते हैं जो पहले से मौजूद वर्शन के साथ काम न करें.

Gemini Live API की मदद से, कम इंतज़ार के समय में रीयल टाइम में, आवाज़ और वीडियो के ज़रिए Gemini मॉडल से इंटरैक्ट किया जा सकता है. यह मॉडल दोनों दिशाओं में काम करता है.

Live API और इससे जुड़े मॉडल, ऑडियो, वीडियो या टेक्स्ट के लगातार स्ट्रीम को प्रोसेस कर सकते हैं. इससे उपयोगकर्ताओं को तुरंत, इंसानों जैसी आवाज़ में जवाब मिलते हैं. इस वजह से, उन्हें बातचीत का स्वाभाविक अनुभव मिलता है.

इस पेज पर, सबसे आम सुविधा यानी ऑडियो इनपुट और आउटपुट को स्ट्रीम करने का तरीका बताया गया है. हालांकि, Live API कई अलग-अलग सुविधाएं और कॉन्फ़िगरेशन के विकल्प उपलब्ध कराता है.

अहम जानकारी: Gemini Live API लाइव रीयल-टाइम स्ट्रीमिंग के लिए है. यह दोनों दिशाओं में काम करता है और खास तौर पर ऑडियो में जवाब देने के लिए है.
अगर आपको टेक्स्ट में जवाबों की सामान्य स्ट्रीमिंग करनी है, तो generateContentStream या sendMessageStream का इस्तेमाल करें. इसके लिए, टेक्स्ट में जवाबों को स्ट्रीम करने के तरीके की खास जानकारी देखें.

Live API स्टेटफ़ुल एपीआई है. यह क्लाइंट और Gemini सर्वर के बीच सेशन बनाने के लिए, WebSocket कनेक्शन बनाता है. ज़्यादा जानकारी के लिए, Live API रेफ़रंस से जुड़ा दस्तावेज़ देखें (Gemini Developer API | Agent Platform Gemini API (formerly Vertex AI)).

कोड सैंपल पर जाएं

काम के संसाधन देखें

• Swift - क्विकस्टार्ट ऐप्लिकेशन | Android - क्विकस्टार्ट ऐप्लिकेशन | Web - क्विकस्टार्ट ऐप्लिकेशन | Flutter - क्विकस्टार्ट ऐप्लिकेशन | Unity - जल्द ही उपलब्ध होगा!

• डिप्लॉय किए गए किसी ऐप्लिकेशन में Gemini Live API का अनुभव करें. इसके लिए, Flutter AI Playground ऐप्लिकेशन को देखें जिसे Firebase कंसोल से ऐक्सेस किया जा सकता है.

शुरू करने से पहले

अगर आपने अब तक, शुरू करने के लिए गाइड नहीं पढ़ी है, तो उसे पढ़ें. इसमें Firebase प्रोजेक्ट सेट अप करने, अपने ऐप्लिकेशन को Firebase से कनेक्ट करने, SDK टूल जोड़ने, चुने गए Gemini API के लिए बैकएंड सेवा शुरू करने, और LiveModel इंस्टेंस बनाने का तरीका बताया गया है.

प्रॉम्प्ट और Live API की मदद से Google AI Studio या Agent  Studio में प्रोटोटाइप किया जा सकता है.

इस सुविधा के साथ काम करने वाले मॉडल

• 3.x मॉडल

  • Gemini Developer API

    • gemini-3.1-flash-live-preview

    भले ही, यह मॉडल फ़िलहाल झलक के तौर पर उपलब्ध हो, लेकिन यह "मुफ़्त टियर" में उपलब्ध है Gemini Developer API.

  • Agent Platform Gemini API (formerly Vertex AI)

    Gemini Live 3.x मॉडल के साथ काम नहीं करता

• 2.5 मॉडल

  भले ही, Gemini API उपलब्ध कराने वाली कंपनी के हिसाब से मॉडल के अलग-अलग नाम हों, लेकिन मॉडल की सुविधाएं एक जैसी होती हैं.

  • Gemini Developer API

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

    भले ही, ये मॉडल फ़िलहाल झलक के तौर पर उपलब्ध हों, लेकिन ये "मुफ़्त टियर" में उपलब्ध हैं Gemini Developer API.

  • Agent Platform Gemini API (formerly Vertex AI)

    • gemini-live-2.5-flash-native-audio (दिसंबर 2025 में रिलीज़ किया गया)
    • gemini-live-2.5-flash-preview-native-audio-09-2025

    Agent Platform Gemini API (formerly Vertex AI) का इस्तेमाल करते समय, Live API मॉडल, global जगह पर काम नहीं करते.

ऑडियो इनपुट और आउटपुट को स्ट्रीम करना

अपनी Gemini API उपलब्ध कराने वाली कंपनी के हिसाब से कॉन्टेंट और कोड देखने के लिए, उस कंपनी पर क्लिक करें. Gemini Developer API Agent Platform Gemini API

नीचे दिए गए उदाहरण में, स्ट्रीम किए गए ऑडियो इनपुट भेजने और स्ट्रीम किए गए ऑडियो आउटपुट पाने के लिए, सामान्य तरीके के बारे में बताया गया है.

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

  // 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 उपलब्ध कराने वाली कंपनी के दस्तावेज़ में Live API मॉडल की कीमत से जुड़ी जानकारी देख सकते हैं: Gemini Developer API | Agent Platform Gemini API (formerly Vertex AI).

Gemini API उपलब्ध कराने वाली कंपनी कोई भी हो, Live API, Count Tokens API के साथ काम नहीं करता.

ध्यान दें: Firebase AI Logic फ़िलहाल जवाब में UsageMetadata पाने की सुविधा के साथ काम नहीं करता.

---

तुम और क्या कर सकती हो?

• क्षमताएं के लिए Live API की फ़ुल सुइट के बारे में जानें. जैसे, अलग-अलग इनपुट मोडैलिटी (ऑडियो, टेक्स्ट या वीडियो + ऑडियो) को स्ट्रीम करना.

• अलग-अलग कॉन्फ़िगरेशन विकल्पों का इस्तेमाल करके, अपनी ज़रूरत के हिसाब से बदलाव करें. जैसे, ट्रांसक्रिप्शन जोड़ना या जवाब की आवाज़ सेट करना.

• सेशन मैनेज करने के बारे में जानें. इसमें सेशन के बीच में कॉन्टेंट अपडेट करना, कॉन्टेक्स्ट विंडो को कंप्रेस करना, यह पता लगाना कि सेशन कब खत्म होने वाला है, और सेशन को फिर से शुरू करना शामिल है.

• मॉडल को टूल का ऐक्सेस देकर, अपनी ज़रूरत के हिसाब से बदलाव करें. जैसे, फ़ंक्शन कॉलिंग और Google Search की मदद से ग्राउंडिंग. Live API के साथ टूल इस्तेमाल करने के बारे में आधिकारिक दस्तावेज़ जल्द ही उपलब्ध होगा!

• Live APILive API के इस्तेमाल से जुड़ी सीमाओं और खास जानकारी, के बारे में जानें. जैसे, सेशन की अवधि, रेट लिमिट, काम करने वाली भाषाएं वगैरह.