Pembuatan text-to-speech (TTS) menggunakan Gemini API


Anda dapat menggunakan model TTS Gemini (gemini-3.8-flash-tts atau gemini-3.8-flash-lite-tts) untuk menyintesis ucapan (audio) yang alami dan ekspresif dari teks. Saat menggunakan Firebase AI Logic, Anda dapat membuat permintaan ini langsung dari aplikasi seluler atau aplikasi web (seperti aplikasi Apple (Swift), Android (Kotlin/Java), Web (JavaScript), Flutter (Dart), atau Unity).

Pembuatan text-to-speech (TTS) dapat dikontrol, yang berarti Anda memberikan teks yang tepat untuk disintesis menjadi ucapan, sekaligus memandu penyampaiannya—seperti emosi, tempo, suara pembicara, dan suara non-ucapan seperti tawa atau desahan—menggunakan metadata terstruktur dan tag vokal inline. Anda dapat menganggap TTS sebagai kebalikan dari transkripsi (speech-to-text).

Dengan kemampuan ini, Anda dapat membangun fitur seperti:

  • Penceritaan interaktif dan buku audio: Narasi cerita panjang atau game role-playing tempat karakter berganti suara, bereaksi satu sama lain dengan backchannel yang tumpang-tindih, dan menyesuaikan penyampaian emosional mereka (seperti berbisik dalam ketegangan atau tertawa mendengar lelucon).
  • Asisten dan agen suara berlatensi rendah: Melakukan streaming ucapan yang disintesis segera setelah teks diterima dari LLM, sehingga mempertahankan persona suara yang konsisten di seluruh giliran percakapan.
  • Pembaca konten multibahasa dan tutor bahasa: Membaca artikel, resep, atau materi pelajaran dengan lisan dalam lebih dari 130 bahasa dan aksen regional, atau beralih bahasa dengan lancar dalam satu percakapan.

Panduan ini menunjukkan cara membuat ucapan satu pembicara dan beberapa pembicara, melakukan streaming respons audio, mengarahkan penyampaian vokal dengan SpeechMetadata dan tag inline, serta memilih dari suara bawaan, koleksi, atau kustom.

Lompat ke kode satu pembicara Lompat ke kode multi-pembicara Lompat ke kode streaming

Perbandingan antara TTS dan Live API

Model text-to-speech (TTS) dan model Live API adalah model penghasil ucapan berlatensi rendah yang dapat dikonfigurasi untuk berbagai suara dan bahasa respons. Namun, keduanya melayani kasus penggunaan yang sangat berbeda.

  • Pembuatan text-to-speech (TTS) adalah interaksi permintaan-respons satu arah (input teks, output audio). Model ini disesuaikan untuk skenario yang memerlukan pembacaan yang tepat dari teks yang disediakan dengan kontrol terperinci atas gaya dan suara, seperti narasi podcast, buku audio, atau pembacaan artikel dengan keras.

  • Live API generation mendukung streaming dua arah untuk percakapan suara real-time (input suara, output suara). Model ini unggul dalam konteks percakapan dinamis, di mana model memutuskan ucapan yang sesuai untuk ditampilkan. Perhatikan bahwa model Live API terbaru juga mendukung input video dan gambar.

Sebelum memulai

Klik penyedia Gemini API untuk melihat konten dan kode khusus penyedia di halaman ini.

Jika Anda belum melakukannya, selesaikan panduan memulai, yang menjelaskan cara menyiapkan project Firebase, menghubungkan aplikasi ke Firebase, menambahkan SDK, menginisialisasi layanan backend untuk penyedia Gemini API yang Anda pilih, dan membuat instance GenerativeModel.

Untuk menguji dan melakukan iterasi pada perintah, sebaiknya gunakan Google AI Studio.

Model yang mendukung kemampuan ini

  • gemini-3.8-flash-tts
  • gemini-3.8-flash-lite-tts
Perbandingan model TTS

Kedua model Gemini 3.x TTS memiliki skema permintaan dan format perintah yang sama. Namun, berikut beberapa perbedaan terkait kapan Anda dapat menggunakan setiap model.

Fitur atau workload gemini-3.8-flash-tts gemini-3.8-flash-lite-tts
Kekuatan utama Kualitas suara sekelas studio, nuansa akting, dan cakupan dialek yang luas Throughput tinggi, latensi rendah, dan efisiensi biaya
Kasus penggunaan terbaik Buku audio, narasi studio, dialog multi-pembicara yang kompleks, tag letupan vokal yang sering, pengucapan yang sulit, dialek regional Produksi bervolume tinggi, cascade agen suara real-time, fitur UI baca lisan, ucapan satu pembicara sehari-hari
Bahasa yang didukung 132 bahasa 103 bahasa

Membuat ucapan dari teks

Anda dapat membuat ucapan dari input teks dalam suara satu pembicara atau dialog dua pembicara, baik sebagai file WAV lengkap (generateContent) maupun sebagai streaming audio PCM mentah dengan latensi rendah (generateContentStream).

Membuat ucapan dengan satu pembicara

Sebelum mencoba contoh ini, selesaikan bagian Sebelum memulai dalam panduan ini untuk menyiapkan project dan aplikasi Anda.
Di bagian tersebut, Anda juga akan mengklik tombol untuk penyedia Gemini API yang dipilih sehingga Anda dapat melihat konten khusus penyedia di halaman ini.

Berikut cara membuat audio satu pembicara:

  1. Di GenerationConfig, tetapkan responseModalities ke AUDIO dan konfigurasikan SpeechConfig dengan hal berikut:

  2. Buat TextPart dengan hal berikut:

    • (Wajib) Transkrip verbatim yang akan diucapkan.

    • (Opsional) SpeechMetadata dengan deskripsi style (misalnya, "cheerful and friendly").

  3. Panggil generateContent. Secara default, permintaan unary menampilkan file audio WAV (audio/wav) lengkap (PCM linear 16-bit, 24 kHz, mono, dengan header RIFF 44 byte standar) di bagian data inline respons.

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

Untuk Kotlin, metode dalam SDK ini adalah fungsi penangguhan dan harus dipanggil dari cakupan Coroutine.

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

Untuk Java, metode streaming di SDK ini menampilkan jenis Publisher dari library Reactive Streams.

// 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);
    }
  }
}

Membuat ucapan dengan beberapa pembicara

Sebelum mencoba contoh ini, selesaikan bagian Sebelum memulai dalam panduan ini untuk menyiapkan project dan aplikasi Anda.
Di bagian tersebut, Anda juga akan mengklik tombol untuk penyedia Gemini API yang dipilih sehingga Anda dapat melihat konten khusus penyedia di halaman ini.

Anda dapat membuat percakapan dua pembicara yang alami dalam satu permintaan dengan menetapkan suara yang berbeda untuk setiap pembicara dan meneruskan setiap baris dialog sebagai TextPart-nya sendiri:

  1. Buat MultiSpeakerVoiceConfig yang memetakan dua nama pembicara (misalnya, "Joe" dan "Jane") ke suara SpeakerVoiceConfig mereka.

  2. Di GenerationConfig, tetapkan responseModalities ke AUDIO dan teruskan MultiSpeakerVoiceConfig (dan languageCode opsional) ke SpeechConfig.

  3. Berikan array atau daftar objek TextPart, khususnya satu TextPart per giliran dialog. Di setiap TextPart, tetapkan SpeechMetadata dengan berikut ini:

    • (Wajib) speaker yang cocok dengan salah satu nama pembicara yang ditentukan dalam MultiSpeakerVoiceConfig Anda.
    • (Opsional) Deskripsi style (misalnya, "cheerful and friendly").
  4. Panggil generateContent. Model ini akan menyintesis seluruh percakapan dan menampilkan file audio WAV (audio/wav) yang lengkap.

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

Untuk Kotlin, metode dalam SDK ini adalah fungsi penangguhan dan harus dipanggil dari cakupan Coroutine.

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

Untuk Java, metode streaming di SDK ini menampilkan jenis Publisher dari library Reactive Streams.

// 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);
    }
  }
}

Menampilkan respons secara bertahap

Sebelum mencoba contoh ini, selesaikan bagian Sebelum memulai dalam panduan ini untuk menyiapkan project dan aplikasi Anda.
Di bagian tersebut, Anda juga akan mengklik tombol untuk penyedia Gemini API yang dipilih sehingga Anda dapat melihat konten khusus penyedia di halaman ini.

Untuk waktu ke audio pertama (TTFA) yang lebih rendah dan pemutaran real-time, Anda dapat melakukan streaming respons audio saat dibuat, bukan menunggu seluruh klip selesai. Streaming berfungsi dengan konfigurasi satu speaker dan multi-speaker.

Untuk melakukan streaming ucapan, panggil generateContentStream, bukan generateContent. Tidak seperti permintaan unary (yang menampilkan file WAV), permintaan streaming menampilkan potongan PCM little-endian bertanda tangan 16-bit mentah tanpa header (audio/l16, 24 kHz, mono) sehingga Anda dapat menambahkan setiap potongan langsung ke buffer output audio.

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

Untuk Kotlin, metode dalam SDK ini adalah fungsi penangguhan dan harus dipanggil dari cakupan Coroutine.

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

Untuk Java, metode streaming di SDK ini menampilkan jenis Publisher dari library Reactive Streams.

// 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);
    }
}



Mengontrol output ucapan dengan metadata dan tag inline

Model Gemini 3.x TTS memperlakukan text di dalam setiap TextPart secara ketat sebagai transkrip verbatim untuk diucapkan dengan keras. Jangan menulis petunjuk naratif (seperti "Say cheerfully:") di dalam string teks, atau model dapat membacakan kata-kata tersebut.

Anda dapat mengarahkan performa vokal menggunakan teknik berikut:

style tingkat giliran dan tag vokal inline

Pisahkan petunjuk performa Anda berdasarkan cakupan antara SpeechMetadata dan tag tanda kurung sudut inline (<...>).

Cakupan Tempat penempatan Yang dikontrolnya Contoh
Tingkat giliran
(dipertahankan di seluruh giliran)
SpeechMetadata.style Emosi, persona, nada, infleksi, tinggi nada, dan kecepatan bicara secara keseluruhan "cheerful and friendly",
"whispered, nervous",
"speaking rapidly",
"out of breath",
"sarcastic"
Point-in-time
(dilokalkan ke momen tertentu dalam kalimat)
Inline dalam teks TextPart menggunakan <...> Suara vokal manusia non-ucapan, napas, jeda, atau perubahan penyampaian sesaat "Wait... <short pause> did you hear that? <gasp> Someone's at the door."

Kecepatan, jeda, nada, dan penekanan

  • Tanda baca dan elipsis: Gunakan koma, tanda hubung (--), dan elipsis (...) dalam transkrip untuk membuat frasa dan keraguan yang alami.

  • Tag jeda eksplisit: Sisipkan <short pause> atau <long pause> secara inline pada titik yang tepat saat pembicara harus menjeda:

    Hold on, let me think... <short pause> Alright, I've got it.
    
  • Kecepatan dan nada bicara: Tetapkan style di SpeechMetadata untuk mengontrol kecepatan, nada, atau infleksi keseluruhan untuk giliran (misalnya, "speaking rapidly and excitedly", "speaking slowly", atau "monotone and flat"). Jika emosi atau kecepatan berubah di tengah monolog, bagi skrip menjadi giliran TextPart yang terpisah, masing-masing dengan style-nya sendiri.

  • Penekanan kata: Gunakan huruf kapital pada kata tertentu dalam transkrip untuk menekankannya:

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

Letupan vokal dan suara non-ucapan

Sisipkan vokalisasi manusia non-ucapan secara inline menggunakan tanda kurung sudut (<...>) pada batas kata yang tepat tempat suara seharusnya muncul. Gunakan vokalisasi manusia, bukan efek suara non-vokal. Berikut adalah tag yang direkomendasikan untuk digunakan:

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

Respons singkat dan ucapan yang tumpang tindih

Dalam dialog beberapa pembicara, Anda dapat menggabungkan reaksi singkat pendengar dalam karakter pipa (|reaction|) di dalam transkrip pembicara aktif. Pembicara yang tidak aktif menyela secara alami pada saat itu tanpa memerlukan giliran terpisah:

  • Backchannel pendengar singkat:

    • Giliran 1 (speaker: "Joe"): "So the launch is Thursday |oh hmm| Are we actually ready?"
    • Giliran 2 (speaker: "Jane"): "Ready enough |oh really?| The last blocker cleared this morning."
  • Ucapan yang tumpang-tindih: Anda dapat menggunakan beberapa segmen pipe untuk menyimulasikan ucapan simultan (paling cocok dengan gemini-3.8-flash-tts), seperti:

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

Praktik terbaik untuk konsistensi

  • Uji tanpa style terlebih dahulu, lalu tambahkan penyesuaian style yang ringkas: Sebagian besar permintaan terdengar alami dengan kolom style yang kosong. Tambahkan frasa style singkat (seperti "casual, friendly" atau "reflective and awe-inspired") hanya jika giliran memerlukan penyesuaian pengiriman tertentu, dan gunakan kembali string singkat yang sama di seluruh giliran jika Anda menginginkan dasar pengukuran yang konsisten.

  • Tulis transkrip lisan yang alami: Sertakan pemendekan kata dalam percakapan dan disfluensi alami (seperti "Oh, uh, yeah I think... hm, that's interesting") langsung dalam teks transkrip.

  • Hindari blok [Audio Profile] dan meta-instruksi lama: Paragraf persona yang panjang, blok [Director's Notes], atau meta-instruksi seperti "maintain identical timbre" meningkatkan pergeseran gaya bahasa. Sebagai gantinya, pilih suara yang cocok dari Extended Voice Library atau buat suara karakter yang persisten dengan Voice design.

  • Jangan mencoba mengganti karakteristik suara yang tidak dapat diubah di style: Hindari penggunaan SpeechMetadata.style untuk mengubah usia, gender, atau aksen permanen suara. Sebagai gantinya, pilih atau desain suara dengan karakteristik tersebut.



Suara yang didukung

Model Gemini 3.x TTS mendukung tiga cara untuk menentukan suara:

Semua suara bersifat multibahasa, yang berarti Anda dapat menggunakan suara yang sama untuk menghasilkan ucapan dalam bahasa yang didukung mana pun sambil mempertahankan identitas pembicara yang konsisten. Misalnya, jika Anda menyetel suara ke suara Kore bawaan dan mengirim perintah dalam bahasa Spanyol, Hindi, dan Vietnam, semua respons akan menggunakan suara Kore dalam setiap bahasa tersebut. Meskipun 30 suara bawaan inti adalah suara multibahasa untuk tujuan umum, suara Library Suara yang Diperluas dan suara kustom dikaitkan ke lokalitas utama atau aksen regional. Artinya, mereka masih dapat berbicara dalam bahasa lain, tetapi terdengar paling autentik dalam lokalitas utama mereka.

Suara bawaan inti

Model TTS Gemini mendukung 30 suara bawaan inti (seperti Kore, Puck, Zephyr, Charon, dan Fenrir), masing-masing dengan karakteristik vokal yang berbeda. Teruskan nama suara di SpeechConfig (seperti yang ditunjukkan dalam contoh pembicara tunggal dan multi-pembicara sebelumnya di halaman ini).

Suara preset dari Extended Voice Library

Selain 30 suara bawaan, Extended Voice Library menyediakan lebih dari 2.000 suara preset pilihan yang mencakup beragam bahasa, aksen regional, rentang usia, persona karakter, dan kasus penggunaan (seperti buku audio, agen dukungan pelanggan, dan pembaca berita).

Berikut cara menggunakan suara apa pun dari Library Suara yang Diperluas di aplikasi Anda:

  1. Jelajahi dan lihat pratinjau suara menggunakan salah satu opsi berikut:

  2. Teruskan string id suara library sebagai nama suara di SpeechConfig (mirip dengan yang ditampilkan dalam contoh pembicara tunggal sebelumnya di halaman ini).

Suara kustom: Desain suara dan replikasi suara

Model Gemini 3.x TTS juga mendukung suara kustom menggunakan salah satu opsi berikut:

  • Desain suara (Pratinjau): Buat suara kustom yang unik dari deskripsi bahasa alami tentang usia, timbre vokal, aksen, dan persona pembicara (tanpa memerlukan audio referensi apa pun). Menampilkan ID suara tersimpan (voice_...).

  • Replikasi suara (Pratinjau): Mereplikasi suara, nada, dan irama pembicara dari rekaman referensi dan rekaman izin lisan. Menampilkan ID suara yang disimpan project (voice_...) atau kunci replikasi suara stateless yang dikelola aplikasi (voicekey_...).

Menggunakan suara kustom di aplikasi Firebase AI Logic Anda

Membuat dan mengelola suara kustom adalah operasi administratif atau sisi server, sehingga SDK klien Firebase AI Logic tidak secara langsung mengekspos endpoint pengelolaan Suara (CreateVoice, ListVoices, DeleteVoice).

Sebagai gantinya, untuk menggunakan suara kustom, Anda perlu melakukan hal berikut:

  1. Buat suara kustom sekali menggunakan salah satu opsi berikut:

    • Gunakan Google AI Studio atau Agent  Studio untuk mendapatkan ID voice_<id> atau voicekey_<id> Anda.

    • Gunakan Voices API untuk mendapatkan ID voice_<id> atau voicekey_<id> Anda. Pelajari lebih lanjut di dokumentasi penyedia Gemini API yang Anda pilih:

  2. Teruskan string voice_<id> atau voicekey_<id> sebagai nama suara di SpeechConfig (mirip dengan yang ditampilkan dalam contoh satu pembicara sebelumnya di halaman ini).

Perhatikan persyaratan berikut saat menggunakan suara kustom:

  • Lokasi (Agent Platform Gemini API (formerly Vertex AI)): Suara kustom (voice_... dan voicekey_...) hanya didukung di lokasi global (yang merupakan lokasi default saat menggunakan Firebase AI Logic).

  • Permintaan satu pembicara: MultiSpeakerVoiceConfig hanya mendukung suara bawaan inti. Untuk menggunakan suara yang didesain khusus atau direplikasi dalam dialog multi-karakter, sintesis giliran setiap karakter dalam permintaan satu pembicara yang terpisah.

  • Retensi dan masa berlaku: Suara kustom yang disimpan (voice_...) akan berakhir jika tidak digunakan selama 1 tahun (setiap permintaan sintesis akan mereset timer retensi 1 tahun); kunci replikasi suara stateless (voicekey_...) akan berakhir 7 hari setelah pembuatan.

Bahasa yang didukung

Model Gemini 3.x TTS otomatis mendeteksi bahasa dari teks input Anda, termasuk saat perintah beralih bahasa di berbagai giliran dalam dialog multibicara.

  • Gemini 3.8 Flash TTS (gemini-3.8-flash-tts): Mendukung 132 bahasa.
  • Gemini 3.8 Flash‑Lite TTS (gemini-3.8-flash-lite-tts): Mendukung 103 bahasa.

(Opsional) Menetapkan kode bahasa secara eksplisit

Jika ingin secara eksplisit membatasi sintesis ucapan ke lokalitas tertentu, Anda dapat meneruskan languageCode BCP-47 di SpeechConfig:



Format output audio

Format audio default yang ditampilkan di InlineDataPart bergantung pada apakah Anda membuat permintaan unary atau streaming:

Metode permintaan Jenis MIME default yang ditampilkan Detail format audio
Unary
(generateContent)
audio/wav File WAV lengkap (PCM linear 16-bit, 24 kHz, mono, little-endian) dengan header RIFF 44-byte standar.

Dapat diputar langsung oleh pemutar audio platform standar (seperti AVAudioPlayer di platform Apple, Web Audio decodeAudioData, atau pemutar berbasis file).

Streaming
(generateContentStream)
audio/l16 Fragmen PCM little-endian bertanda 16-bit mentah tanpa header pada 24 kHz, mono.

Didesain untuk penggabungan dan antrean buffer latensi rendah tanpa header file per potongan.



Batasan dan persyaratan

Perhatikan batasan dan persyaratan berikut saat menggunakan model Gemini 3.x TTS:

  • Input khusus teks, output khusus audio: Model TTS hanya menerima input teks (TextPart) dan mengharuskan responseModalities ditetapkan ke AUDIO.

  • Hanya sintesis verbatim: Model akan membacakan transkrip yang diberikan secara verbatim dan tidak menghasilkan balasan teks percakapan.

  • Batas token: Input maksimum adalah 8.192 token dan output maksimum adalah 16.384 token per permintaan.

  • Batas multi-penutur: MultiSpeakerVoiceConfig memerlukan 2 penutur dan hanya mendukung suara bawaan inti. Setiap TextPart dalam permintaan multi-pembicara harus menyertakan SpeechMetadata.speaker yang cocok dengan salah satu pembicara yang dikonfigurasi.

  • Parameter dan metode yang tidak didukung:

    • SDK Firebase AI Logic belum mendukung setelan responseFormat di GenerationConfig untuk mengganti format output audio default.
    • Menetapkan systemInstruction, temperature, topP, topK, candidateCount, presencePenalty, atau frequencyPenalty tidak didukung dan menyebabkan permintaan gagal dengan error 400 INVALID_ARGUMENT.
    • Pemanggilan countTokens tidak didukung untuk model TTS (jumlah token ditampilkan dalam usageMetadata pada respons).
  • Lokasi (Agent Platform Gemini API (formerly Vertex AI)): Suara kustom (voice_... dan voicekey_...) memerlukan lokasi global (yang merupakan lokasi default saat menggunakan Firebase AI Logic).



Migrasi dari gemini-3.1-flash-tts-preview

gemini-3.8-flash-tts dan gemini-3.8-flash-lite-tts menggunakan struktur permintaan yang sama. Tinjau tabel perbandingan model untuk memilih pengganti terbaik bagi workload Anda, dan perbarui kode Anda sebagai berikut:

Luas gemini-3.1-flash-tts-preview (Lama) gemini-3.8-flash-tts dan
gemini-3.8-flash-lite-tts
Gaya & arahan penyampaian Disematkan dalam teks perintah. Contoh:
"Say cheerfully: ...",
[Audio Profile],
[Director's Notes]
Lulus di SpeechMetadata(style: "...") pada setiap TextPart

Pastikan teks TextPart benar-benar sesuai dengan transkrip lisan verbatim.

Dialog multi-pembicara String teks tunggal dengan awalan "Speaker: ..." inline Satu TextPart per giliran dialog, dengan SpeechMetadata(speaker: "...", style: "...") pada setiap TextPart
Tag vokal inline Tanda kurung siku. Misalnya,
[sigh] atau [laughs]
Tanda kurung sudut. Misalnya,
<sigh> atau <laugh> atau <short pause>

Tulis disfluensi lisan seperti "uhm" langsung dalam teks.

Format audio unary default (generateContent) PCM 16-bit mentah tanpa header (audio/pcm, 24 kHz, mono) File WAV lengkap (audio/wav, PCM 16-bit, 24 kHz, mono, dengan header RIFF 44 byte)

Streaming (generateContentStream) tetap berupa PCM 16-bit mentah tanpa header (audio/l16).

System instructions, temperature, top-P, top-K Diabaikan Ditolak dengan error 400 INVALID_ARGUMENT. Hapus parameter ini dari konfigurasi model Anda.

Checklist migrasi

  • Upgrade ke versi terbaru Firebase AI Logic SDK dan update nama model Anda ke gemini-3.8-flash-tts atau gemini-3.8-flash-lite-tts.

  • Pindahkan petunjuk gaya ke SpeechMetadata.style: Hapus awalan "Say cheerfully:", [Audio Profile], [Scene], dan blok [Director's Notes] dari string perintah Anda agar model tidak membacanya dengan keras. Teruskan deskripsi gaya yang ringkas di SpeechMetadata.style.

  • Pisahkan skrip multi-pembicara menjadi giliran TextPart yang terpisah: Ganti blok teks "Joe: ... \n Jane: ..." dengan array/daftar objek TextPart yang setiap gilirannya menetapkan SpeechMetadata.speaker.

  • Mengonversi tag [...] menjadi tag <...>: Ganti tag audio dalam tanda kurung siku (seperti [whispers], [sighs], [laughs]) dengan tag vokal dalam tanda kurung sudut (seperti <whispers>, <sigh>, <laugh>, <short pause>).

  • Perbarui pemutaran audio unary: Karena generateContent kini menampilkan file WAV lengkap (dengan header RIFF 44 byte), bukan PCM mentah tanpa header, hapus kode apa pun yang menambahkan header WAV secara manual ke respons unary (atau lewati header 44 byte jika memasukkan sampel PCM mentah ke API buffer tingkat rendah seperti AudioTrack Android atau AudioClip Unity).

  • Hapus parameter konfigurasi yang tidak didukung: Hapus temperature, topP, topK, candidateCount, presencePenalty, frequencyPenalty, dan systemInstruction dari konfigurasi GenerativeModel TTS Anda.



Kamu bisa apa lagi?

Mencoba kemampuan lain

Pelajari cara mengontrol pembuatan konten

Anda juga dapat bereksperimen dengan perintah dan konfigurasi model, bahkan mendapatkan cuplikan kode yang dihasilkan menggunakan Google AI Studio.

Pelajari lebih lanjut model yang didukung

Pelajari model yang tersedia untuk berbagai kasus penggunaan beserta kuota dan harganya.


Berikan masukan tentang pengalaman Anda menggunakan Firebase AI Logic