Bắt đầu sử dụng Gemini Live API bằng Firebase AI Logic


Gemini Live API cho phép tương tác bằng giọng nói và video theo thời gian thực với độ trễ thấp với một mô hình Gemini mà hai chiều.

Live API và nhóm mô hình đặc biệt của API này có thể xử lý các luồng liên tục âm thanh, video hoặc văn bản để đưa ra các phản hồi bằng lời nói tức thì, giống như con người, tạo ra trải nghiệm đàm thoại tự nhiên cho người dùng.

Trang này mô tả cách bắt đầu sử dụng tính năng phổ biến nhất – truyền phát đầu vào và đầu ra âm thanh, nhưng Live API hỗ trợ nhiều tính năng và lựa chọn cấu hình khác nhau.

Live API là một API có trạng thái, tạo kết nối WebSocket để thiết lập phiên giữa máy khách và máy chủ Gemini. Để biết thông tin chi tiết, hãy xem tài liệu tham khảo Live API (Gemini Developer API | Vertex AI Gemini API).

arrow_downward Chuyển đến mã mẫu

Xem các tài nguyên hữu ích

Trước khi bắt đầu

Nếu bạn chưa hoàn tất, hãy làm theo hướng dẫn bắt đầu, hướng dẫn này mô tả cách thiết lập dự án Firebase, kết nối ứng dụng với Firebase, thêm SDK, khởi chạy dịch vụ phụ trợ cho nhà cung cấp Gemini API mà bạn chọn và tạo thực thể LiveModel.

Bạn có thể tạo nguyên mẫu bằng lời nhắc và Live API trong Google AI Studio hoặc Vertex AI Studio.

Các mô hình hỗ trợ tính năng này

Gemini 2.5 Flash Live mô hình là các mô hình âm thanh gốc hỗ trợ Gemini Live API. Mặc dù mô hình này có các tên mô hình khác nhau tuỳ thuộc vào nhà cung cấp Gemini API, nhưng hành vi và tính năng của mô hình này là giống nhau.

  • Gemini Developer API

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

    Mặc dù đây là các mô hình xem trước, nhưng chúng có sẵn trong "bậc miễn phí" của the Gemini Developer API.

  • Vertex AI Gemini API

    • gemini-live-2.5-flash-native-audio (ra mắt vào tháng 12 năm 2025)
    • gemini-live-2.5-flash-preview-native-audio-09-2025

    Khi sử dụng Vertex AI Gemini API, các mô hình Live API không được hỗ trợ ở vị trí global.

Truyền phát đầu vào và đầu ra âm thanh

Nhấp vào nhà cung định Gemini API để xem nội dung dành riêng cho nhà cung cấp và mã trên trang này.

Ví dụ sau đây trình bày cách triển khai cơ bản để gửi đầu vào âm thanh được truyền phát và nhận đầu ra âm thanh được truyền phát.

Để biết thêm các lựa chọn và tính năng cho Live API, hãy xem phần "Bạn có thể làm gì nữa?" ở phần sau của trang này.

Swift

Để sử dụng Live API, hãy tạo một LiveModel thực thể và đặt phương thức phản hồi thành 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 require to send more requests.
      if content.isTurnComplete {
        await session.close()
      }
    }
  }
} catch {
  fatalError(error.localizedDescription)
}

Kotlin

Để sử dụng Live API, hãy tạo một LiveModel thực thể và đặt phương thức phản hồi thành 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

Để sử dụng Live API, hãy tạo một LiveModel thực thể và đặt phương thức phản hồi thành 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

Để sử dụng Live API, hãy tạo một LiveGenerativeModel thực thể và đặt phương thức phản hồi thành 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

Để sử dụng Live API, hãy tạo một LiveGenerativeModel thực thể và đặt phương thức phản hồi thành 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

Để sử dụng Live API, hãy tạo một LiveModel thực thể và đặt phương thức phản hồi thành 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++;
  }
}


Giá và cách tính mã thông báo

Bạn có thể tìm thấy thông tin về giá cho các mô hình Live API trong tài liệu dành cho nhà cung cấp Gemini API mà bạn chọn: Gemini Developer API | Vertex AI Gemini API.

Bất kể nhà cung cấp Gemini API của bạn là gì, Live API đều không hỗ trợ Count Tokens API.


Bạn có thể làm gì nữa?

  • Xem bộ tính năng đầy đủ cho khả năng của Live API, chẳng hạn như truyền phát nhiều phương thức đầu vào (âm thanh, văn bản hoặc video + âm thanh).

  • Tuỳ chỉnh cách triển khai bằng cách sử dụng nhiều lựa chọn cấu hình, chẳng hạn như thêm bản ghi hoặc đặt giọng phản hồi.

  • Tìm hiểu về cách quản lý phiên, bao gồm cả việc cập nhật nội dung giữa phiên và phát hiện thời điểm phiên sắp kết thúc.

  • Nâng cao cách triển khai bằng cách cấp cho mô hình quyền truy cập vào các công cụ, chẳng hạn như gọi hàm và căn cứ vào Google Tìm kiếm. Tài liệu chính thức về cách sử dụng các công cụ với Live API sẽ sớm ra mắt!

  • Tìm hiểu về các giới hạn và thông số kỹ thuật, khi sử dụng Live API, chẳng hạn như thời lượng phiên, hạn mức tốc độ, ngôn ngữ được hỗ trợ, v.v.