Gemini API'yi kullanarak metin okuma (TTS) oluşturma


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-tts
  • gemini-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:

  1. GenerationConfig uygulamanızda responseModalities değerini AUDIO olarak ayarlayın ve aşağıdaki değerlerle bir SpeechConfig yapılandırın:

  2. Aşağıdakileri içeren bir TextPart oluşturun:

    • (Zorunlu) Seslendirilecek tam transkript.

    • (İsteğe bağlı) style açıklamalı bir SpeechMetadata (ör. "cheerful and friendly").

  3. generateContent numarası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 bir Publisher 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:

  1. İki konuşmacı adını (ör. "Joe" ve "Jane") SpeakerVoiceConfigsesleriyle eşleyen bir MultiSpeakerVoiceConfig oluşturun.

  2. GenerationConfig uygulamanızda responseModalities değerini AUDIO olarak ayarlayın ve MultiSpeakerVoiceConfig (ve isteğe bağlı olarak languageCode) değerinizi SpeechConfig içine iletin.

  3. Diyalog sırası başına bir TextPart olacak şekilde, TextPart nesnelerinden oluşan bir dizi veya liste sağlayın. Her TextPart için SpeechMetadata değerini aşağıdakilerle ayarlayın:

    • (Zorunlu) MultiSpeakerVoiceConfig dosyanızda tanımlanan konuşmacı adlarından biriyle eşleşen bir speaker.
    • (İsteğe bağlı) style açıklaması (ör. "cheerful and friendly").
  4. generateContent numarası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 bir Publisher 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 bir Publisher 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 SpeechMetadata içinde style değ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 kendi style değerine sahip ayrı TextPart sı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."
  • Üst üste binen konuşma: Eş zamanlı konuşmayı simüle etmek için birden fazla dikey çizgi segmenti kullanabilirsiniz (gemini-3.8-flash-tts ile 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!"

Tutarlılıkla ilgili en iyi uygulamalar

  • Önce style olmadan test edin, ardından kısa style düzenlemeleri ekleyin: Çoğu istek, boş bir style alanıyla doğal bir şekilde ifade edilir. Yalnızca bir sıranın belirli bir yayınlama düzenlemesi gerektirdiği durumlarda kısa bir style ifadesi ("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.

  • style iç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çin SpeechMetadata.style kullanmaktan 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:

  1. Aşağıdaki seçeneklerden birini kullanarak seslere göz atın ve önizleyin:

  2. Kitaplık sesinin id dizesini SpeechConfig iç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:

  1. Aşağıdaki seçeneklerden birini kullanarak özel sesi bir kez oluşturun:

    • voice_<id> veya voicekey_<id> tanımlayıcınızı almak için Google AI Studio ya da Agent  Studio kullanın.

    • voice_<id> veya voicekey_<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:

  2. SpeechConfig içinde ses adı olarak voice_<id> veya voicekey_<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_... ve voicekey_...) yalnızca global konumunda (Firebase AI Logic kullanılırken varsayılan konumdur) desteklenir.

  • Tek konuşmacılı istekler: MultiSpeakerVoiceConfig yalnı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 AVAudioPlayer, Web Audio decodeAudioData veya dosya tabanlı oynatıcılar) tarafından doğrudan oynatılabilir.

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 ve responseModalities değerinin AUDIO olarak 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 her TextPart, yapılandırılmış konuşmacılardan biriyle eşleşen bir SpeechMetadata.speaker içermelidir.

  • Desteklenmeyen parametreler ve yöntemler:

    • Firebase AI Logic SDK'ları, varsayılan ses çıkış biçimini geçersiz kılmak için GenerationConfig içinde responseFormat ayarını henüz desteklememektedir.
    • systemInstruction, temperature, topP, topK, candidateCount, presencePenalty veya frequencyPenalty ayarı desteklenmez ve isteklerin 400 INVALID_ARGUMENT hatasıyla başarısız olmasına neden olur.
    • TTS modelleri için countTokens çağrısı desteklenmez (yanıtta usageMetadata içinde parça sayıları döndürülür).
  • Konum (Agent Platform Gemini API (formerly Vertex AI)): Özel sesler (voice_... ve voicekey_...) için global konumu (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 ve
gemini-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

TextPart metnini, konuşulan transkriptle tamamen aynı tutun.

Ç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>

"uhm" gibi konuşma bozukluklarını doğrudan metne yazın.

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ış (generateContentStream), başlıksız ham 16 bit PCM (audio/l16) olarak kalır.

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-tts veya gemini-3.8-flash-lite-tts olarak güncelleyin.

  • Stil talimatlarını SpeechMetadata.style iç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 yerine SpeechMetadata.style içinde kısa bir stil açıklaması iletin.

  • Birden fazla konuşmacının olduğu senaryoları ayrı TextPart sıralara bölün: "Joe: ... \n Jane: ..." metin bloklarını, her sıranın SpeechMetadata.speaker değerini ayarladığı bir TextPart nesnesi 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: generateContent artı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'in AudioTrack veya Unity'nin AudioClip gibi 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 GenerativeModel yapılandırmanızdan temperature, topP, topK, candidateCount, presencePenalty, frequencyPenalty ve systemInstruction parametrelerini kaldırın.



Başka ne yapabilirsin?

Diğer özellikleri deneme

İçerik üretimini nasıl kontrol edeceğinizi öğrenin.

Ayrıca, istemler ve model yapılandırmalarıyla denemeler yapabilir, hatta Google AI Studio kullanarak oluşturulan bir kod snippet'i alabilirsiniz.

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