Metinden doğal ve ifadeli konuşma (ses) sentezlemek için Gemini TTS modelini (gemini-3.8-flash-tts veya gemini-3.8-flash-lite-tts) kullanabilirsiniz. Firebase AI Logic kullandığınızda bu isteği doğrudan mobil veya web uygulamanızdan (ör. Apple (Swift), Android (Kotlin/Java), Web (JavaScript), Flutter (Dart) veya Unity uygulamanız) gönderebilirsiniz.
Metin okuma (TTS) oluşturma işlemi kontrol edilebilir. Yani konuşmaya dönüştürülecek metni tam olarak siz sağlarsınız. Bu sırada, yapılandırılmış meta veriler ve satır içi ses etiketleri kullanarak duygu, tempo, konuşmacı sesleri ve gülme veya iç çekme gibi konuşma dışı sesler gibi sunum özelliklerini yönlendirirsiniz. TTS'yi metne dönüştürmenin (sesle yazma) tam tersi olarak düşünebilirsiniz.
Bu özellik sayesinde aşağıdaki gibi özellikler oluşturabilirsiniz:
- Etkileşimli hikaye anlatımı ve sesli kitaplar: Karakterlerin ses değiştirdiği, birbirlerine tepki verdiği ve duygusal anlatımlarını uyarladığı (ör. gerilim anında fısıldama veya şakaya gülme) uzun hikayeler ya da rol yapma oyunları anlatın.
- Düşük gecikmeli sesli temsilciler ve asistanlar: LLM'den metin gelir gelmez sentezlenmiş konuşmayı yayınlayarak konuşma sıraları boyunca tutarlı bir ses karakteri sağlar.
- Çok dilli içerik okuyucular ve dil eğitmenleri: Makaleleri, tarifleri veya çalışma materyallerini 130'dan fazla dilde ve bölgesel aksanda sesli okuyun ya da tek bir sohbette diller arasında sorunsuz geçiş yapın.
Bu kılavuzda, tek ve çok konuşmacılı konuşma oluşturma, sesli yanıtları yayınlama, SpeechMetadata ve satır içi etiketlerle sesli sunumu yönlendirme ve önceden oluşturulmuş, kitaplık veya özel sesler arasından seçim yapma işlemleri açıklanmaktadır.
Tek konuşmacılı koda gidin Çok konuşmacılı koda gidin Akış koduna gidin
Live API ile TTS karşılaştırması
Hem metin okuma (TTS) modelleri hem de Live API modelleri, farklı yanıt sesleri ve diller için yapılandırılabilen, düşük gecikmeli, konuşma üreten modellerdir. Ancak kullanım alanları birbirinden çok farklıdır.
Metin okuma (TTS) oluşturma, tek yönlü bir istek-yanıt etkileşimidir (metin girişi, ses çıkışı). Bu model, sağlanan metnin tam olarak okunmasını gerektiren ve stil ile ses üzerinde ayrıntılı kontrol imkanı sunan senaryolar (ör. podcast anlatımı, sesli kitaplar veya makalelerin sesli okunması) için özel olarak tasarlanmıştır.
Live API nesli, anlık sesli sohbetler (ses girişi, ses çıkışı) için çift yönlü akışı destekler. Modelin döndürülecek uygun konuşmaya karar verdiği dinamik sohbet bağlamlarında başarılıdır. En yeni Live API modellerinin video ve resim girişini de desteklediğini unutmayın.
Başlamadan önce
|
Bu sayfada sağlayıcıya özel içerikleri ve kodları görüntülemek için Gemini API sağlayıcınızı tıklayın. |
Henüz yapmadıysanız başlangıç kılavuzunu tamamlayın. Bu kılavuzda Firebase projenizi nasıl oluşturacağınız, uygulamanızı Firebase'e nasıl bağlayacağınız, SDK'yı nasıl ekleyeceğiniz, seçtiğiniz Gemini API sağlayıcı için arka uç hizmetini nasıl başlatacağınız ve bir GenerativeModel örneği nasıl oluşturacağınız açıklanmaktadır.
İstemlerinizi test etmek ve yinelemek için Google AI Studio kullanmanızı öneririz.
Bu özelliği destekleyen modeller
gemini-3.8-flash-ttsgemini-3.8-flash-lite-tts
TTS modellerinin karşılaştırması
Her iki Gemini 3.x TTS modelinde de aynı istek şeması ve istem formatı kullanılır. Ancak her bir modeli kullanabileceğiniz durumlar arasında bazı farklılıklar vardır.
| Özellik veya iş yükü | gemini-3.8-flash-tts |
gemini-3.8-flash-lite-tts |
|---|---|---|
| Birincil güç | Stüdyo kalitesinde ses doğruluğu, oyunculuk nüansı ve geniş lehçe kapsamı | Yüksek gönderim hacmi, düşük gecikme süresi ve maliyet verimliliği |
| En iyi kullanım alanları | Sesli kitaplar, stüdyo anlatımı, karmaşık çoklu konuşmacı diyaloğu, sık ses patlaması etiketleri, zor telaffuz, bölgesel lehçeler | Yüksek hacimli üretim, gerçek zamanlı sesli asistan kaskadları, sesli okuma kullanıcı arayüzü özellikleri, günlük tek konuşmacılı konuşma |
| Desteklenen diller | 132 dil | 103 dil |
Metinden konuşma oluşturma
Metin girişinden tek konuşmacılı bir ses veya iki konuşmacılı bir diyalog olarak konuşma oluşturabilirsiniz. Bu konuşmayı tam bir WAV dosyası (generateContent) veya düşük gecikmeli ham PCM ses akışı (generateContentStream) olarak alabilirsiniz.
Tek bir konuşmacıyla konuşma oluşturma
|
Bu örneği denemeden önce projenizi ve uygulamanızı ayarlamak için bu kılavuzun Başlamadan önce bölümünü tamamlayın. Bu bölümde, seçtiğiniz Gemini API sağlayıcıya ait düğmeyi tıklayarak bu sayfada sağlayıcıya özel içerikleri görebilirsiniz. |
Tek konuşmacılı ses üretmek için:
GenerationConfiguygulamanızdaresponseModalitiesdeğeriniAUDIOolarak ayarlayın ve aşağıdaki değerlerle birSpeechConfigyapılandırın:(Zorunlu) Ses adı veya kimliği. Bu,
Koregibi önceden oluşturulmuş bir ses, Genişletilmiş Ses Kitaplığı ses kimliği veya özel sesvoice_.../voicekey_...kimliği olabilir.(İsteğe bağlı) BCP-47 dil kodu. Atlanırsa model, dili otomatik olarak algılar.
Aşağıdakileri içeren bir
TextPartoluşturun:(Zorunlu) Seslendirilecek tam transkript.
(İsteğe bağlı)
styleaçıklamalı birSpeechMetadata(ör."cheerful and friendly").
generateContentnumarasını arayın. Varsayılan olarak, tekli istekler yanıtın satır içi veri bölümlerinde eksiksiz bir WAV (audio/wav) ses dosyası (16 bit doğrusal PCM, 24 kHz, mono, standart 44 bayt RIFF başlığına sahip) döndürür.
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
Kotlin için bu SDK'daki yöntemler askıya alma işlevleridir ve Coroutine kapsamından çağrılmaları gerekir.
// 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
Java için bu SDK'daki akış yöntemleri, Reactive Streams kitaplığından birPublisher türü döndürür.
// 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);
}
Unity
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);
}
}
}
Birden fazla konuşmacıyla konuşma oluşturma
|
Bu örneği denemeden önce projenizi ve uygulamanızı ayarlamak için bu kılavuzun Başlamadan önce bölümünü tamamlayın. Bu bölümde, seçtiğiniz Gemini API sağlayıcıya ait düğmeyi tıklayarak bu sayfada sağlayıcıya özel içerikleri görebilirsiniz. |
Her konuşmacıya farklı bir ses atayarak ve her diyalog satırını kendi TextPart olarak ileterek tek bir istekte doğal bir iki konuşmacılı sohbet oluşturabilirsiniz:
İki konuşmacı adını (ör.
"Joe"ve"Jane")SpeakerVoiceConfigsesleriyle eşleyen birMultiSpeakerVoiceConfigoluşturun.GenerationConfiguygulamanızdaresponseModalitiesdeğeriniAUDIOolarak ayarlayın veMultiSpeakerVoiceConfig(ve isteğe bağlı olaraklanguageCode) değeriniziSpeechConfigiçine iletin.Diyalog sırası başına bir
TextPartolacak şekilde,TextPartnesnelerinden oluşan bir dizi veya liste sağlayın. HerTextPartiçinSpeechMetadatadeğerini aşağıdakilerle ayarlayın:- (Zorunlu)
MultiSpeakerVoiceConfigdosyanızda tanımlanan konuşmacı adlarından biriyle eşleşen birspeaker. - (İsteğe bağlı)
styleaçıklaması (ör."cheerful and friendly").
- (Zorunlu)
generateContentnumarasını arayın. Model, tüm görüşmeyi sentezler ve eksiksiz bir WAV (audio/wav) ses dosyası döndürür.
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
Kotlin için bu SDK'daki yöntemler askıya alma işlevleridir ve Coroutine kapsamından çağrılmaları gerekir.
// 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
Java için bu SDK'daki akış yöntemleri, Reactive Streams kitaplığından birPublisher türü döndürür.
// 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);
}
Unity
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);
}
}
}
Yanıtı akış şeklinde gösterme
|
Bu örneği denemeden önce projenizi ve uygulamanızı ayarlamak için bu kılavuzun Başlamadan önce bölümünü tamamlayın. Bu bölümde, seçtiğiniz Gemini API sağlayıcıya ait düğmeyi tıklayarak bu sayfada sağlayıcıya özel içerikleri görebilirsiniz. |
Daha düşük ilk sese kadar geçen süre (TTFA) ve gerçek zamanlı oynatma için ses yanıtını, tüm klibin bitmesini beklemek yerine oluşturulduğu anda oynatabilirsiniz. Akış, hem tek hoparlörlü hem de çok hoparlörlü yapılandırmalarla çalışır.
Konuşmayı canlı yayınlamak için generateContent yerine generateContentStream yöntemini çağırın.
Tekli isteklerin (WAV dosyası döndürür) aksine akış istekleri, başlıksız ham 16 bit imzalı little-endian PCM parçaları (audio/l16, 24 kHz, mono) döndürür. Böylece her parçayı doğrudan ses çıkış arabelleğinize ekleyebilirsiniz.
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
Kotlin için bu SDK'daki yöntemler askıya alma işlevleridir ve Coroutine kapsamından çağrılmaları gerekir.
// 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
Java için bu SDK'daki akış yöntemleri, Reactive Streams kitaplığından birPublisher türü döndürür.
// 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);
}
}
Unity
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);
}
}
Meta veriler ve satır içi etiketlerle konuşma çıkışını kontrol etme
Gemini 3.x TTS modelleri, her TextPart içindeki text öğesini kesinlikle sesli olarak okunacak tam transkript olarak değerlendirir. Metin dizesinin içine anlatım talimatları (ör. "Say cheerfully:") yazmayın. Aksi takdirde model, bu kelimeleri sesli okuyabilir.
Aşağıdaki teknikleri kullanarak ses performansını yönlendirebilirsiniz:
Sıra düzeyinde style ve satır içi ses etiketleri
Performans talimatlarınızı kapsama göre SpeechMetadata ve satır içi açılı parantez etiketleri (<...>) arasında bölün.
| Kapsam | Nereye yerleştirilir? | Kontrol ettiği öğeler | Örnekler |
|---|---|---|---|
|
Sıra düzeyinde (sıra boyunca sürdürülür) |
SpeechMetadata.style
|
Duygu, karakter, ton, vurgu, perde ve genel konuşma hızı |
"cheerful and friendly","whispered, nervous","speaking rapidly","out of breath","sarcastic"
|
|
Belirli bir an (cümledeki belirli bir ana yerelleştirilmiş) |
<...> kullanarak TextPart metninde satır içi
|
Konuşma dışı insan sesleri, nefes alma, duraklama veya anlık konuşma hızı değişiklikleri |
"Wait... <short pause> did you hear that? <gasp> Someone's at the door."
|
Hız, duraklamalar, ses perdesi ve vurgu
Noktalama işaretleri ve üç nokta: Doğal ifadeler ve duraksamalar oluşturmak için transkriptte virgül, tire (
--) ve üç nokta (...) kullanın.Açık duraklatma etiketleri: Konuşmacının duraklatması gereken noktaya
<short pause>veya<long pause>satır içi etiketini ekleyin:Hold on, let me think... <short pause> Alright, I've got it.Konuşma hızı ve ses perdesi: Sıranın genel hızını, ses perdesini veya tonlamasını kontrol etmek için
SpeechMetadataiçindestyledeğerini ayarlayın (ör."speaking rapidly and excitedly","speaking slowly"veya"monotone and flat"). Monologun ortasında duygu veya hız değişirse senaryoyu her biri kendistyledeğerine sahip ayrıTextPartsıralarına bölün.Kelime vurgusu: Transkriptteki belirli kelimeleri vurgulamak için büyük harfle yazın:
It was a VERY long day <sigh> ... nobody listens anymore.
Ses patlamaları ve konuşma dışı sesler
Konuşma dışı insan seslerini, sesin çıkması gereken tam kelime sınırında açılı parantez (<...>) kullanarak satır içine ekleyin. Sözlü olmayan ses efektleri yerine
insan seslerini kullanın. Kullanılması önerilen etiketler şunlardır:
<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> |
Onaylama ifadeleri ve çakışan konuşma
Birden fazla konuşmacının yer aldığı diyaloglarda, dinleyicinin kısa tepkilerini etkin konuşmacının transkriptinde dikey çizgi karakterleri (|reaction|) içine alabilirsiniz. Konuşmayan kişi, ayrı bir sıra beklemeden doğal bir şekilde araya girer:
Kısa dinleyici geri bildirimleri:
- 1. sıra (
speaker: "Joe"):"So the launch is Thursday |oh hmm| Are we actually ready?" - 2. sıra (
speaker: "Jane"):"Ready enough |oh really?| The last blocker cleared this morning."
- 1. sıra (
Üst üste binen konuşma: Eş zamanlı konuşmayı simüle etmek için birden fazla dikey çizgi segmenti kullanabilirsiniz (
gemini-3.8-flash-ttsile en iyi sonucu verir). Örneğin:- 1. sıra (
speaker: "Joe"):"Let's surprise him on three |ok| ready?" - 2. sıra (
speaker: "Jane"):"one. two. three. |happy| happy |birthday| birthday!"
- 1. sıra (
Tutarlılıkla ilgili en iyi uygulamalar
Önce
styleolmadan test edin, ardından kısastyledüzenlemeleri ekleyin: Çoğu istek, boş birstylealanıyla doğal bir şekilde ifade edilir. Yalnızca bir sıranın belirli bir yayınlama düzenlemesi gerektirdiği durumlarda kısa birstyleifadesi ("casual, friendly"veya"reflective and awe-inspired"gibi) ekleyin ve tutarlı bir temel istediğinizde sıralar arasında aynı kısa dizeyi yeniden kullanın.Doğal konuşma transkriptleri yazın: Konuşma dilindeki kısaltmaları ve doğal akıcılık bozukluklarını (ör.
"Oh, uh, yeah I think... hm, that's interesting") doğrudan transkript metnine ekleyin.Eski
[Audio Profile]bloklarından ve meta talimatlardan kaçının: Uzun karakter paragrafları,[Director's Notes]blokları veya"maintain identical timbre"gibi meta talimatlar ses kaymasını artırır. Bunun yerine, Genişletilmiş Ses Kitaplığı'ndan uygun bir ses seçin veya Ses Tasarımı ile kalıcı bir karakter sesi oluşturun.styleiçinde değişmez ses özelliklerini geçersiz kılmaya çalışmayın: Bir sesin yaşını, cinsiyetini veya kalıcı aksanını değiştirmek içinSpeechMetadata.stylekullanmaktan kaçının. Bunun yerine, bu özelliklere sahip bir ses seçin veya tasarlayın.
Desteklenen sesler
Gemini 3.x TTS modelleri, ses belirtmenin üç yolunu destekler:
Tüm sesler çok dillidir. Yani aynı sesi kullanarak desteklenen dillerden herhangi birinde konuşma üretebilir ve tutarlı bir konuşmacı kimliği sağlayabilirsiniz. Örneğin, sesi önceden oluşturulmuş Kore sesine ayarlayıp İspanyolca, Hintçe ve Vietnamca istemler gönderirseniz yanıtların tümünde bu dillerin her biri için Kore sesi kullanılır. 30 temel önceden oluşturulmuş ses genel amaçlı çok dilli seslerken Genişletilmiş Ses Kitaplığı sesleri ve özel sesler birincil yerel ayara veya bölgesel aksana bağlıdır. Bu, diğer dilleri de konuşabilecekleri ancak en doğal seslerinin birincil yerel ayarlarında duyulacağı anlamına gelir.
Önceden oluşturulmuş temel sesler
Gemini TTS modelleri, her biri farklı ses özelliklerine sahip 30 temel önceden oluşturulmuş sesi (ör. Kore, Puck, Zephyr, Charon ve Fenrir) destekler. Ses adını SpeechConfig içinde iletin (bu sayfanın önceki kısımlarında yer alan tek hoparlörlü ve çok hoparlörlü örneklerde gösterildiği gibi).
Genişletilmiş Ses Kitaplığı'ndaki hazır ayarlı sesler
Genişletilmiş Ses Kitaplığı, önceden oluşturulmuş 30 sese ek olarak farklı dilleri, bölgesel aksanları, yaş gruplarını, karakter kişiliklerini ve kullanım alanlarını (ör. sesli kitaplar, müşteri destek temsilcileri ve haber spikerleri) kapsayan 2.000'den fazla özel olarak seçilmiş hazır ses sunar.
Genişletilmiş Ses Kitaplığı'ndaki sesleri uygulamanızda kullanmak için:
Aşağıdaki seçeneklerden birini kullanarak seslere göz atın ve önizleyin:
Sesli
idalmak için Google AI Studio veya Agent Studio kullanın.idsesini almak için Voices APIlistyöntemini (type=prebuiltve isteğe bağlı birsearchsorgusuylaListVoices) sorgulayın. Gemini Developer API belgelerinde veya Agent Platform Gemini API (formerly Vertex AI) belgelerinde daha fazla bilgi edinebilirsiniz.
Kitaplık sesinin
iddizesiniSpeechConfigiçinde ses adı olarak iletin (bu sayfanın önceki kısımlarında yer alan tek konuşmacı örneğine benzer şekilde).
Özel sesler: Ses tasarımı ve ses kopyalama
Gemini 3.x TTS modelleri, aşağıdaki seçeneklerden birini kullanarak özel sesleri de destekler:
Ses tasarımı (Önizleme): Konuşmacının yaşı, ses tınısı, aksanı ve kişiliğinin doğal dildeki açıklamasından benzersiz bir özel ses oluşturun (referans ses gerekmez). Kayıtlı bir ses kimliğini (
voice_...) döndürür.Ses kopyalama (Önizleme): Referans kayıt ve sözlü izin kaydı kullanarak konuşmacının sesini, tonunu ve ritmini kopyalayın. Projede depolanan bir ses kimliği (
voice_...) veya uygulama tarafından yönetilen, durum bilgisi olmayan bir ses kopyalama anahtarı (voicekey_...) döndürür.
Firebase AI Logic uygulamanızda özel ses kullanma
Özel sesler oluşturma ve yönetme, yönetimsel veya sunucu tarafı bir işlemdir. Bu nedenle, Firebase AI Logic istemci SDK'ları ses yönetimi uç noktalarını (CreateVoice, ListVoices, DeleteVoice) doğrudan göstermez.
Bunun yerine, özel bir ses kullanmak için aşağıdakileri yapmanız gerekir:
Aşağıdaki seçeneklerden birini kullanarak özel sesi bir kez oluşturun:
voice_<id>veyavoicekey_<id>tanımlayıcınızı almak için Google AI Studio ya da Agent Studio kullanın.voice_<id>veyavoicekey_<id>tanımlayıcınızı almak için Voices API'yi kullanın. Seçtiğiniz Gemini API sağlayıcının belgelerinden daha fazla bilgi edinebilirsiniz:Gemini Developer API: Konuşma oluşturma
Agent Platform Gemini API (formerly Vertex AI): Ses tasarımı ve Ses kopyalama
SpeechConfigiçinde ses adı olarakvoice_<id>veyavoicekey_<id>dizesini iletin (bu sayfanın önceki kısımlarında gösterilen tek konuşmacılı örneğe benzer şekilde).
Özel sesleri kullanırken aşağıdaki şartları göz önünde bulundurun:
Konum (Agent Platform Gemini API (formerly Vertex AI)): Özel sesler (
voice_...vevoicekey_...) yalnızcaglobalkonumunda (Firebase AI Logic kullanılırken varsayılan konumdur) desteklenir.Tek konuşmacılı istekler:
MultiSpeakerVoiceConfigyalnızca temel önceden oluşturulmuş sesleri destekler. Çok karakterli bir diyalogda özel olarak tasarlanmış veya kopyalanmış sesleri kullanmak için her karakterin sırasını ayrı bir tek konuşmacı isteğinde sentezleyin.Saklama ve geçerlilik süresi: Saklanan özel seslerin (
voice_...) geçerlilik süresi 1 yıl boyunca kullanılmadığında sona erer (her sentez isteği, 1 yıllık saklama zamanlayıcısını sıfırlar). Durum bilgisiz ses kopyalama anahtarlarının (voicekey_...) geçerlilik süresi, oluşturulduktan 7 gün sonra sona erer.
Desteklenen diller
Gemini 3.x TTS modelleri, birden fazla konuşmacının yer aldığı bir diyalogda istemlerin dilleri değiştiğinde de giriş metninizdeki dili otomatik olarak algılar.
- Gemini 3.8 Flash TTS (
gemini-3.8-flash-tts): 132 dili destekler. - Gemini 3.8 Flash‑Lite TTS (
gemini-3.8-flash-lite-tts): 103 dili destekler.
(İsteğe bağlı) Açıkça bir dil kodu ayarlama
Konuşma sentezini belirli bir yerel ayarla açıkça kısıtlamak istiyorsanız SpeechConfig içinde bir BCP-47 languageCode iletebilirsiniz:
Ses çıkış biçimleri
InlineDataPart içinde döndürülen varsayılan ses biçimi, tekli mi yoksa akış isteği mi yaptığınıza bağlıdır:
| İstek yöntemi | Varsayılan döndürülen MIME türü | Ses biçimi ayrıntıları |
|---|---|---|
|
Tekli ( generateContent)
|
audio/wav
|
Standart 44 baytlık RIFF başlığına sahip eksiksiz WAV dosyası (16 bit doğrusal PCM, 24 kHz, mono, little-endian).
Standart platform ses çalarlar (ör. Apple platformlarında |
|
Yayınlama ( generateContentStream)
|
audio/l16
|
24 kHz, mono, başlıksız ham 16 bit imzalı little-endian PCM parçaları.
Düşük gecikmeli arabellek sırası ve parça başına dosya başlığı olmadan birleştirme için tasarlanmıştır. |
Sınırlamalar ve şartlar
Gemini 3.x TTS modellerini kullanırken aşağıdaki sınırlamaları ve şartları göz önünde bulundurun:
Yalnızca metin girişi, yalnızca ses çıkışı: TTS modelleri yalnızca metin girişini (
TextPart) kabul eder veresponseModalitiesdeğerininAUDIOolarak ayarlanmasını gerektirir.Yalnızca kelimesi kelimesine sentez: Modeller, sağlanan transkripti kelimesi kelimesine okur ve sohbete dayalı metin yanıtları oluşturmaz.
Jeton sınırları: İstek başına maksimum giriş 8.192 jeton, maksimum çıkış ise 16.384 jetondur.
Birden fazla konuşmacı sınırı:
MultiSpeakerVoiceConfig, 2 konuşmacı gerektirir ve yalnızca temel önceden oluşturulmuş sesleri destekler. Çoklu konuşmacı isteğindeki herTextPart, yapılandırılmış konuşmacılardan biriyle eşleşen birSpeechMetadata.speakeriçermelidir.Desteklenmeyen parametreler ve yöntemler:
- Firebase AI Logic SDK'ları, varsayılan ses çıkış biçimini geçersiz kılmak için
GenerationConfigiçinderesponseFormatayarını henüz desteklememektedir. systemInstruction,temperature,topP,topK,candidateCount,presencePenaltyveyafrequencyPenaltyayarı desteklenmez ve isteklerin400 INVALID_ARGUMENThatasıyla başarısız olmasına neden olur.- TTS modelleri için
countTokensçağrısı desteklenmez (yanıttausageMetadataiçinde parça sayıları döndürülür).
- Firebase AI Logic SDK'ları, varsayılan ses çıkış biçimini geçersiz kılmak için
Konum (Agent Platform Gemini API (formerly Vertex AI)): Özel sesler (
voice_...vevoicekey_...) içinglobalkonumu (Firebase AI Logic kullanılırken varsayılan konumdur) gerekir.
Taşıma kaynağı: gemini-3.1-flash-tts-preview
Hem gemini-3.8-flash-tts hem de gemini-3.8-flash-lite-tts aynı istek yapısını kullanır. İş yükünüz için en uygun modeli seçmek üzere model karşılaştırma tablosunu inceleyin ve kodunuzu aşağıdaki gibi güncelleyin:
| Alan |
gemini-3.1-flash-tts-preview (Eski)
|
gemini-3.8-flash-tts vegemini-3.8-flash-lite-tts
|
|---|---|---|
| Yayınlama stili ve yönü |
İstem metnine yerleştirilir. Örneğin:"Say cheerfully: ...",[Audio Profile],[Director's Notes]
|
Her TextPart için SpeechMetadata(style: "...") içinde iletildi
|
| Çok konuşmacılı diyalog |
Satır içi "Speaker: ..." ön ekleri içeren tek metin dizesi
|
Her bir TextPart üzerinde SpeechMetadata(speaker: "...", style: "...") ile her diyalog sırası için bir TextPart
|
| Satır içi sesli etiketler |
Köşeli parantezler. Örneğin,[sigh] veya [laughs]
|
Açılı ayraçlar. Örneğin,<sigh> veya
<laugh> ya da
<short pause>
|
Varsayılan tekli ses biçimi
(generateContent)
|
Başlıksız ham 16 bit PCM (audio/pcm, 24 kHz, mono)
|
Tam WAV dosyası (audio/wav, 16 bit PCM, 24 kHz, mono, 44 baytlık RIFF başlığıyla)
Akış
( |
| Sistem talimatları, sıcaklık, üst-P, üst-K | Yoksayıldı |
400 INVALID_ARGUMENT hatasıyla reddedildi. Bu parametreleri model yapılandırmanızdan kaldırın.
|
Taşıma kontrol listesi
Firebase AI Logic SDK'sının en yeni sürümüne yükseltin ve model adınızı
gemini-3.8-flash-ttsveyagemini-3.8-flash-lite-ttsolarak güncelleyin.Stil talimatlarını
SpeechMetadata.styleiçine taşıyın: Modelin sesli okumaması için istem dizelerinizden"Say cheerfully:"ön eklerini,[Audio Profile],[Scene]ve[Director's Notes]bloklarını kaldırın. Bunun yerineSpeechMetadata.styleiçinde kısa bir stil açıklaması iletin.Birden fazla konuşmacının olduğu senaryoları ayrı
TextPartsıralara bölün:"Joe: ... \n Jane: ..."metin bloklarını, her sıranınSpeechMetadata.speakerdeğerini ayarladığı birTextPartnesnesi dizisi/listesiyle değiştirin.[...]etiketlerini<...>etiketlerine dönüştürün: Köşeli parantez içindeki ses etiketlerini (ör.[whispers],[sighs],[laughs]) açılı parantez içindeki vokal etiketleriyle (ör.<whispers>,<sigh>,<laugh>,<short pause>) değiştirin.Tekli ses oynatmayı güncelleme:
generateContentartık başlıksız ham PCM yerine tam bir WAV dosyası (44 baytlık RIFF başlığıyla) döndürdüğünden, tekli yanıtlara manuel olarak WAV başlığı ekleyen tüm kodları kaldırın (veya ham PCM örneklerini Android'inAudioTrackveya Unity'ninAudioClipgibi düşük seviyeli bir arabellek API'sine besliyorsanız 44 baytlık başlığı atlayın).Desteklenmeyen yapılandırma parametrelerini kaldırın: TTS
GenerativeModelyapılandırmanızdantemperature,topP,topK,candidateCount,presencePenalty,frequencyPenaltyvesystemInstructionparametrelerini kaldırın.
Başka ne yapabilirsin?
-
Üretime hazırlık yapmaya başlayın (üretim yapılacaklar listesine bakın):
- Firebase App Check politikasını mümkün olan en kısa sürede zorunlu kılın. Böylece Gemini API, yetkisiz istemcilerin kötüye kullanımına karşı korunur.
- Uygulamanızın yeni bir sürümünü yayınlamadan yapay zeka özelliğinizin yapılandırmalarında (model adı gibi) seç-izle değişiklikler yapabilmek için Firebase Remote Config veya sunucu istem şablonlarını kullanın.
Diğer özellikleri deneme
- Çok adımlı görüşmeler (sohbet) oluşturun.
- Yalnızca metin içeren istemlerden metin oluşturma
- Hem metin hem de çok formatlı istemlerden yapılandırılmış çıkış (ör. JSON) oluşturun.
- Hem metin hem de çok formatlı istem yazmadan görüntü oluşturun ve düzenleyin.
- Gemini Live API kullanarak giriş ve çıkış akışı (ses dahil)
-
Gemini modelini uygulamanızın diğer bölümlerine, harici sistemlere ve bilgilere bağlamak için araçları (işlev çağrısı ve
Google Search veyaGoogle Maps ile temellendirme gibi) kullanın.
İçerik üretimini nasıl kontrol edeceğinizi öğrenin.
- En iyi uygulamalar, stratejiler ve örnek istemler de dahil olmak üzere istem tasarımını anlama
- Maksimum çıkış jetonu sayısı, tekrarlanan çıkış jetonlarının olasılığı gibi model parametrelerini yapılandırın.
- Zararlı olarak değerlendirilebilecek yanıtlar alma olasılığını ayarlamak için güvenlik ayarlarını kullanın.
Desteklenen modeller hakkında daha fazla bilgi
Çeşitli kullanım alanları için kullanılabilen modeller, kotaları ve fiyatlandırmaları hakkında bilgi edinin.Firebase AI Logic ile ilgili deneyiminiz hakkında geri bildirimde bulunun