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-ttsgemini-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:
Legen Sie in Ihrer
GenerationConfigresponseModalitiesaufAUDIOfest und konfigurieren Sie eineSpeechConfigmit Folgendem:(Erforderlich) Ein Name oder eine ID für die Stimme. Dies kann eine vordefinierte Stimme wie
Kore, eine Sprach-ID aus der erweiterten Sprachbibliothek oder eine benutzerdefinierte Stimme mit der IDvoice_.../voicekey_...sein.(Optional) Ein BCP-47-Sprachcode. Wenn Sie sie weglassen, erkennt das Modell die Sprache automatisch.
Erstellen Sie ein
TextPartmit folgendem Inhalt:(Erforderlich) Das wörtliche Transkript, das gesprochen werden soll.
(Optional) Ein
SpeechMetadatamit einerstyle-Beschreibung (z. B."cheerful and friendly").
Rufen Sie
generateContentan. 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 einenPublisher-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:
Erstellen Sie eine
MultiSpeakerVoiceConfig, die zwei Sprechernamen (z. B."Joe"und"Jane") ihrenSpeakerVoiceConfig-Stimmen zuordnet.Legen Sie in
GenerationConfigfürresponseModalitiesden WertAUDIOfest und übergeben SieMultiSpeakerVoiceConfig(und optionallanguageCode) anSpeechConfig.Geben Sie ein Array oder eine Liste von
TextPart-Objekten an, genauer gesagt einTextPartpro Dialogrunde. Legen Sie für jedenTextPartFolgendes fürSpeechMetadatafest:- (Erforderlich) Ein
speaker, der mit einem der in IhrerMultiSpeakerVoiceConfigdefinierten Sprechernamen übereinstimmt. - (Optional) Eine
style-Beschreibung (z. B."cheerful and friendly").
- (Erforderlich) Ein
Rufen Sie
generateContentan. 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 einenPublisher-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 einenPublisher-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
styleinSpeechMetadatafest, 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 separateTextPart-Turns auf, jeweils mit einem eigenenstyle.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."
- Runde 1 (
Ü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!"
- Runde 1 (
Best Practices für Konsistenz
Testen Sie zuerst ohne
styleund fügen Sie dann prägnantestyle-Anpassungen hinzu: Die meisten Anfragen klingen mit einem leerenstyle-Feld natürlich. Fügen Sie nur dann eine kurzestyle-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
stylezu überschreiben: Verwenden SieSpeechMetadata.stylenicht, 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:
Sie haben folgende Möglichkeiten, Stimmen zu suchen und sich eine Vorschau anzuhören:
Verwenden Sie Google AI Studio oder Agent Studio, um die Stimme
idabzurufen.Fragen Sie die Voices API-Methode
list(ListVoicesmittype=prebuiltund einer optionalensearch-Abfrage) ab, um die Stimmeidabzurufen. Weitere Informationen finden Sie in der Dokumentation zu Gemini Developer API oder in der Dokumentation zu Agent Platform Gemini API (formerly Vertex AI).
Übergeben Sie den String
idder Stimme aus der Bibliothek als Stimmennamen inSpeechConfig(ä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:
Erstellen Sie die benutzerdefinierte Stimme einmal mit einer der folgenden Optionen:
Verwenden Sie Google AI Studio oder Agent Studio, um Ihre
voice_<id>- odervoicekey_<id>-ID abzurufen.Verwenden Sie die Voices API, um Ihre
voice_<id>- odervoicekey_<id>-ID abzurufen. Weitere Informationen finden Sie in der Dokumentation des ausgewählten Gemini API-Anbieters:Gemini Developer API: Sprachgenerierung
Agent Platform Gemini API (formerly Vertex AI): Stimmendesign und Stimmenklonen
Übergeben Sie den String
voice_<id>odervoicekey_<id>als Sprachnamen inSpeechConfig(ä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_...undvoicekey_...) werden nur am Standortglobalunterstützt. Dies ist der Standardstandort, wenn Firebase AI Logic verwendet wird.Anfragen mit einem einzelnen Sprecher:
MultiSpeakerVoiceConfigunterstü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. |
|
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, dassresponseModalitiesaufAUDIOgesetzt 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:
MultiSpeakerVoiceConfigerfordert 2 Sprecher und unterstützt nur vordefinierte Core-Stimmen. JederTextPartin einer Anfrage mit mehreren Sprechern muss eineSpeechMetadata.speakerenthalten, 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
responseFormatinGenerationConfig, um das Standard-Audioausgabeformat zu überschreiben. - Das Festlegen von
systemInstruction,temperature,topP,topK,candidateCount,presencePenaltyoderfrequencyPenaltywird nicht unterstützt und führt dazu, dass Anfragen mit dem Fehler400 INVALID_ARGUMENTfehlschlagen. - Der Aufruf von
countTokenswird für die TTS-Modelle nicht unterstützt. Die Tokenanzahl wird inusageMetadatain der Antwort zurückgegeben.
- Die Firebase AI Logic-SDKs unterstützen noch nicht das Festlegen von
Standort (Agent Platform Gemini API (formerly Vertex AI)): Benutzerdefinierte Stimmen (
voice_...undvoicekey_...) erfordern den Standortglobal(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 undgemini-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 |
| 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 |
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 ( |
| 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-ttsodergemini-3.8-flash-lite-tts.Stilanweisungen in
SpeechMetadata.styleverschieben: 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 inSpeechMetadata.style.Skripts mit mehreren Sprechern in separate
TextPart-Turns aufteilen: Ersetzen Sie"Joe: ... \n Jane: ..."-Textblöcke durch ein Array oder eine Liste vonTextPart-Objekten, wobei für jeden TurnSpeechMetadata.speakerfestgelegt 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
generateContentjetzt 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 wieAudioTrackvon Android oderAudioClipvon Unity einspeisen.Nicht unterstützte Konfigurationsparameter entfernen: Entfernen Sie
temperature,topP,topK,candidateCount,presencePenalty,frequencyPenaltyundsystemInstructionaus Ihrer TTS-GenerativeModel-Konfiguration.
Was kannst du sonst noch alles für mich tun?
-
Beginnen Sie mit der Vorbereitung auf die Produktion (siehe Produktionscheckliste):
- Erzwingen Sie Firebase App Check so früh wie möglich, um die Gemini API vor Missbrauch durch nicht autorisierte Clients zu schützen.
- Verwenden Sie Firebase Remote Config oder Server-Prompt-Vorlagen, um bei Bedarf Änderungen an den Konfigurationen für Ihre KI-Funktion (z. B. Modellname) vorzunehmen, ohne eine neue Version Ihrer App zu veröffentlichen.
Andere Funktionen ausprobieren
- Multi-Turn-Unterhaltungen (Chat) erstellen
- Text aus reinen Text-Prompts generieren.
- Strukturierte Ausgabe (z. B. JSON) aus Text- und multimodalen Prompts generieren.
- Bilder aus Text- und multimodalen Prompts generieren und bearbeiten
- Streamen Sie Eingaben und Ausgaben (einschließlich Audio) mit dem Gemini Live API.
-
Verwenden Sie Tools (wie Funktionsaufrufe und Fundierung mit
Google Search oderGoogle Maps ), um ein Gemini-Modell mit anderen Teilen Ihrer Anwendung sowie mit externen Systemen und Informationen zu verbinden.
Informationen zum Steuern der Inhaltserstellung
- Prompt-Design verstehen, einschließlich Best Practices, Strategien und Beispiel-Prompts.
- Modellparameter konfigurieren, z. B. maximale Ausgabetokens, die Wahrscheinlichkeit wiederholter Ausgabetokens usw.
- Verwenden Sie Sicherheitseinstellungen, um die Wahrscheinlichkeit zu steuern, dass Sie Antworten erhalten, die als schädlich angesehen werden könnten.
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