Erste Schritte mit der Gemini Live API mit Firebase AI Logic

Vorschau: Die Verwendung der Firebase AI Logic SDKs mit der Gemini Live API ist eine Funktion in der Vorschau. Das bedeutet, dass sie keinem SLA oder keiner Richtlinie zur Einstellung von Produkten und Diensten unterliegt und sich auf nicht abwärtskompatible Weise ändern kann.

Die Gemini Live API ermöglicht latenzarme Sprach- und Videointeraktionen in Echtzeit mit einem Gemini Modell, das bidirektional ist.

Die Live API und ihre spezielle Modellfamilie können kontinuierliche Streams von Audio, Video oder Text verarbeiten, um sofortige, menschenähnliche gesprochene Antworten zu liefern und so einen natürlichen Konversationsmodus für Ihre Nutzer zu ermöglichen.

Auf dieser Seite wird beschrieben, wie Sie mit der häufigsten Funktion beginnen: dem Streaming von Audioeingabe und ‑ausgabe. Die Live API unterstützt jedoch viele verschiedene Funktionen und Konfigurationsoptionen.

Wichtig: Die Gemini Live API ist für bidirektionales Live-Streaming in Echtzeit und speziell für Audioantworten.
Wenn Sie einfaches Streaming von Textantworten verwenden möchten (generateContentStream oder sendMessageStream), finden Sie in unserer Übersicht Informationen zum Streamen von Textantworten.

Die Live API ist eine zustandsbehaftete API, die eine WebSocket-Verbindung herstellt, um eine Sitzung zwischen dem Client und dem Gemini Server einzurichten. Weitere Informationen finden Sie in der Live API Referenzdokumentation (Gemini Developer API | Vertex AI Gemini API).

Zu den Codebeispielen springen

Hilfreiche Ressourcen

• Swift : Schnellstart-App | Android : Schnellstart-App | Web : Schnellstart-App | Flutter : Schnellstart-App | Unity : Bald verfügbar

• Testen Sie die Gemini Live API in einer bereitgestellten App. Die Flutter AI Playground App ist über die Firebase Console zugänglich.

Hinweis

Wenn Sie es noch nicht getan haben, folgen Sie der Anleitung für den Einstieg, dort wird beschrieben, wie Sie Ihr Firebase-Projekt einrichten, Ihre App mit Firebase verbinden, das SDK hinzufügen, den Backend-Dienst für den ausgewählten Gemini API Bereitsteller initialisieren und eine LiveModel Instanz erstellen.

Sie können Prompts und die Live API in Google AI Studio oder Vertex AI Studio prototypisieren.

Modelle, die diese Funktion unterstützen

Gemini 2.5 Flash Live Modelle sind die nativen Audiomodelle, die die Gemini Live API unterstützen. Obwohl das Modell je nach Gemini API-Anbieter unterschiedliche Modellnamen hat, sind das Verhalten und die Funktionen des Modells gleich.

• Gemini Developer API

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

  Obwohl es sich um Vorschaumodelle handelt, sind sie im kostenlosen Kontingent von der Gemini Developer API verfügbar.

• Vertex AI Gemini API

  • gemini-live-2.5-flash-native-audio (veröffentlicht im Dezember 2025)
  • gemini-live-2.5-flash-preview-native-audio-09-2025

  Bei Verwendung der Vertex AI Gemini API, werden die Live API Modelle nicht am global Standort unterstützt.

Audioeingabe und ‑ausgabe streamen

Klicken Sie auf Ihren Gemini API Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen. Gemini Developer API Vertex AI Gemini API

Das folgende Beispiel zeigt die grundlegende Implementierung zum Senden von gestreamter Audioeingabe und zum Empfangen von gestreamter Audioausgabe.

Weitere Optionen und Funktionen für die Live API finden Sie weiter unten auf dieser Seite im Abschnitt „Was können Sie sonst noch tun?".

Swift

Erstellen Sie eine LiveModel Instanz und legen Sie die Antwortmodalität auf audio fest, um die Live API zu verwenden.

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

Erstellen Sie eine LiveModel Instanz und legen Sie die Antwortmodalität auf AUDIO fest, um die Live API zu verwenden.

// 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

Erstellen Sie eine LiveModel Instanz und legen Sie die Antwortmodalität auf AUDIO fest, um die Live API zu verwenden.

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

Erstellen Sie eine LiveGenerativeModel Instanz und legen Sie die Antwortmodalität auf AUDIO fest, um die Live API zu verwenden.

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

Erstellen Sie eine LiveGenerativeModel Instanz und legen Sie die Antwortmodalität auf audio fest, um die Live API zu verwenden.

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
}

Einheit

Erstellen Sie eine LiveModel Instanz und legen Sie die Antwortmodalität auf Audio fest, um die Live API zu verwenden.

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

---

Preise und Tokenanzahl

Preisinformationen für die Live API Modelle finden Sie in der Dokumentation für den ausgewählten Gemini API Anbieter: Gemini Developer API | Vertex AI Gemini API.

Unabhängig vom Gemini API wird die Live API von der Count Tokens API nicht unterstützt.

Hinweis: Firebase AI Logic unterstützt noch nicht den Empfang von UsageMetadata in der Antwort.

---

Was können Sie sonst noch tun?

• Sehen Sie sich die vollständige Palette der Funktionen für die Live API, z. B. das Streamen verschiedener Eingabemodalitäten (Audio, Text oder Video + Audio) an.

• Passen Sie Ihre Implementierung mit verschiedenen Konfigurationsoptionen, an, z. B. durch Hinzufügen einer Transkription oder Festlegen der Antwortstimme.

• Informationen zum Verwalten von Sitzungen, einschließlich des Aktualisierens von Inhalten während der Sitzung, des Komprimierens des Kontextfensters, des Erkennens des Endes einer Sitzung und des Fortsetzens einer Sitzung.

• Optimieren Sie Ihre Implementierung, indem Sie dem Modell Zugriff auf Tools gewähren, z. B. Funktionsaufrufe und Grounding mit Google Search. Die offizielle Dokumentation zur Verwendung von Tools mit der Live API ist bald verfügbar.

• Informationen zu Limits und Spezifikationen, für die Verwendung der Live API, z. B. Sitzungslänge, Ratenlimits, unterstützte Sprachen usw.