Text-zu-Sprache-Generierung (TTS) mit der Gemini API


Sie können ein Gemini-TTS-Modell bitten, aus einem Text-Prompt eine Sprachausgabe (Audio) zu generieren. Wenn Sie Firebase AI Logic verwenden, können Sie diese Anfrage direkt über Ihre App stellen.

Die Text-zu-Sprache-Generierung (TTS) ist steuerbar. Das bedeutet, dass Sie den genauen Text angeben, der in Sprache synthetisiert werden soll. Außerdem können Sie in Ihren Prompts natürliche Sprache verwenden, um Stil, Akzent, Tempo und Ton der Audioausgabe festzulegen. TTS ist das Gegenteil der Transkription (Spracherkennung).

Diese Funktion ist für alle Gemini--tts-Modelle verfügbar, die für die hochwertige Sprachgenerierung mit niedriger Latenz optimiert sind.

Mit dieser Funktion haben Sie beispielsweise folgende Möglichkeiten:

  • Interaktives Storytelling: Erstellen Sie immersive Hörbücher oder Rollenspiele, in denen das Modell die Stimme für verschiedene Charaktere wechselt oder den Ton an die Geschichte anpasst, z. B. flüstert, wenn es spannend wird, oder lacht, wenn ein Witz erzählt wird.

  • Sprachen lernen: Erstellen Sie Aussprachehilfen, die Text mit bestimmten regionalen Akzenten oder in langsamerem Tempo vorlesen können, damit Lernende schwierige Aussprachen üben können.

  • Kontextbezogene Inhalte vorlesen: Nachrichtenartikel, Rezepte oder Blogposts werden mit einer Stimme und einem emotionalen Ton vorgelesen, die zum Inhalt passen (z. B. ein ernster Ton bei Eilmeldungen oder ein warmer, geduldiger Ton bei Schritt-für-Schritt-Kochrezepten).

In dieser Anleitung wird gezeigt, wie Sie Sprache aus Texteingaben mit einem oder mehreren Sprechern generieren und die Audioantwort streamen.

 Zum Code für einen einzelnen Lautsprecher springen  Zum Code für mehrere Lautsprecher springen  Zum Code für gestreamte Antworten springen

Vergleich zwischen TTS und Live API

Sowohl TTS-Modelle (Text-to-Speech) als auch Live API-Modelle sind Modelle mit geringer Latenz, die Sprache generieren und für verschiedene Antwortstimmen und ‑sprachen konfiguriert werden können. Sie sind jedoch für ganz unterschiedliche Anwendungsfälle gedacht.

  • Die Sprachausgabe (Text-to-Speech, TTS) ist eine unidirektionale Anfrage-Antwort-Interaktion (Texteingabe, Audioausgabe). Es ist auf Szenarien zugeschnitten, in denen der bereitgestellte Text genau wiedergegeben werden muss und Stil und Klang präzise gesteuert werden sollen, z. B. bei Podcast-Narrativen, Hörbüchern oder beim Vorlesen von Artikeln.

  • Die Live API-Generation unterstützt bidirektionales Streaming für Sprachunterhaltungen in Echtzeit (Spracheingabe, Sprachausgabe). Es eignet sich hervorragend für dynamische Gesprächskontexte, in denen das Modell entscheidet, welche Sprache zurückgegeben werden soll. Die neuesten Live API-Modelle unterstützen auch Video- und Bildeingaben.

Hinweis

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

Falls noch nicht geschehen, folgen Sie dem Startleitfaden. Darin 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-Anbieter initialisieren und eine GenerativeModel-Instanz erstellen.

Zum Testen und Iterieren von Prompts empfehlen wir die Verwendung von Google AI Studio.

Modelle, die diese Funktion unterstützen

  • gemini-3.1-flash-tts-preview

Sprache aus Text generieren

Sie können Sprache aus bereitgestelltem Text generieren, indem Sie ein Gemini-TTS-Modell verwenden.

Sprache mit einem einzelnen Sprecher generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen ausgewählten Gemini API-Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden.

Sie können das Modell so konfigurieren, dass Audioausgabe mit einer einzelnen Stimme erfolgt.

Fügen Sie in Ihr GenerationConfig Folgendes ein:

  • Legen Sie responseModalities so fest, dass AUDIO enthalten ist.

  • Konfigurieren Sie eine SpeechConfig mit den folgenden Einstellungen:

Rufen Sie generateContent mit Ihrem Text-Prompt auf. Das Modell gibt in den Antwortteilen PCM-Audiorohdaten zurück.

Swift 


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
let config = GenerationConfig(
  responseModalities: [.audio],
  speechConfig: SpeechConfig(voiceName: "Kore", languageCode: "en-US")
)

// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
  modelName: "gemini-3.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt.
let prompt = "Say cheerfully: Have a wonderful day!"

// Call `generateContent` to generate the speech output based on your text prompt.
let response = try await model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let data = part.data          // Raw PCM audio bytes (24kHz, 1 channel, 16-bit)
  let mimeType = part.mimeType  // for example: "audio/pcm"
  print("Received audio data with MIME type: \(mimeType)")

  // To play back raw PCM audio bytes, you'll need to write your own `playRawPcm` function.
  playRawPcm(data: data)
}

Kotlin

In Kotlin sind die Methoden in diesem SDK suspend-Funktionen und müssen aus einem Coroutine-Bereich aufgerufen werden. 

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
    responseModalities = listOf(ResponseModality.AUDIO)
    speechConfig = SpeechConfig(
        voice = Voice("Kore"),
        languageCode = "en-US"
    )
}

// Initialize the Gemini Developer API backend service.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt.
val prompt = "Say cheerfully: Have a wonderful day!"

// Call `generateContent` to generate the speech output based on your text prompt.
val response = model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val pcmData = part.inlineData  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
    val mimeType = part.mimeType   // for example: "audio/pcm"

    // To play back PCM audio data, you'll need to write your own `playAudio` function.
    playAudio(pcmData)
}

Java

Für Java geben die Streamingmethoden in diesem SDK einen Publisher-Typ aus der Reactive Streams-Bibliothek zurück. 

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
GenerationConfig config = new GenerationConfig.Builder()
    .setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
    .setSpeechConfig(new SpeechConfig(new Voice("Kore"), "en-US"))
    .build();

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.1-flash-tts-preview", config);

// Use the GenerativeModelFutures Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt.
String prompt = "Say cheerfully: Have a wonderful day!";
Content content = new Content.Builder().addText(prompt).build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output based on your text prompt.
// Extract the audio data and handle it for downstream use.
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        Part part = result.getCandidates().get(0).getContent().getParts().get(0);
        if (part instanceof InlineDataPart) {
            byte[] pcmData = ((InlineDataPart) part).getInlineData();
            String mimeType = ((InlineDataPart) part).getMimeType();

            // To play back PCM audio data, you'll need to write your own `playAudio` function.
            playAudio(pcmData);
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web 


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
const generationConfig = {
  responseModalities: [ResponseModality.AUDIO],
  speechConfig: {
    voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } },
    languageCode: "en-US"
  }
};

// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
  model: "gemini-3.1-flash-tts-preview",
  generationConfig
});

// Provide a text prompt.
const prompt = "Say cheerfully: Have a wonderful day!";

// Call `generateContent` to generate the speech output based on your text prompt.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const pcmBase64 = inlineDataParts[0].inlineData.data;
  // Decode base64 to ArrayBuffer
  const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;

  // To play back a PCM buffer, you'll need to write your own `playAudio` function.
  playAudio(pcmBuffer);
}

Dart 


import 'package:firebase_ai/firebase_ai.dart';

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
final config = GenerationConfig(
  responseModalities: [ResponseModality.audio],
  speechConfig: SpeechConfig(voiceName: 'Kore', languageCode: 'en-US'),
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-3.1-flash-tts-preview',
  config: config,
);

// Provide a text prompt.
final prompt = 'Say cheerfully: Have a wonderful day!';

// Call `generateContent` to generate the speech output based on your text prompt.
final response = await model.generateContent([Content.text(prompt)]);

// Extract the audio data and handle it for downstream use. For example:
final part = response.candidates.first.content.parts.first;
if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
  final Uint8List pcmData = part.bytes;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

  // To play back PCM audio data, you'll need to write your own `playAudio` function.
  await playAudio(pcmData);
}

Einheit 


using Firebase.AI;

// Set `responseModalities` to include `Audio`.
// Configure a `SpeechConfig` with your chosen voice name and language code.
var config = new GenerationConfig(
  responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
  speechConfig: SpeechConfig.UsePrebuiltVoice("Kore", "en-US")
);

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.1-flash-tts-preview",
  generationConfig: config
);

// Provide a text prompt.
var prompt = "Say cheerfully: Have a wonderful day!";

// Call `GenerateContentAsync` to generate the speech output based on your text prompt.
var response = await model.GenerateContentAsync(prompt);

// Extract the audio data and handle it for downstream use. For example:
if (response.Candidates.Count > 0) {
  foreach (var part in response.Candidates[0].Content.Parts) {
    if (part is ModelContent.InlineDataPart inlineData) {
      byte[] pcmData = inlineData.Data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

      // To play back PCM audio data, you'll need to write your own `playAudio` function.
      playAudio(pcmData);
    }
  }
}

Sprache mit mehreren Sprechern generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen ausgewählten Gemini API-Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden.

Sie können das Modell so konfigurieren, dass für verschiedene Sprecher im Text unterschiedliche Stimmen verwendet werden. Dies ist nützlich, um Audio für Dialoge oder Unterhaltungen zu generieren.

  1. Erstellen Sie eine MultiSpeakerVoiceConfig, in der Sprechernamen (die Sie in Ihrem Prompt verwenden) bestimmten Namen für die Antwortstimme (z. B. Kore) zugeordnet werden.

    Die Konfiguration mit mehreren Sprechern unterstützt genau zwei Sprecher.

  2. Fügen Sie in Ihr GenerationConfig Folgendes ein:

    • Legen Sie responseModalities so fest, dass AUDIO enthalten ist.

    • Konfigurieren Sie eine SpeechConfig mit den folgenden Einstellungen:

      • (Erforderlich) Reichen Sie Ihren MultiSpeakerVoiceConfig ein.

      • (Optional) Sprachcode.
        Wenn Sie keine Sprache angeben, können die Gemini-TTS-Modelle die Sprache im Prompt automatisch erkennen.

  3. Geben Sie in Ihrem Prompt an, wer spricht, indem Sie die Sprechernamen als Präfixe verwenden (z. B. Joe: Hello. Jane: Hi.).

Rufen Sie generateContent mit Ihrem Text-Prompt auf. Das Modell gibt in den Antwortteilen PCM-Audiorohdaten zurück.

Swift 


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
let multiSpeechConfig = SpeechConfig(
  multiSpeakerVoiceConfig: MultiSpeakerVoiceConfig(
    speakerVoiceConfigs: [
      SpeakerVoiceConfig(speaker: "Joe", voiceName: "Puck"),
      SpeakerVoiceConfig(speaker: "Jane", voiceName: "Kore")
    ]
  ),
  languageCode: "en-US"
)

// Set `responseModalities` to include `audio`.
let config = GenerationConfig(
  responseModalities: [.audio],
  speechConfig: multiSpeechConfig
)

// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
  modelName: "gemini-3.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt that includes the names of the speakers.
let prompt = """
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
"""

// Call `generateContent` to generate the speech output based on your text prompt.
let response = try await model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let data = part.data          // Raw PCM audio bytes (24kHz, 1 channel, 16-bit)
  let mimeType = part.mimeType  // for example: "audio/pcm"
  print("Received audio data with MIME type: \(mimeType)")

  // To play back raw PCM audio bytes, you'll need to write your own `playRawPcm` function.
  playRawPcm(data: data)
}

Kotlin

In Kotlin sind die Methoden in diesem SDK suspend-Funktionen und müssen aus einem Coroutine-Bereich aufgerufen werden. 

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
val multiSpeechConfig = SpeechConfig(
    multiSpeakerVoiceConfig = MultiSpeakerVoiceConfig(
        speakerVoiceConfigs = listOf(
            SpeakerVoiceConfig(speaker = "Joe", voice = Voice("Puck")),
            SpeakerVoiceConfig(speaker = "Jane", voice = Voice("Kore"))
        )
    ),
    languageCode = "en-US"
)

// Set `responseModalities` to include `AUDIO`.
val config = generationConfig {
    responseModalities = listOf(ResponseModality.AUDIO)
    speechConfig = multiSpeechConfig
}

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt that includes the names of the speakers.
val prompt = """
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
"""

// Call `generateContent` to generate the speech output based on your text prompt.
val response = model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val pcmData = part.inlineData  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
    val mimeType = part.mimeType   // for example: "audio/pcm"

    // To play back PCM audio data, you'll need to write your own `playAudio` function.
    playAudio(pcmData)
}

Java

Für Java geben die Streamingmethoden in diesem SDK einen Publisher-Typ aus der Reactive Streams-Bibliothek zurück. 

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
MultiSpeakerVoiceConfig multiSpeakerVoiceConfig = new MultiSpeakerVoiceConfig(
    Arrays.asList(
        new SpeakerVoiceConfig("Joe", new Voice("Puck")),
        new SpeakerVoiceConfig("Jane", new Voice("Kore"))
    )
);

SpeechConfig multiSpeechConfig = new SpeechConfig(multiSpeakerVoiceConfig);

// Set `responseModalities` to include `AUDIO`.
GenerationConfig config = new GenerationConfig.Builder()
    .setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
    .setSpeechConfig(multiSpeechConfig)
    .build();

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
         .generativeModel("gemini-3.1-flash-tts-preview", config);

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt that includes the names of the speakers.
String prompt = "Joe: How's it going today Jane?\nJane: Not too bad, how about you?";
Content content = new Content.Builder().addText(prompt).build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output based on your text prompt.
// Extract the audio data and handle it for downstream use.
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        Part part = result.getCandidates().get(0).getContent().getParts().get(0);
        if (part instanceof InlineDataPart) {
            byte[] pcmData = ((InlineDataPart) part).getInlineData();  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
            String mimeType = ((InlineDataPart) part).getMimeType();   // for example: "audio/pcm"

            // To play back PCM audio data, you'll need to write your own `playAudio` function.
            playAudio(pcmData);
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web 


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
const generationConfig = {
  responseModalities: [ResponseModality.AUDIO],
  speechConfig: {
    multiSpeakerVoiceConfig: {
      speakerVoiceConfigs: [
        { speaker: "Joe", voiceConfig: { prebuiltVoiceConfig: { voiceName: "Puck" } } },
        { speaker: "Jane", voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } } }
      ]
    },
    languageCode: "en-US"
  }
};

// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
  model: "gemini-3.1-flash-tts-preview",
  generationConfig
});

// Provide a text prompt that includes the names of the speakers.
const prompt = `
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
`;

// Call `generateContent` to generate the speech output based on your text prompt.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const pcmBase64 = inlineDataParts[0].inlineData.data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
  const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;

  // To play back a PCM buffer, you'll need to write your own `playAudio` function.
  playAudio(pcmBuffer);
}

Dart 


import 'package:firebase_ai/firebase_ai.dart';

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
final multiSpeechConfig = SpeechConfig.multiSpeaker(
  multiSpeakerVoiceConfig: MultiSpeakerVoiceConfig(
    speakerVoiceConfigs: [
      SpeakerVoiceConfig(speaker: 'Joe', voiceName: 'Puck'),
      SpeakerVoiceConfig(speaker: 'Jane', voiceName: 'Kore'),
    ],
  ),
  languageCode: 'en-US',
);

// Set `responseModalities` to include `audio`.
final config = GenerationConfig(
  responseModalities: [ResponseModality.audio],
  speechConfig: multiSpeechConfig,
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-3.1-flash-tts-preview',
  config: config,
);

// Provide a text prompt that includes the names of the speakers.
final prompt = '''
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
''';

// Call `generateContent` to generate the speech output based on your text prompt.
final response = await model.generateContent([Content.text(prompt)]);

// Extract the audio data and handle it for downstream use. For example:
final part = response.candidates.first.content.parts.first;
if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
  final Uint8List pcmData = part.bytes;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

  // To play back PCM audio data, you'll need to write your own `playAudio` function.
  await playAudio(pcmData);
}

Einheit 


using Firebase.AI;

// Configure a `SpeechConfig` for multiple speakers, assigning a voice to each speaker.
var multiSpeakerVoiceConfig = new MultiSpeakerVoiceConfig(
  new System.Collections.Generic.List<SpeakerVoiceConfig> {
    SpeakerVoiceConfig.UsePrebuiltVoice("Joe", "Puck"),
    SpeakerVoiceConfig.UsePrebuiltVoice("Jane", "Kore")
  }
);

var multiSpeechConfig = SpeechConfig.UseMultiSpeakerVoice(multiSpeakerVoiceConfig);

// Set `responseModalities` to include `Audio`.
var config = new GenerationConfig(
  responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
  speechConfig: multiSpeechConfig
);

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.1-flash-tts-preview",
  generationConfig: config
);

// Provide a text prompt that includes the names of the speakers.
var prompt = "Joe: How's it going today Jane?\nJane: Not too bad, how about you?";

// Call `GenerateContentAsync` to generate the speech output based on your text prompt.
var response = await model.GenerateContentAsync(prompt);

// Extract the audio data and handle it for downstream use. For example:
if (response.Candidates.Count > 0) {
  foreach (var part in response.Candidates[0].Content.Parts) {
    if (part is ModelContent.InlineDataPart inlineData) {
      byte[] pcmData = inlineData.Data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

      // To play back PCM audio data, you'll need to write your own `playAudio` function.
      playAudio(pcmData);
    }
  }
}

Antwort streamen

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durcharbeiten, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den von Ihnen ausgewählten Gemini API-Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden.

Sie können schnellere Interaktionen und eine geringere Latenz erreichen, indem Sie die Audioantwort streamen, während sie generiert wird, anstatt zu warten, bis die gesamte Audiodatei fertig ist.

Das Streamen der generierten Sprache wird sowohl für Einzelsprecher- als auch für Mehrfachsprecher-Konfigurationen unterstützt. Sie wird nur bei Verwendung der Gemini 3.x TTS-Modelle unterstützt.

Wenn Sie die Sprachantwort streamen möchten, rufen Sie generateContentStream anstelle von generateContent auf und verarbeiten Sie die Chunks, sobald sie eintreffen. In den folgenden Beispielen wird gezeigt, wie eine Antwort mit einem einzelnen Sprecher gestreamt wird:

Swift 


import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Set `responseModalities` to include `audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
let config = GenerationConfig(
  responseModalities: [.audio],
  speechConfig: SpeechConfig(voiceName: "Kore")
)

// Create a `GenerativeModel` instance with a model that supports speech generation.
let model = ai.generativeModel(
  modelName: "gemini-3.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt.
let prompt = "Tell me a story about a brave knight."

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
let responseStream = try model.generateContentStream(prompt)

// Extract the audio data and handle it for downstream use. For example:
for try await chunk in responseStream {
  for part in chunk.inlineDataParts {
    let data = part.data          // Raw PCM audio bytes (24kHz, 1 channel, 16-bit)
    let mimeType = part.mimeType  // for example: "audio/pcm"

    // Append the audio chunk to your audio queue/buffer for playback.
    appendAudioChunk(data)
  }
}

Kotlin

In Kotlin sind die Methoden in diesem SDK suspend-Funktionen und müssen aus einem Coroutine-Bereich aufgerufen werden. 

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
val config = generationConfig {
    responseModalities = listOf(ResponseModality.AUDIO)
    speechConfig = SpeechConfig(voice = Voice("Kore"))
}

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt.
val prompt = "Tell me a story about a brave knight."

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
// Extract the audio data and handle it for downstream use.
model.generateContentStream(prompt).collect { chunk ->
    val part = chunk.candidates.firstOrNull()?.content?.parts?.firstOrNull()
    if (part is InlineDataPart) {
        val pcmChunk = part.inlineData  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
        val mimeType = part.mimeType    // for example: "audio/pcm"

        // Append the audio chunk to your audio queue/buffer for playback.
        appendAudioChunk(pcmChunk)
    }
}

Java

Für Java geben die Streaming-Methoden in diesem SDK einen Publisher-Typ aus der Reactive Streams-Bibliothek zurück. 

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
GenerationConfig config = new GenerationConfig.Builder()
    .setResponseModalities(Collections.singletonList(ResponseModality.AUDIO))
    .setSpeechConfig(new SpeechConfig(new Voice("Kore")))
    .build();

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3.1-flash-tts-preview", config);

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt.
String prompt = "Tell me a story about a brave knight.";
Content content = new Content.Builder().addText(prompt).build();

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

// Extract the audio data and handle it for downstream use.
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
  @Override
  public void onSubscribe(Subscription s) {
      s.request(Long.MAX_VALUE);
  }

  @Override
  public void onNext(GenerateContentResponse chunk) {
      Part part = chunk.getCandidates().get(0).getContent().getParts().get(0);
      if (part instanceof InlineDataPart) {
          byte[] pcmChunk = ((InlineDataPart) part).getInlineData();  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
          String mimeType = ((InlineDataPart) part).getMimeType();    // for example: "audio/pcm"

          // Append the audio chunk to your audio queue/buffer for playback.
          appendAudioChunk(pcmChunk);
      }
  }

  @Override
  public void onComplete() {
      // Audio stream complete.
  }

  @Override
  public void onError(Throwable t) {
      t.printStackTrace();
  }
});

Web 


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer): Replace with your app's Firebase configuration
const firebaseConfig = { /* ... */ };
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set `responseModalities` to include `AUDIO`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
const generationConfig = {
  responseModalities: [ResponseModality.AUDIO],
  speechConfig: {
    voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } }
  }
};

// Create a `GenerativeModel` instance with a model that supports speech generation.
const model = getGenerativeModel(ai, {
  model: "gemini-3.1-flash-tts-preview",
  generationConfig
});

// Provide a text prompt.
const prompt = "Tell me a story about a brave knight.";

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
const result = await model.generateContentStream(prompt);

// Extract the audio data and handle it for downstream use. For example:
const playbackQueue = [];
for await (const chunk of result.stream) {
  const inlineDataParts = chunk.inlineDataParts();
  if (inlineDataParts?.[0]) {
    const pcmBase64 = inlineDataParts[0].inlineData.data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
    const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;

    // Append the audio chunk to your audio queue/buffer for playback.
    playbackQueue.push(pcmBuffer);
  }
}

// To play back an array of PCM buffers in sequence, you'll need to write your own `processPlaybackQueue` function.
processPlaybackQueue(playbackQueue);

Dart 


import 'package:firebase_ai/firebase_ai.dart';

// Set `responseModalities` to include `audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
final config = GenerationConfig(
  responseModalities: [ResponseModality.audio],
  speechConfig: SpeechConfig(voiceName: 'Kore'),
);

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a model that supports speech generation.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'gemini-3.1-flash-tts-preview',
  config: config,
);

// Provide a text prompt.
final prompt = 'Tell me a story about a brave knight.';

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
final responseStream = model.generateContentStream([Content.text(prompt)]);

// Extract the audio data and handle it for downstream use. For example:
await for (final chunk in responseStream) {
  final part = chunk.candidates.first.content.parts.first;
  if (part is InlineDataPart && part.mimeType.startsWith('audio/')) {
    final Uint8List pcmChunk = part.bytes;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

    // Append the audio chunk to your audio queue/buffer for playback.
    appendAudioChunk(pcmChunk);
  }
}

Einheit 


using System.Collections.Generic;
using System.Linq;
using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Set `ResponseModalities` to include `Audio`.
// Configure a `SpeechConfig` with your chosen voice name (and optionally a language code).
var config = new GenerationConfig(
    responseModalities: new List<ResponseModality> { ResponseModality.Audio },
    speechConfig: SpeechConfig.UsePrebuiltVoice("Kore")
);

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
    modelName: "gemini-3.1-flash-tts-preview",
    generationConfig: config
);

// Provide a text prompt.
var prompt = "Tell me a story about a brave knight.";

// Call `GenerateContentStreamAsync` to generate the speech output stream based on your text prompt.
var responseStream = model.GenerateContentStreamAsync(prompt);

// Extract the audio data and handle it for downstream use. For example:
await foreach (var response in responseStream)
{
    var audioParts = response.Candidates.FirstOrDefault().Content.Parts
                            .OfType<ModelContent.InlineDataPart>();

    foreach (var part in audioParts)
    {
        byte[] pcmChunk = part.Data; // Raw PCM bytes (24kHz, 1 channel, 16-bit)

        // Append the audio chunk to your audio queue/buffer for playback.
        appendAudioChunk(pcmChunk);
    }
}


Sprachausgabe mit Prompts steuern

Sie können den Ton, das Tempo und den Stil der generierten Sprache mit bestimmten Prompting-Techniken beeinflussen.

In den folgenden Unterabschnitten zur Prompt-Struktur und zu Audio-Tags finden Sie allgemeine Informationen. Eine ausführliche Anleitung finden Sie in diesem Leitfaden.

Prompt-Struktur

Für optimale Ergebnisse sollte Ihr Prompt die folgenden Komponenten enthalten:

  • Audio Profile: Beschreibe die Persönlichkeit, die Kernidentität und den Archetyp des Sprechers (z. B. A warm, professional narrator).

  • Scene: Beschreiben Sie die Umgebung und die emotionale Stimmung (z. B. In a quiet library oder Amidst a noisy crowd).

  • Director's Notes: Beschreiben Sie die Emotion, das Tempo, den Stil und den Akzent (z. B. Speak slowly and with mystery).

  • Sample Context: Geben Sie dem Modell einen Start, z. B. The speaker is greeting a close friend.

  • Transkript: Der Text, der gesprochen werden soll. Achten Sie für eine optimale Leistung darauf, dass der Stil und Kontext des Texts mit dem Sprachprofil und den Regieanweisungen übereinstimmen.

Beispielprompt:

[Audio Profile: A young, energetic voice]
[Scene: A lively sports broadcast]
[Director's Notes: Speak fast, with high energy and excitement]
[Sample Context: The game just ended with a last-second touchdown]
Welcome back fans! What an incredible game we're witnessing today!

Audio-Tags

Sie können Formatierungstags direkt in Ihren Text-Prompt einfügen, um die Leistung des Modells zu optimieren.

Audio-Tags werden nur bei Verwendung der Gemini 3.x TTS-Modelle unterstützt.

Häufig verwendete Tags sind:

  • [whispers]: flüstern
  • [laughs]: Lachen hinzufügen
  • [giggles]: Lachen hinzufügen
  • [sighs]: Einen Seufzer hinzufügen
  • [gasp]: Einen Ausruf hinzufügen
  • [shouting]: Schreien
  • [excited]: Aufgeregt sprechen
  • [serious]: Ernsthaft sprechen
  • [sighs whispers]: Kombinierte Emotionen (Sie können Tags kombinieren)

Beachten Sie bei der Verwendung von Audio-Tags Folgendes:

  • Keine vollständige Liste: Es gibt keine feste Liste der unterstützten Tags. Sie können verschiedene Emotionen und Ausdrücke (z. B. [bored], [sarcastically] oder [like dracula]) ausprobieren, um zu sehen, wie sich die Ausgabe ändert.

  • Nicht englischsprachiger Text-Prompt: Wenn Ihr Text-Prompt nicht auf Englisch ist, sollten Sie trotzdem englische Audio-Tags verwenden, um optimale Ergebnisse zu erzielen.

Beispielprompt:

I have a secret to tell you. [whispers] I found the hidden treasure. [laughs] I can't believe it!


Beschränkungen und Anforderungen

Beachten Sie die folgenden Einschränkungen und Anforderungen, wenn Sie die Sprachsynthese verwenden:

  • Die Konfiguration mit mehreren Sprechern unterstützt genau zwei Sprecher.

  • Die folgenden Funktionen werden nur bei Verwendung der Gemini 3.x TTS-Modelle unterstützt: Streaming, Audio-Tags und zusätzliche automatisch erkannte Sprachen.

Einschränkungen für gemini-3.1-flash-tts-preview

  • Inkonsistente Stimme: Die Ausgabe des Modells entspricht möglicherweise nicht immer genau der ausgewählten Stimme, wenn der Ton und Kontext Ihres Prompts nicht mit dem Profil der Stimme übereinstimmen (z. B. wenn eine tiefe männliche Stimme versucht, wie ein junges Mädchen zu sprechen). Achten Sie darauf, dass der Kontext Ihres Prompts zur Stimme passt.
  • Längere Ausgaben: Bei Audioinhalten, die länger als einige Minuten sind, kann es zu Abweichungen bei Sprachqualität und Konsistenz kommen. Wir empfehlen, lange Text-Prompts in kleinere Abschnitte aufzuteilen.
  • Gelegentliche Rückgabe von Text-Tokens: Das Modell gibt gelegentlich Text-Tokens anstelle von Audio-Tokens zurück, was dazu führt, dass die Anfrage mit einem 500-Fehler fehlschlägt. Da dies zufällig bei einem kleinen Prozentsatz der Anfragen auftritt, sollten Sie in Ihrer App eine Wiederholungslogik implementieren.
  • Falsche Ablehnungen durch den Klassifikator: Unklare Prompts können den Klassifikator für die Sprachsynthese nicht bestehen. Dies führt zu einer abgelehnten Anfrage (PROHIBITED_CONTENT) oder dazu, dass das Modell Ihre Stilanweisungen laut vorliest. Um dies zu vermeiden, verwenden Sie einen strukturierten Prompt mit einer klaren Einleitung (wie Audio Profile und Director's Notes) am Anfang des Prompts.


Unterstützte Stimmen und Sprachen

Die Gemini-TTS-Modelle nehmen Texteingaben entgegen und generieren Audioausgaben. Die Antwort ist also die synthetisierte Sprache selbst. In den folgenden Unterabschnitten sind die unterstützten Stimmen und Sprachen aufgeführt, in denen die Gemini-TTS-Modelle sprechen (oder antworten) können.

Die Stimmen sind mehrsprachig. Sie können also dieselbe Stimme verwenden, um Sprache in einer der unterstützten Sprachen zu generieren. Sie können die Stimme beispielsweise auf Kore festlegen und eine Reihe von Text-Prompts auf Spanisch, Hindi und Vietnamesisch senden. Die Antworten werden alle in der Stimme von Kore, aber in den jeweiligen Sprachen verfasst.

Namen der Stimmen

Die Gemini-TTS-Modelle unterstützen 30 verschiedene synthetisierte HD-Stimmen mit jeweils eigenen Merkmalen. Wenn Sie den Abschnitt unten maximieren, sehen Sie eine Liste der verfügbaren Stimmen und können sich Demos der einzelnen Stimmen anhören.

Sprachen

Die Gemini-TTS-Modelle können die folgenden Sprachen in Ihrem Text-Prompt automatisch erkennen. Die generierte Sprache wird in dieser Sprache ausgegeben.

Optional können Sie in Ihrer Sprachkonfiguration explizit einen Sprachcode festlegen.

Von allen Modellen zur Audiogenerierung unterstützte Sprachen
Sprache BCP-47-Code Sprache BCP-47-Code
Arabisch (Ägypten) ar-EG Deutsch (Deutschland) de-DE
Englisch (USA) en-US Spanisch (USA) es-US
Französisch (Frankreich) fr-FR Hindi (Indien) hi-IN
Indonesisch (Indonesien) id-ID Italienisch (Italien) it-IT
Japanisch (Japan) ja-JP Koreanisch (Korea) ko-KR
Portugiesisch (Brasilien) pt-BR Russisch (Russland) ru-RU
Niederländisch (Niederlande) nl-NL Polnisch (Polen) pl-PL
Thailändisch (Thailand) th-TH Türkisch (Türkei) tr-TR
Vietnamesisch (Vietnam) vi-VN Rumänisch (Rumänien) ro-RO
Ukrainisch (Ukraine) uk-UA Bengalisch (Bangladesch) bn-BD
Englisch (Indien) en-IN- und hi-IN-Set Marathi (Indien) mr-IN
Tamil (Indien) ta-IN Telugu (Indien) te-IN
Zusätzliche Sprachen, die von Modellen der Version 3.x zur Audioerstellung unterstützt werden
Sprache BCP-47-Code Sprache BCP-47-Code
Afrikaans af Filipino fil
Albanisch sq Finnisch fi
Amharisch vormittags Galizisch gl
Armenisch hy Georgisch ka
Aserbaidschanisch az Griechisch el
Baskisch eu Gujarati gu
Belarussisch be Haitianisch ht
Bulgarisch bg Hebräisch er
Burmesisch mein Ungarisch hu
Katalanisch Zertifizierungsstelle Isländisch ist
Cebuano ceb Javanisch jv
Chinesisch (Mandarin) cmn Kannada kn
Kroatisch Std. Konkani kok
Tschechisch cs Lao lo
Dänisch da Latein la
Estnisch et Lettisch lv
Litauisch lt Luxemburgisch lb
Mazedonisch mk Maithili mai
Malagasy mg Malaiisch ms
Malayalam ml Mongolisch mn
Nepalesisch ne Norwegisch (Bokmål) nb
Norwegisch (Nynorsk) nn Oriya oder
Paschtu ps Persisch fa
Punjabi pa Serbisch sr
Sindhi sd Singhalesisch si
Slowakisch sk Slowenisch sl
Swahili sw Schwedisch sv
Urdu ur

(Optional) Sprachcode explizit festlegen

Wenn Sie in Ihrer Sprachkonfiguration keinen Sprachcode angeben, erkennt das Modell die Sprache in Ihrem Text-Prompt automatisch.

Sie können die Sprache jedoch optional explizit festlegen (mit dem Parameter languageCode in der Sprachkonfiguration). Dazu müssen Sie einen der folgenden unterstützten BCP-47-Sprachcodes verwenden:

  • Arabisch: ar-XA
  • Bengalisch: bn-IN
  • Chinesisch (Mandarin): cmn-CN
  • Niederländisch: nl-NL
  • Deutsch: en-US, en-GB, en-AU, en-IN
  • Französisch: fr-FR, fr-CA
  • Deutsch: de-DE
  • Gujarati: gu-IN
  • Hindi: hi-IN
  • Indonesisch: id-ID
  • Italienisch: it-IT
  • Japanisch: ja-JP
  • Kannada: kn-IN
  • Koreanisch: ko-KR
  • Malayalam: ml-IN
  • Marathi: mr-IN
  • Polnisch: pl-PL
  • Portugiesisch: pt-BR
  • Russisch: ru-RU
  • Spanisch: es-US, es-ES
  • Tamil: ta-IN
  • Telugu: te-IN
  • Thailändisch: th-TH
  • Türkisch: tr-TR
  • Vietnamesisch: vi-VN


Was kannst du sonst noch tun?

Andere Funktionen ausprobieren

Informationen zum Steuern der Inhaltserstellung

  • Prompt-Design – Best Practices, Strategien und Beispiel-Prompts
  • Modellparameter konfigurieren, z. B. maximale Anzahl von Ausgabetokens, Wahrscheinlichkeit wiederholter Ausgabetokens usw.
  • Mit den Sicherheitseinstellungen können Sie die Wahrscheinlichkeit anpassen, Antworten zu erhalten, die als schädlich eingestuft werden könnten.
Sie können auch mit Prompts und Modellkonfigurationen experimentieren und sogar ein generiertes Code-Snippet mit Google AI Studio abrufen.

Weitere Informationen zu den unterstützten Modellen

Verfügbare Modelle für verschiedene Anwendungsfälle sowie ihre Kontingente und Preise


Feedback zu Firebase AI Logic geben