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


Sie können ein Gemini-TTS-Modell (gemini-3.8-flash-tts oder gemini-3.8-flash-lite-tts) verwenden, um aus Text natürliche, ausdrucksstarke Sprache (Audio) zu synthetisieren. Wenn Sie Firebase AI Logic verwenden, können Sie diese Anfrage direkt über Ihre mobile App oder Web-App stellen, z. B. über Ihre Apple- (Swift), Android- (Kotlin/Java), Web- (JavaScript), Flutter- (Dart) oder Unity-App.

Die Text-zu-Sprache-Generierung (TTS) ist steuerbar. Das bedeutet, dass Sie den genauen Text angeben, der in Sprache umgewandelt werden soll, und gleichzeitig die Ausgabe steuern können, z. B. Emotionen, Tempo, Sprecherstimmen und nicht-sprachliche Geräusche wie Lachen oder Seufzen. Dazu verwenden Sie strukturierte Metadaten und Inline-Stimm-Tags. Sie können sich TTS als das Gegenteil der Transkription (Speech-to-Text) vorstellen.

Mit dieser Funktion können Sie beispielsweise Folgendes erstellen:

  • Interaktives Storytelling und Hörbücher: Erzählen Sie lange Geschichten oder Rollenspiele, bei denen die Charaktere die Stimme wechseln, mit überlappenden Backchannels aufeinander reagieren und ihre emotionale Darbietung anpassen (z. B. Flüstern in spannenden Momenten oder Lachen über einen Witz).
  • Sprach-Agents und -Assistenten mit niedriger Latenz: Synthetisierte Sprache wird gestreamt, sobald Text von einem LLM eingeht. Dabei wird eine konsistente Sprachpersona über alle Gesprächsrunden hinweg beibehalten.
  • Mehrsprachige Inhaltsleser und Sprachtutoren: Lassen Sie sich Artikel, Rezepte oder Lernmaterialien in mehr als 130 Sprachen und regionalen Akzenten vorlesen oder wechseln Sie innerhalb einer Unterhaltung nahtlos die Sprache.

In diesem Leitfaden wird beschrieben, wie Sie Sprache mit einem oder mehreren Sprechern generieren, Audioantworten streamen, die Sprachausgabe mit SpeechMetadata und Inline-Tags steuern und aus vordefinierten, Bibliotheks- oder benutzerdefinierten Stimmen auswählen.

Zum Code für einen einzelnen Sprecher springen Zum Code für mehrere Sprecher springen Zum Code für Streaming springen

Vergleich zwischen TTS und dem Live API

Sowohl Text-zu-Sprache-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.8-flash-tts
  • gemini-3.8-flash-lite-tts
Vergleich von TTS-Modellen

Beide Gemini 3.x TTS-Modelle haben dasselbe Anfrageschema und Prompt-Format. Hier sind jedoch einige Unterschiede, die Ihnen bei der Entscheidung helfen können, welches Modell Sie verwenden sollten.

Funktion oder Arbeitslast gemini-3.8-flash-tts gemini-3.8-flash-lite-tts
Primäre Stärke Stimmtreue in Studioqualität, schauspielerische Nuancen und breite Dialektabdeckung Hoher Durchsatz, niedrige Latenz und Kosteneffizienz
Ideale Anwendungsfälle Hörbücher, Studio-Erzählung, komplexe Dialoge mit mehreren Sprechern, häufige Vocal-Burst-Tags, schwierige Aussprache, regionale Dialekte Produktion in großem Umfang, Echtzeit-Sprach-Agenten-Kaskaden, UI-Funktionen zum Vorlesen, alltägliche Sprachausgabe mit einem Sprecher
Unterstützte Sprachen 132 Sprachen 103 Sprachen

Sprache aus Text generieren

Sie können Sprache aus Texteingaben in einer Stimme mit einem Sprecher oder einem Dialog mit zwei Sprechern generieren, entweder als vollständige WAV-Datei (generateContent) oder als PCM-Roh-Audiostream mit niedriger Latenz (generateContentStream).

Sprache mit einem einzelnen Sprecher generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durchgehen, 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 Sie auf dieser Seite anbieterspezifische Inhalte sehen.

So generieren Sie Audio mit einem einzelnen Sprecher:

  1. Legen Sie in Ihrer GenerationConfig responseModalities auf AUDIO fest und konfigurieren Sie eine SpeechConfig mit Folgendem:

  2. Erstellen Sie ein TextPart mit folgendem Inhalt:

    • (Erforderlich) Das wörtliche Transkript, das gesprochen werden soll.

    • (Optional) Ein SpeechMetadata mit einer style-Beschreibung (z. B. "cheerful and friendly").

  3. Rufen Sie generateContent an. Standardmäßig geben unäre Anfragen eine vollständige WAV-Audiodatei (audio/wav) (16-Bit-lineares PCM, 24 kHz, Mono, mit einem standardmäßigen 44-Byte-RIFF-Header) in den Inline-Datenteilen der Antwort 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.8-flash-tts",
  generationConfig: config
)

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
let prompt = TextPart(
  "Have a wonderful day!",
  speechMetadata: SpeechMetadata(style: "cheerful and friendly")
)

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

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

  // Play the WAV audio data using your own playback helper (for example, with `AVAudioPlayer(data: wavData)`).
  playAudio(data: wavData)
}

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.
// Create a `GenerativeModel` instance with a model that supports speech generation.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.8-flash-tts",
        generationConfig = config
    )

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
    text(
        text = "Have a wonderful day!",
        speechMetadata = SpeechMetadata(style = "cheerful and friendly")
    )
}

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

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

    // Pass the audio data to your audio player or playback helper (which you'll need to implement).
    playAudio(wavData)
}

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.8-flash-tts", config);

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

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
Content content = new Content.Builder()
    .addText("Have a wonderful day!", new SpeechMetadata(null, "cheerful and friendly"))
    .build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output.
// Extract the WAV 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[] wavData = ((InlineDataPart) part).getInlineData();  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

            // Pass the audio data to your audio player or playback helper (which you'll need to implement).
            playAudio(wavData);
        }
    }

    @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.8-flash-tts",
  generationConfig
});

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
const prompt = [
  {
    type: "text",
    text: "Have a wonderful day!",
    speechMetadata: { style: "cheerful and friendly" }
  }
];

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

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

  // The response is a complete WAV file, so the Web Audio API can decode and play it directly.
  const audioCtx = new AudioContext();
  const audioBuffer = await audioCtx.decodeAudioData(wavBuffer);
  const source = audioCtx.createBufferSource();
  source.buffer = audioBuffer;
  source.connect(audioCtx.destination);
  source.start();
}

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.8-flash-tts',
  generationConfig: config,
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
final prompt = Content.multi([
  TextPart(
    'Have a wonderful day!',
    speechMetadata: SpeechMetadata(style: 'cheerful and friendly'),
  ),
]);

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

// Extract the WAV 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 wavData = part.bytes;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

  // Play the WAV audio data using your preferred audio player or helper (which you'll need to implement).
  await playAudio(wavData);
}

Einheit


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 language code.
var config = new GenerationConfig(
  responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
  speechConfig: SpeechConfig.UsePrebuiltVoice("Kore", "en-US")
);

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

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
var prompt = new ModelContent(
  new ModelContent.TextPart(
    "Have a wonderful day!",
    new SpeechMetadata(speaker: null, style: "cheerful and friendly")
  )
);

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

// Extract the WAV 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[] wavData = inlineData.Data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

      // Pass the audio data to your audio player or playback helper (which you'll need to implement).
      PlayAudio(wavData);
    }
  }
}

Sprache mit mehreren Sprechern generieren

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durchgehen, 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 Sie auf dieser Seite anbieterspezifische Inhalte sehen.

Sie können eine natürliche Unterhaltung zwischen zwei Sprechern in einer einzigen Anfrage generieren, indem Sie jedem Sprecher eine eigene Stimme zuweisen und jede Dialogzeile als eigene TextPart übergeben:

  1. Erstellen Sie eine MultiSpeakerVoiceConfig, die zwei Sprechernamen (z. B. "Joe" und "Jane") ihren SpeakerVoiceConfig-Stimmen zuordnet.

  2. Legen Sie in GenerationConfig für responseModalities den Wert AUDIO fest und übergeben Sie MultiSpeakerVoiceConfig (und optional languageCode) an SpeechConfig.

  3. Geben Sie ein Array oder eine Liste von TextPart-Objekten an, genauer gesagt ein TextPart pro Dialogrunde. Legen Sie für jeden TextPart Folgendes für SpeechMetadata fest:

    • (Erforderlich) Ein speaker, der mit einem der in Ihrer MultiSpeakerVoiceConfig definierten Sprechernamen übereinstimmt.
    • (Optional) Eine style-Beschreibung (z. B. "cheerful and friendly").
  4. Rufen Sie generateContent an. Das Modell synthetisiert die gesamte Unterhaltung und gibt eine vollständige WAV-Audiodatei (audio/wav) 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.8-flash-tts",
  generationConfig: config
)

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
let prompt: [any PartsRepresentable] = [
  TextPart(
    "How's it going today, Jane?",
    speechMetadata: SpeechMetadata(speaker: "Joe", style: "cheerful and friendly")
  ),
  TextPart(
    "Not too bad, how about you?",
    speechMetadata: SpeechMetadata(speaker: "Jane", style: "calm and relaxed")
  )
]

// Call `generateContent` to generate the multi-speaker speech output.
let response = try await model.generateContent(prompt)

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

  // Play the WAV audio data using your own playback helper (for example, with `AVAudioPlayer(data: wavData)`).
  playAudio(data: wavData)
}

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.8-flash-tts",
        generationConfig = config
    )

// Provide one text part per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
val prompt = content {
    text(
        text = "How's it going today, Jane?",
        speechMetadata = SpeechMetadata(speaker = "Joe", style = "cheerful and friendly")
    )
    text(
        text = "Not too bad, how about you?",
        speechMetadata = SpeechMetadata(speaker = "Jane", style = "calm and relaxed")
    )
}

// Call `generateContent` to generate the multi-speaker speech output.
val response = model.generateContent(prompt)

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

    // Pass the audio data to your audio player or playback helper (which you'll need to implement).
    playAudio(wavData)
}

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, "en-US");

// 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.8-flash-tts", config);

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

// Provide one text part per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
Content content = new Content.Builder()
    .addText(
        "How's it going today, Jane?",
        new SpeechMetadata("Joe", "cheerful and friendly"))
    .addText(
        "Not too bad, how about you?",
        new SpeechMetadata("Jane", "calm and relaxed"))
    .build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the multi-speaker speech output.
// Extract the WAV 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[] wavData = ((InlineDataPart) part).getInlineData();  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

            // Pass the audio data to your audio player or playback helper (which you'll need to implement).
            playAudio(wavData);
        }
    }

    @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.8-flash-tts",
  generationConfig
});

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `speechMetadata`.
const prompt = [
  {
    type: "text",
    text: "How's it going today, Jane?",
    speechMetadata: { speaker: "Joe", style: "cheerful and friendly" }
  },
  {
    type: "text",
    text: "Not too bad, how about you?",
    speechMetadata: { speaker: "Jane", style: "calm and relaxed" }
  }
];

// Call `generateContent` to generate the multi-speaker speech output.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

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

  // The response is a complete WAV file, so the Web Audio API can decode and play it directly.
  const audioCtx = new AudioContext();
  const audioBuffer = await audioCtx.decodeAudioData(wavBuffer);
  const source = audioCtx.createBufferSource();
  source.buffer = audioBuffer;
  source.connect(audioCtx.destination);
  source.start();
}

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.8-flash-tts',
  generationConfig: config,
);

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
final prompt = Content.multi([
  TextPart(
    "How's it going today, Jane?",
    speechMetadata: SpeechMetadata(speaker: 'Joe', style: 'cheerful and friendly'),
  ),
  TextPart(
    'Not too bad, how about you?',
    speechMetadata: SpeechMetadata(speaker: 'Jane', style: 'calm and relaxed'),
  ),
]);

// Call `generateContent` to generate the multi-speaker speech output.
final response = await model.generateContent([prompt]);

// Extract the WAV 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 wavData = part.bytes;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

  // Play the WAV audio data using your preferred audio player or helper (which you'll need to implement).
  await playAudio(wavData);
}

Einheit


using Firebase.AI;

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

// 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, "en-US");

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

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

// Provide one `TextPart` per dialogue turn, specifying the speaker and optional style in `SpeechMetadata`.
var prompt = new ModelContent(
  new ModelContent.TextPart(
    "How's it going today, Jane?",
    new SpeechMetadata(speaker: "Joe", style: "cheerful and friendly")
  ),
  new ModelContent.TextPart(
    "Not too bad, how about you?",
    new SpeechMetadata(speaker: "Jane", style: "calm and relaxed")
  )
);

// Call `GenerateContentAsync` to generate the multi-speaker speech output.
var response = await model.GenerateContentAsync(prompt);

// Extract the WAV 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[] wavData = inlineData.Data;  // WAV audio bytes (24kHz, 1 channel, 16-bit PCM)

      // Pass the audio data to your audio player or playback helper (which you'll need to implement).
      PlayAudio(wavData);
    }
  }
}

Antwort streamen

Bevor Sie dieses Beispiel ausprobieren, müssen Sie den Abschnitt Vorbereitung in diesem Leitfaden durchgehen, 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 Sie auf dieser Seite anbieterspezifische Inhalte sehen.

Für eine kürzere Zeit bis zum ersten Audio (TTFA) und eine Echtzeitwiedergabe können Sie die Audioantwort streamen, während sie generiert wird, anstatt auf die Fertigstellung des gesamten Clips zu warten. Streaming funktioniert sowohl mit Einzelsprecher- als auch mit Mehrsprecher-Konfigurationen.

Wenn Sie Sprache streamen möchten, rufen Sie generateContentStream anstelle von generateContent auf. Im Gegensatz zu unären Anfragen (die eine WAV-Datei zurückgeben) geben Streaming-Anfragen headerlose, signierte 16-Bit-Little-Endian-PCM-Rohdatenblöcke (audio/l16, 24 kHz, Mono) zurück, sodass Sie jeden Block direkt an Ihren Audioausgabepuffer anhängen können.

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.8-flash-tts",
  generationConfig: config
)

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
let prompt = TextPart(
  "Tell me a story about a brave knight.",
  speechMetadata: SpeechMetadata(style: "warm, engaging audiobook narrator")
)

// Call `generateContentStream` to stream the speech output as it is generated.
let responseStream = try model.generateContentStream(prompt)

// Extract the raw PCM audio chunks and queue them for playback:
for try await chunk in responseStream {
  for part in chunk.inlineDataParts {
    let pcmChunk = part.data  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

    // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
    appendAudioChunk(pcmChunk)
  }
}

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.8-flash-tts",
        generationConfig = config
    )

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
val prompt = content {
    text(
        text = "Tell me a story about a brave knight.",
        speechMetadata = SpeechMetadata(style = "warm, engaging audiobook narrator")
    )
}

// Call `generateContentStream` to stream the speech output as it is generated.
// Extract the raw PCM audio chunks and queue them for playback.
model.generateContentStream(prompt).collect { chunk ->
    val part = chunk.candidates.firstOrNull()?.content?.parts?.firstOrNull()
    if (part is InlineDataPart) {
        val pcmChunk = part.inlineData  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

        // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
        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.8-flash-tts", config);

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

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
Content content = new Content.Builder()
    .addText(
        "Tell me a story about a brave knight.",
        new SpeechMetadata(null, "warm, engaging audiobook narrator"))
    .build();

// Call `generateContentStream` to stream the speech output as it is generated.
Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

// Extract the raw PCM audio chunks and queue them for playback.
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();  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

          // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
          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.8-flash-tts",
  generationConfig
});

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
const prompt = [
  {
    type: "text",
    text: "Tell me a story about a brave knight.",
    speechMetadata: { style: "warm, engaging audiobook narrator" }
  }
];

// Call `generateContentStream` to stream the speech output as it is generated.
const result = await model.generateContentStream(prompt);

// Extract the raw PCM audio chunks and queue them for playback:
const playbackQueue = [];
for await (const chunk of result.stream) {
  const inlineDataParts = chunk.inlineDataParts();
  if (inlineDataParts?.[0]) {
    const pcmBase64 = inlineDataParts[0].inlineData.data;  // Headerless 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.
    // In a real app, start playing chunks as they arrive (rather than waiting for
    // the whole stream to finish) to get the low-latency benefit of streaming.
    playbackQueue.push(pcmBuffer);
  }
}

// To play back an array of PCM buffers in sequence, pass them to your playback helper (which you'll need to write).
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.8-flash-tts',
  generationConfig: config,
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
final prompt = Content.multi([
  TextPart(
    'Tell me a story about a brave knight.',
    speechMetadata: SpeechMetadata(style: 'warm, engaging audiobook narrator'),
  ),
]);

// Call `generateContentStream` to stream the speech output as it is generated.
final responseStream = model.generateContentStream([prompt]);

// Extract the raw PCM audio chunks and queue them for playback:
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;  // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

    // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
    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.8-flash-tts",
    generationConfig: config
);

// Provide the verbatim text to synthesize as speech.
// Optionally provide turn-level style metadata.
var prompt = new ModelContent(
    new ModelContent.TextPart(
        "Tell me a story about a brave knight.",
        new SpeechMetadata(speaker: null, style: "warm, engaging audiobook narrator")
    )
);

// Call `GenerateContentStreamAsync` to stream the speech output as it is generated.
var responseStream = model.GenerateContentStreamAsync(prompt);

// Extract the raw PCM audio chunks and queue them for playback:
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; // Headerless raw PCM bytes (24kHz, 1 channel, 16-bit)

        // Append the audio chunk to your audio queue/buffer for playback (using a helper you implement).
        AppendAudioChunk(pcmChunk);
    }
}



Sprachausgabe mit Metadaten und Inline-Tags steuern

Die Gemini 3.x TTS-Modelle behandeln die text in jedem TextPart strikt als wörtliches Transkript, das laut vorgelesen werden soll. Schreiben Sie keine narrativen Anweisungen (z. B. "Say cheerfully:") in den Textstring, da das Modell diese Wörter sonst möglicherweise vorliest.

Sie können die Gesangsleistung mit den folgenden Techniken steuern:

style auf Turn-Ebene und Inline-Vocal-Tags

Teilen Sie Ihre Leistungsanweisungen nach Bereich zwischen SpeechMetadata und Inline-Tags mit spitzen Klammern (<...>) auf.

Umfang Platzierung Was wird gesteuert? Beispiele
Kurvenfahrt
(während der gesamten Kurvenfahrt)
SpeechMetadata.style Emotion, Persona, Tonfall, Betonung, Tonhöhe und allgemeine Sprechgeschwindigkeit "cheerful and friendly",
"whispered, nervous",
"speaking rapidly",
"out of breath",
"sarcastic"
Zeitpunkt
(auf einen bestimmten Moment im Satz bezogen)
Inline in TextPart-Text mit <...> Nicht sprachliche menschliche Laute, Atemgeräusche, Pausen oder vorübergehende Veränderungen der Sprechweise "Wait... <short pause> did you hear that? <gasp> Someone's at the door."

Tempo, Pausen, Tonhöhe und Betonung

  • Satzzeichen und Auslassungspunkte: Verwenden Sie im Transkript Kommas, Gedankenstriche (--) und Auslassungspunkte (...), um natürliche Formulierungen und Zögern zu erzeugen.

  • Explizite Pausen-Tags: Fügen Sie <short pause> oder <long pause> inline an der genauen Stelle ein, an der der Sprecher eine Pause einlegen soll:

    Hold on, let me think... <short pause> Alright, I've got it.
    
  • Sprechgeschwindigkeit und Tonhöhe: Legen Sie style in SpeechMetadata fest, um die Gesamtgeschwindigkeit, Tonhöhe oder Intonation für den Turn zu steuern (z. B. "speaking rapidly and excitedly", "speaking slowly" oder "monotone and flat"). Wenn sich die Emotion oder Geschwindigkeit mitten im Monolog ändert, teilen Sie das Skript in separate TextPart-Turns auf, jeweils mit einem eigenen style.

  • Wortbetonung: Bestimmte Wörter im Transkript großschreiben, um sie zu betonen:

    It was a VERY long day <sigh> ... nobody listens anymore.
    

Vokale Ausrufe und Geräusche, die keine Sprache sind

Fügen Sie nichtsprachliche menschliche Laute inline mit spitzen Klammern (<...>) an der genauen Wortgrenze ein, an der der Laut auftreten soll. Verwenden Sie menschliche Laute anstelle von nicht-vokalen Soundeffekten. Hier sind empfohlene Tags:

<argh> <exhales> <heavy breath> <scream> <snort>
<breath> <gasp> <hiss> <short pause> <sob>
<cackle> <giggle> <laugh> /
<laughter>
<shout> <throat-clearing>
<cheer> <groan> <long pause> <shriek> <tsk>
<chuckle> /
<chuckles>
<growl> <moan> <sigh> /
<sighs>
<whimper>
<cough> <grr> <pant> <sneeze> <whispers> /
<whispering>
<cry> <grunt> <pff> /
<phew>
<snicker> <yawn>

Backchannels und gleichzeitig sprechende Stimmen

In einem Dialog mit mehreren Sprechern können Sie kurze Reaktionen des Zuhörers im Transkript des aktiven Sprechers in Pipe-Zeichen (|reaction|) setzen. Der nicht aktive Sprecher wirft an dieser Stelle auf natürliche Weise etwas ein, ohne dass ein separater Turn erforderlich ist:

  • Kurze Rückmeldungen von Zuhörern:

    • Runde 1 (speaker: "Joe"): "So the launch is Thursday |oh hmm| Are we actually ready?"
    • Runde 2 (speaker: "Jane"): "Ready enough |oh really?| The last blocker cleared this morning."
  • Überlappende Sprache: Sie können mehrere Pipe-Segmente verwenden, um gleichzeitiges Sprechen zu simulieren (funktioniert am besten mit gemini-3.8-flash-tts), z. B.:

    • Runde 1 (speaker: "Joe"): "Let's surprise him on three |ok| ready?"
    • Runde 2 (speaker: "Jane"): "one. two. three. |happy| happy |birthday| birthday!"

Best Practices für Konsistenz

  • Testen Sie zuerst ohne style und fügen Sie dann prägnante style-Anpassungen hinzu: Die meisten Anfragen klingen mit einem leeren style-Feld natürlich. Fügen Sie nur dann eine kurze style-Phrase (z. B. "casual, friendly" oder "reflective and awe-inspired") hinzu, wenn für einen Turn eine bestimmte Anpassung der Ausgabe erforderlich ist. Verwenden Sie dieselbe kurze Zeichenfolge für mehrere Turns, wenn Sie eine einheitliche Baseline wünschen.

  • Natürliche gesprochene Transkripte schreiben: Fügen Sie umgangssprachliche Kontraktionen und natürliche Unflüssigkeiten (wie "Oh, uh, yeah I think... hm, that's interesting") direkt in den Transkripttext ein.

  • Vermeiden Sie veraltete [Audio Profile]-Blöcke und Metaanweisungen: Lange Persona-Absätze, [Director's Notes]-Blöcke oder Metaanweisungen wie "maintain identical timbre" erhöhen die Voice-Drift. Wählen Sie stattdessen eine passende Stimme aus der erweiterten Stimmenbibliothek aus oder erstellen Sie mit Stimmendesign eine dauerhafte Stimme für die Figur.

  • Versuchen Sie nicht, unveränderliche Stimmmerkmale in style zu überschreiben: Verwenden Sie SpeechMetadata.style nicht, um das Alter, das Geschlecht oder den permanenten Akzent einer Stimme zu ändern. Wählen Sie stattdessen eine Stimme mit diesen Eigenschaften aus oder erstellen Sie eine.



Unterstützte Stimmen

Die Gemini 3.x TTS-Modelle unterstützen drei Möglichkeiten, eine Stimme anzugeben:

Alle Stimmen sind mehrsprachig. Das bedeutet, dass Sie dieselbe Stimme verwenden können, um Sprache in einer der unterstützten Sprachen zu generieren, während die Identität des Sprechers konsistent bleibt. Wenn Sie beispielsweise die vordefinierte Stimme Kore festlegen und Prompts auf Spanisch, Hindi und Vietnamesisch senden, werden die Antworten in allen diesen Sprachen mit der Stimme Kore ausgegeben. Die 30 vordefinierten Kernstimmen sind mehrsprachige Stimmen für allgemeine Zwecke, während die Stimmen der erweiterten Stimmenbibliothek und die benutzerdefinierten Stimmen an eine primäre Sprache oder einen regionalen Akzent gebunden sind. Das bedeutet, dass sie zwar andere Sprachen sprechen können, aber in ihrer primären Sprache am authentischsten klingen.

Vordefinierte Standardstimmen

Die Gemini-TTS-Modelle unterstützen 30 vordefinierte Kernstimmen (z. B. Kore, Puck, Zephyr, Charon und Fenrir), die jeweils unterschiedliche Stimmmerkmale haben. Übergeben Sie den Namen der Stimme in SpeechConfig (wie in den Beispielen für einzelne Sprecher und mehrere Sprecher weiter oben auf dieser Seite gezeigt).

Voreingestellte Stimmen aus der erweiterten Stimmenbibliothek

Über die 30 vordefinierten Stimmen hinaus bietet die erweiterte Stimmenbibliothek mehr als 2.000 ausgewählte voreingestellte Stimmen in verschiedenen Sprachen, regionalen Akzenten, Altersgruppen, Charakter-Personas und Anwendungsfällen (z. B. Hörbücher, Kundensupport-Agents und Nachrichtensprecher).

So verwenden Sie eine Stimme aus der erweiterten Stimmenbibliothek in Ihrer App:

  1. Sie haben folgende Möglichkeiten, Stimmen zu suchen und sich eine Vorschau anzuhören:

  2. Übergeben Sie den String id der Stimme aus der Bibliothek als Stimmennamen in SpeechConfig (ähnlich wie im Beispiel für einen einzelnen Sprecher weiter oben auf dieser Seite).

Custom Voices: Voice Design und Voice Replication

Die Gemini 3.x TTS-Modelle unterstützen auch benutzerdefinierte Stimmen mit einer der folgenden Optionen:

  • Voice Design (Vorabversion): Generieren Sie eine einzigartige benutzerdefinierte Stimme aus einer Beschreibung in natürlicher Sprache, die das Alter, die Klangfarbe, den Akzent und die Persönlichkeit eines Sprechers enthält (ohne dass Referenzaudio erforderlich ist). Gibt eine gespeicherte Voice-ID (voice_...) zurück.

  • Stimmenklonen (Vorabversion): Klonen Sie die Stimme, den Tonfall und die Sprechgeschwindigkeit eines Sprechers anhand einer Referenzaufnahme und einer Aufnahme, in der der Sprecher seine Zustimmung gibt. Gibt entweder eine im Projekt gespeicherte Stimmen-ID (voice_...) oder einen zustandslosen, von der Anwendung verwalteten Schlüssel für die Stimmen-Replikation (voicekey_...) zurück.

Benutzerdefinierte Stimme in Ihrer Firebase AI Logic-Anwendung verwenden

Das Erstellen und Verwalten benutzerdefinierter Stimmen ist ein administrativer oder serverseitiger Vorgang. Daher stellen die Firebase AI Logic-Client-SDKs die Endpunkte für die Stimmenverwaltung (CreateVoice, ListVoices, DeleteVoice) nicht direkt bereit.

Wenn Sie eine benutzerdefinierte Stimme verwenden möchten, müssen Sie stattdessen Folgendes tun:

  1. Erstellen Sie die benutzerdefinierte Stimme einmal mit einer der folgenden Optionen:

    • Verwenden Sie Google AI Studio oder Agent  Studio, um Ihre voice_<id>- oder voicekey_<id>-ID abzurufen.

    • Verwenden Sie die Voices API, um Ihre voice_<id>- oder voicekey_<id>-ID abzurufen. Weitere Informationen finden Sie in der Dokumentation des ausgewählten Gemini API-Anbieters:

  2. Übergeben Sie den String voice_<id> oder voicekey_<id> als Sprachnamen in SpeechConfig (ähnlich wie im Beispiel für einen einzelnen Sprecher weiter oben auf dieser Seite).

Beachten Sie bei der Verwendung benutzerdefinierter Stimmen die folgenden Anforderungen:

  • Standort (Agent Platform Gemini API (formerly Vertex AI)): Benutzerdefinierte Stimmen (voice_... und voicekey_...) werden nur am Standort global unterstützt. Dies ist der Standardstandort, wenn Firebase AI Logic verwendet wird.

  • Anfragen mit einem einzelnen Sprecher: MultiSpeakerVoiceConfig unterstützt nur die vordefinierten Core-Stimmen. Wenn Sie benutzerdefinierte oder replizierte Stimmen in einem Dialog mit mehreren Charakteren verwenden möchten, synthetisieren Sie die Redebeiträge der einzelnen Charaktere in einer separaten Anfrage für einen einzelnen Sprecher.

  • Aufbewahrung und Ablauf: Gespeicherte benutzerdefinierte Stimmen (voice_...) laufen ab, wenn sie 1 Jahr lang nicht verwendet werden. Jede Syntheseanfrage setzt den 1-jährigen Aufbewahrungstimer zurück. Zustandslose Schlüssel für die Stimmenreplikation (voicekey_...) laufen 7 Tage nach der Erstellung ab.

Unterstützte Sprachen

Die Gemini 3.x TTS-Modelle erkennen die Sprache automatisch aus Ihrem Eingabetext, auch wenn ein Prompt die Sprache in einem Dialog mit mehreren Sprechern wechselt.

  • Gemini 3.8 Flash TTS (gemini-3.8-flash-tts): Unterstützt 132 Sprachen.
  • Gemini 3.8 Flash‑Lite TTS (gemini-3.8-flash-lite-tts): Unterstützt 103 Sprachen.

(Optional) Sprachcode explizit festlegen

Wenn Sie die Sprachsynthese explizit auf eine bestimmte Sprache beschränken möchten, können Sie in Ihrer SpeechConfig einen BCP-47-languageCode übergeben:



Audioausgabeformate

Das standardmäßige Audioformat, das in InlineDataPart zurückgegeben wird, hängt davon ab, ob Sie eine unäre oder eine Streaminganfrage stellen:

Anfragemethode Standardmäßig zurückgegebener MIME-Typ Details zum Audioformat
Unär
(generateContent)
audio/wav Vollständige WAV-Datei (lineare 16-Bit-PCM, 24 kHz, Mono, Little Endian) mit einem standardmäßigen 44-Byte-RIFF-Header.

Kann direkt von Standard-Audioplayern der Plattform abgespielt werden (z. B. AVAudioPlayer auf Apple-Plattformen, Web Audio decodeAudioData oder dateibasierte Player).

Streaming
(generateContentStream)
audio/l16 Headerlose, rohe, 16-Bit-signierte Little-Endian-PCM-Blöcke mit 24 kHz, Mono.

Entwickelt für die Warteschlange und Verkettung von Puffern mit niedriger Latenz ohne Dateiheader pro Block.



Beschränkungen und Anforderungen

Beachten Sie die folgenden Einschränkungen und Anforderungen, wenn Sie die Gemini 3.x TTS-Modelle verwenden:

  • Nur Texteingabe, nur Audioausgabe: Die TTS-Modelle akzeptieren nur Texteingaben (TextPart) und erfordern, dass responseModalities auf AUDIO gesetzt ist.

  • Nur wörtliche Synthese: Die Modelle geben das bereitgestellte Transkript wörtlich wieder und generieren keine konversationellen Textantworten.

  • Tokenlimits: Die maximale Eingabe beträgt 8.192 Tokens und die maximale Ausgabe 16.384 Tokens pro Anfrage.

  • Limit für mehrere Sprecher: MultiSpeakerVoiceConfig erfordert 2 Sprecher und unterstützt nur vordefinierte Core-Stimmen. Jeder TextPart in einer Anfrage mit mehreren Sprechern muss eine SpeechMetadata.speaker enthalten, die mit einem der konfigurierten Sprecher übereinstimmt.

  • Nicht unterstützte Parameter und Methoden:

    • Die Firebase AI Logic-SDKs unterstützen noch nicht das Festlegen von responseFormat in GenerationConfig, um das Standard-Audioausgabeformat zu überschreiben.
    • Das Festlegen von systemInstruction, temperature, topP, topK, candidateCount, presencePenalty oder frequencyPenalty wird nicht unterstützt und führt dazu, dass Anfragen mit dem Fehler 400 INVALID_ARGUMENT fehlschlagen.
    • Der Aufruf von countTokens wird für die TTS-Modelle nicht unterstützt. Die Tokenanzahl wird in usageMetadata in der Antwort zurückgegeben.
  • Standort (Agent Platform Gemini API (formerly Vertex AI)): Benutzerdefinierte Stimmen (voice_... und voicekey_...) erfordern den Standort global (dies ist der Standardstandort bei Verwendung von Firebase AI Logic).



Von gemini-3.1-flash-tts-preview migrieren

Sowohl gemini-3.8-flash-tts als auch gemini-3.8-flash-lite-tts verwenden dieselbe Anfragestruktur. Sehen Sie sich die Modellvergleichstabelle an, um den besten Ersatz für Ihre Arbeitslast auszuwählen, und aktualisieren Sie Ihren Code so:

Gebiet gemini-3.1-flash-tts-preview (alt) gemini-3.8-flash-tts und
gemini-3.8-flash-lite-tts
Stil und Richtung der Präsentation In den Prompt-Text eingebettet. Beispiel:
"Say cheerfully: ...",
[Audio Profile],
[Director's Notes]
Wird in SpeechMetadata(style: "...") für jede TextPart übergeben

Der TextPart-Text muss genau dem gesprochenen Transkript entsprechen.

Dialog mit mehreren Sprechern Einzelner Textstring mit Inline-"Speaker: ..."-Präfixen Ein TextPart pro Dialogrunde, mit SpeechMetadata(speaker: "...", style: "...") für jeden TextPart
Inline-Tags für die Stimme Eckige Klammern. Beispiel:
[sigh] oder [laughs]
Spitze Klammern. Beispiel:
<sigh> oder <laugh> oder <short pause>

Schreiben Sie gesprochene Unflüssigkeiten wie "uhm" direkt in den Text.

Unäres Standard-Audioformat (generateContent) Headerlose 16-Bit-PCM-Rohdaten (audio/pcm, 24 kHz, Mono) Vollständige WAV-Datei (audio/wav, 16-Bit-PCM, 24 kHz, Mono, mit einem 44-Byte-RIFF-Header)

Streaming (generateContentStream) bleibt headerloses 16-Bit-PCM-Rohformat (audio/l16).

Systemanweisungen, Temperatur, Top-P, Top-K Ignoriert Abgelehnt mit einem 400 INVALID_ARGUMENT-Fehler. Entfernen Sie diese Parameter aus Ihrer Modellkonfiguration.

Checkliste für die Migration

  • Führen Sie ein Upgrade auf die aktuelle Version des Firebase AI Logic SDK durch und aktualisieren Sie den Modellnamen auf gemini-3.8-flash-tts oder gemini-3.8-flash-lite-tts.

  • Stilanweisungen in SpeechMetadata.style verschieben: Entfernen Sie die Präfixe "Say cheerfully:", [Audio Profile], [Scene] und [Director's Notes] aus Ihren Prompt-Strings, damit das Modell sie nicht vorliest. Übergeben Sie stattdessen eine prägnante Stilbeschreibung in SpeechMetadata.style.

  • Skripts mit mehreren Sprechern in separate TextPart-Turns aufteilen: Ersetzen Sie "Joe: ... \n Jane: ..."-Textblöcke durch ein Array oder eine Liste von TextPart-Objekten, wobei für jeden Turn SpeechMetadata.speaker festgelegt wird.

  • [...]-Tags in <...>-Tags umwandeln: Ersetzen Sie Audio-Tags in eckigen Klammern (z. B. [whispers], [sighs], [laughs]) durch Stimm-Tags in spitzen Klammern (z. B. <whispers>, <sigh>, <laugh>, <short pause>).

  • Unäre Audiowiedergabe aktualisieren: Da generateContent jetzt eine vollständige WAV-Datei (mit einem 44-Byte-RIFF-Header) anstelle von headerlosem Roh-PCM zurückgibt, entfernen Sie alle Codezeilen, die unären Antworten manuell einen WAV-Header voranstellen. Alternativ können Sie den 44-Byte-Header überspringen, wenn Sie Roh-PCM-Samples in eine Low-Level-Zwischenspeicher-API wie AudioTrack von Android oder AudioClip von Unity einspeisen.

  • Nicht unterstützte Konfigurationsparameter entfernen: Entfernen Sie temperature, topP, topK, candidateCount, presencePenalty, frequencyPenalty und systemInstruction aus Ihrer TTS-GenerativeModel-Konfiguration.



Was kannst du sonst noch alles für mich tun?

Andere Funktionen ausprobieren

Informationen zum Steuern der Inhaltserstellung

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

Informationen zu den Modellen, die für verschiedene Anwendungsfälle verfügbar sind, sowie zu ihren Kontingenten und Preisen.


Feedback zu Ihren Erfahrungen mit Firebase AI Logic geben