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


Sie können ein Gemini-TTS-Modell auffordern, eine Sprachausgabe (Audio) aus einem Text-Prompt 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, d. h., Sie geben den genauen Text an, der in Sprache umgewandelt werden soll. Außerdem können Sie in Ihren Prompts natürliche Sprache verwenden, um Stil, Akzent, Tempo und Ton der Audioausgabe zu steuern. Sie können sich TTS als das Gegenteil der Transkription (Speech-to-Text) vorstellen.

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

Mit dieser Funktion können Sie beispielsweise Folgendes tun:

  • Interaktives Storytelling: Erstellen Sie immersive Hörbücher oder Rollenspiele, bei denen das Modell die Stimme für verschiedene Charaktere wechselt oder den Tonfall an die Erzählung anpasst (z. B. Flüstern bei Spannung oder Lachen über einen Witz).

  • Sprachen lernen: Erstellen Sie Aussprachehilfen, die Text mit bestimmten regionalen Akzenten oder langsamer vorlesen, um Lernenden zu helfen, schwierige Aussprachen zu üben.

  • Kontextsensitive Inhaltsleser: Nachrichtenartikel, Rezepte oder Blogposts werden mit einer Stimme und einem emotionalen Tonfall vorgelesen, die zum Inhalt passen (z. B. ein ernster Tonfall für Eilmeldungen oder ein warmer, geduldiger Tonfall für Schritt-für-Schritt-Kochanleitungen).

In diesem Leitfaden wird beschrieben, wie Sie Sprache aus Texteingaben mit einem oder mehreren Sprechern generieren und die Audioantwort streamen.

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

Vergleich zwischen TTS und dem Live API

Sowohl Text-to-Speech-Modelle (TTS) als auch Live API-Modelle sind sprachgenerierende Modelle mit niedriger Latenz, die für verschiedene Antwortstimmen und Sprachen konfiguriert werden können. Sie dienen jedoch sehr unterschiedlichen Anwendungsfällen.

  • Die Sprachausgabe (Text-to-Speech, TTS) ist eine unidirektionale Anfrage-Antwort-Interaktion (Texteingabe, Audioausgabe). Es ist auf Szenarien zugeschnitten, die eine genaue Wiedergabe des bereitgestellten Textes mit detaillierter Kontrolle über Stil und Klang erfordern, z. B. Podcast-Erzählungen, Hörbücher oder das Vorlesen von Artikeln.

  • Die Live API-Generation unterstützt bidirektionales Streaming für Echtzeit-Sprachunterhaltungen (Spracheingabe, Sprachausgabe). Es eignet sich hervorragend für dynamische Konversationskontexte, 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, lesen Sie den Startleitfaden. 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-Anbieter initialisieren und eine GenerativeModel-Instanz erstellen.

Zum Testen und Iterieren Ihrer 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 mit einem Gemini-TTS-Modell Sprache aus bereitgestelltem Text generieren.

Sprache mit einem einzelnen Sprecher generieren

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Vorbereitung dieses Leitfadens aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API-Anbieter, damit Sie auf dieser Seite anbieterspezifische Inhalte sehen.

Sie können das Modell so konfigurieren, dass Audio mit einer einzelnen Stimme ausgegeben wird.

Fügen Sie in Ihrer GenerationConfig Folgendes ein:

Rufen Sie generateContent mit Ihrem Text-Prompt auf. Das Modell gibt PCM-Audiorohdaten in den Antwortteilen 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 Koroutinenbereich 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

In 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: [ResponseModalities.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',
  generationConfig: 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, führen Sie die Schritte im Abschnitt Vorbereitung dieses Leitfadens aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API-Anbieter, damit Sie auf dieser Seite anbieterspezifische Inhalte sehen.

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

  1. Erstellen Sie eine MultiSpeakerVoiceConfig, die Sprechernamen (die Sie in Ihrem Prompt verwenden) bestimmten Antwortstimm-Namen zuordnet (z. B. Kore).

    Die Konfiguration für mehrere Sprecher unterstützt genau zwei Sprecher.

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

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

    • Konfigurieren Sie einen SpeechConfig mit Folgendem:

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

Rufen Sie generateContent mit Ihrem Text-Prompt auf. Das Modell gibt PCM-Audiorohdaten in den Antwortteilen 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 Koroutinenbereich 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

In 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: [ResponseModalities.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',
  generationConfig: 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, führen Sie die Schritte im Abschnitt Vorbereitung dieses Leitfadens aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für den ausgewählten Gemini API-Anbieter, damit Sie auf dieser Seite anbieterspezifische Inhalte sehen.

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 Streaming von generierter Sprache wird sowohl für Konfigurationen mit einem Sprecher als auch für Konfigurationen mit mehreren Sprechern unterstützt. Er 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 Koroutinenbereich 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

In 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")))
    .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: [ResponseModalities.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',
  generationConfig: 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.

Die folgenden Unterabschnitte zur Prompt-Struktur und zu Audio-Tags enthalten allgemeine Hinweise. Eine ausführliche Anleitung finden Sie in diesem Leitfaden für Prompts.

Prompt-Struktur

Die besten Ergebnisse erzielen Sie, wenn Sie Ihren Prompt mit den folgenden Komponenten strukturieren:

  • Audio Profile: Beschreiben Sie die Persona, 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 Startpunkt (z. B. The speaker is greeting a close friend).

  • Transkript: Der Text, der gesprochen werden soll. Die besten Ergebnisse erzielen Sie, wenn der Ton und der Kontext des Textes mit dem Stimmenprofil 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 Formatierungs-Tags direkt in Ihren Text-Prompt einfügen, um die Leistung des Modells zu steuern.

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

Häufig verwendete Tags sind:

  • [whispers]: Flüstern
  • [laughs]: Um Lachen hinzuzufügen
  • [giggles]: Für mehr Spaß
  • [sighs]: Seufzer hinzufügen
  • [gasp]: Um ein Keuchen hinzuzufü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 mit verschiedenen Emotionen und Ausdrücken (z. B. [bored], [sarcastically] oder sogar [like dracula]) experimentieren, um zu sehen, wie sich die Ausgabe ändert.

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

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 Sprachgenerierung verwenden:

  • Die Konfiguration für mehrere Sprecher 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 stimmt möglicherweise nicht immer genau mit dem ausgewählten Sprecher überein, wenn der Ton und der Kontext Ihres Prompts nicht mit dem Profil des Sprechers übereinstimmen (z. B. eine tiefe männliche Stimme, die versucht, wie ein junges Mädchen zu sprechen). Achten Sie darauf, dass der Kontext des Prompts zur Stimme passt.
  • Längere Ausgaben: Bei Audioinhalten, die länger als ein paar Minuten sind, können die Sprachqualität und die Konsistenz abnehmen. Wir empfehlen, lange Text-Prompts in kleinere Teile 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 von Anfragen auftritt, sollten Sie in Ihrer Anwendung eine Wiederholungslogik implementieren.
  • Falsche Ablehnungen durch den Klassifikator: Vage Prompts können dazu führen, dass der Klassifikator für die Sprachsynthese fehlschlägt. Das kann dazu führen, dass die Anfrage abgelehnt wird (PROHIBITED_CONTENT) oder das Modell Ihre Stilanweisungen laut vorliest. Um dies zu vermeiden, verwenden Sie einen strukturierten Prompt mit einer klaren Präambel (z. B. 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 Abschnitten sind die unterstützten Stimmen und Sprachen aufgeführt, die die Gemini-TTS-Modelle „sprechen“ (oder in denen sie antworten) können.

Die Stimmen sind mehrsprachig. Das bedeutet, dass Sie dieselbe Stimme verwenden können, 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 Kore-Stimme, aber in den verschiedenen Sprachen ausgegeben.

Namen der Stimmen

Die Gemini-TTS-Modelle unterstützen 30 verschiedene synthetisierte HD-Stimmen, die jeweils eigene Merkmale haben. Wenn Sie den Abschnitt unten maximieren, können Sie sich eine Liste der Sprachoptionen für Antworten ansehen und 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.

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

Von allen Audiogenerierungsmodellen 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-Bundle Marathi (Indien) mr-IN
Tamil (Indien) ta-IN Telugu (Indien) te-IN
Zusätzliche Sprachen, die von Audiogenerierungsmodellen der Version 3.x 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
  • Englisch: 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 alles für mich tun?

Andere Funktionen ausprobieren

Informationen zum Steuern der Inhaltsgenerierung

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

Informieren Sie sich über die Modelle, die für verschiedene Anwendungsfälle verfügbar sind, sowie über die zugehörigen Kontingente und Preise.


Feedback zu Ihren Erfahrungen mit Firebase AI Logic geben