Inizia a utilizzare l'API Gemini Live con Firebase AI Logic

Anteprima: l'utilizzo degli SDK Firebase AI Logic con Gemini Live API è una funzionalità in anteprima, il che significa che non è soggetta a SLA (accordo sul livello del servizio) o a norme sul ritiro e potrebbe cambiare in modi incompatibili con le versioni precedenti.

Gemini Live API consente interazioni vocali e video in tempo reale a bassa latenza con un modello Gemini bidirezionale.

Live API e la sua speciale famiglia di modelli possono elaborare flussi continui di audio, video o testo per fornire risposte immediate e simili a quelle umane, creando un'esperienza conversazionale naturale per i tuoi utenti.

Questa pagina descrive come iniziare a utilizzare la funzionalità più comune, ovvero l'input e l'output audio in streaming, ma Live API supporta molte funzionalità e opzioni di configurazione diverse.

Importante :Gemini Live API è per lo streaming live in tempo reale bidirezionale e specificamente per le risposte audio.
Se vuoi lo streaming di base delle risposte di testo (utilizzando generateContentStream o sendMessageStream), consulta la nostra panoramica su come trasmettere in streaming le risposte di testo.

Live API è un'API stateful che crea una connessione WebSocket per stabilire una sessione tra il client e il server Gemini. Per maggiori dettagli, consulta la documentazione di riferimento di Live API (Gemini Developer API | Vertex AI Gemini API).

Vai agli esempi di codice

Consulta risorse utili

• Swift: disponibile a breve. | Android - app di avvio rapido | Web - app di avvio rapido | Flutter - app di avvio rapido | Unity - in arrivo

• Prova Gemini Live API in un'app di cui è stato eseguito il deployment. Dai un'occhiata all'app Flutter AI Playground accessibile tramite la console Firebase.

Prima di iniziare

Se non l'hai ancora fatto, completa la guida introduttiva, che descrive come configurare il progetto Firebase, connettere l'app a Firebase, aggiungere l'SDK, inizializzare il servizio di backend per il provider Gemini API scelto e creare un'istanza LiveModel.

Puoi creare prototipi con prompt e Live API in Google AI Studio o Vertex AI Studio.

Modelli che supportano questa funzionalità

I modelli Gemini 2.5 Flash Live sono i modelli audio nativi che supportano la Gemini Live API. Anche se il modello ha nomi diversi a seconda del provider API Gemini, il comportamento e le funzionalità del modello sono gli stessi.

• Gemini Developer API

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

  Anche se si tratta di modelli di anteprima, sono disponibili nel "livello senza costi" di Gemini Developer API.

• Vertex AI Gemini API

  • gemini-live-2.5-flash-native-audio (rilasciato a dicembre 2025)
  • gemini-live-2.5-flash-preview-native-audio-09-2025

  Quando utilizzi Vertex AI Gemini API, i modelli Live API non sono supportati nella posizione global.

Trasmettere in streaming l'input e l'output audio

Fai clic sul tuo fornitore Gemini API per visualizzare i contenuti e il codice specifici del fornitore in questa pagina. API Gemini per gli sviluppatori API Vertex AI Gemini

L'esempio seguente mostra l'implementazione di base per inviare l'input audio in streaming e ricevere l'output audio in streaming.

Per ulteriori opzioni e funzionalità per Live API, consulta la sezione "Cos'altro puoi fare?" più avanti in questa pagina.

Swift

Per utilizzare Live API, crea un'istanza LiveModel e imposta la modalità di risposta su 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

Per utilizzare Live API, crea un'istanza LiveModel e imposta la modalità di risposta su 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

Per utilizzare Live API, crea un'istanza LiveModel e imposta la modalità di risposta su 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

Per utilizzare Live API, crea un'istanza LiveGenerativeModel e imposta la modalità di risposta su 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

Per utilizzare Live API, crea un'istanza LiveGenerativeModel e imposta la modalità di risposta su 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

Per utilizzare Live API, crea un'istanza LiveModel e imposta la modalità di risposta su 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++;
  }
}

---

Prezzi e conteggio dei token

Puoi trovare informazioni sui prezzi dei modelli Live API nella documentazione del fornitore Gemini API che hai scelto: Gemini Developer API | Vertex AI Gemini API.

Indipendentemente dal tuo fornitore di Gemini API, Live API non supporta l'API Count Tokens.

Nota: Firebase AI Logic non supporta ancora la ricezione di UsageMetadata nella risposta.

---

Cos'altro puoi fare?

• Scopri la suite completa di funzionalità per Live API, come lo streaming di varie modalità di input (audio, testo o video + audio).

• Personalizza l'implementazione utilizzando varie opzioni di configurazione, come l'aggiunta della trascrizione o l'impostazione della voce di risposta.

• Potenzia l'implementazione dando al modello l'accesso a strumenti come le chiamate di funzione e il grounding con la Ricerca Google. La documentazione ufficiale per l'utilizzo degli strumenti con Live API sarà disponibile a breve.

• Scopri di più su limiti e specifiche per l'utilizzo di Live API, come durata della sessione, limiti di frequenza, lingue supportate e così via.