Generazione di sintesi vocale (TTS) utilizzando l'API Gemini


Puoi utilizzare un modello TTS Gemini (gemini-3.8-flash-tts o gemini-3.8-flash-lite-tts) per sintetizzare un parlato (audio) naturale ed espressivo dal testo. Quando utilizzi Firebase AI Logic, puoi effettuare questa richiesta direttamente dalla tua app mobile o app web (ad esempio l'app Apple (Swift), Android (Kotlin/Java), web (JavaScript), Flutter (Dart) o Unity).

La generazione di sintesi vocale (TTS) è controllabile, il che significa che fornisci il testo esatto da sintetizzare in parlato, guidando al contempo l'erogazione, ad esempio emozioni, ritmo, voci degli speaker e suoni non vocali come risate o sospiri, utilizzando metadati strutturati e tag vocali incorporati. Puoi pensare alla sintesi vocale come all'opposto della trascrizione (da voce a testo).

Con questa funzionalità, puoi creare funzionalità come:

  • Storytelling interattivo e audiolibri: narra storie di lunga durata o giochi di ruolo in cui i personaggi cambiano voce, reagiscono l'uno all'altro con segnali di ascolto sovrapposti e adattano la loro espressione emotiva (ad esempio sussurrando in momenti di suspense o ridendo di una battuta).
  • Agenti e assistenti vocali a bassa latenza: trasmetti in streaming il parlato sintetizzato non appena il testo arriva da un LLM, mantenendo una persona vocale coerente durante le conversazioni.
  • Lettori di contenuti multilingue e tutor linguistici: leggi articoli, ricette o materiale di studio ad alta voce in oltre 130 lingue e accenti regionali o cambia lingua senza problemi all'interno di una singola conversazione.

Questa guida mostra come generare parlato con uno o più relatori, trasmettere in streaming risposte audio, indirizzare la voce con SpeechMetadata e tag incorporati e scegliere tra voci predefinite, della libreria o personalizzate.

Passa al codice per un singolo interlocutore Passa al codice per più interlocutori Passa al codice per lo streaming

Confronto tra TTS e Live API

Sia i modelli text-to-speech (TTS) che i modelli Live API sono modelli di generazione vocale a bassa latenza che possono essere configurati per diverse voci e lingue di risposta. Tuttavia, sono adatti a casi d'uso molto diversi.

  • La generazione di sintesi vocale (TTS) è un'interazione richiesta-risposta unidirezionale (testo in entrata, audio in uscita). È progettato per scenari che richiedono la recitazione esatta del testo fornito con un controllo granulare su stile e suono, come la narrazione di podcast, audiolibri o la lettura ad alta voce di articoli.

  • La generazione di Live API supporta lo streaming bidirezionale per conversazioni vocali in tempo reale (input vocale, output vocale). È eccellente in contesti di conversazione dinamici in cui il modello decide il parlato applicabile da restituire. Tieni presente che i modelli Live API più recenti supportano anche l'input di video e immagini.

Prima di iniziare

Fai clic sul tuo provider Gemini API per visualizzare i contenuti e il codice specifici del provider in questa pagina.

Se non l'hai già fatto, completa la guida introduttiva, che descrive come configurare il progetto Firebase, connettere l'app a Firebase, aggiungere l'SDK, inizializzare il servizio di backend per il provider Gemini API scelto e creare un'istanza GenerativeModel.

Per testare e perfezionare i prompt, ti consigliamo di utilizzare Google AI Studio.

Modelli che supportano questa funzionalità

  • gemini-3.8-flash-tts
  • gemini-3.8-flash-lite-tts
Confronto dei modelli TTS

Entrambi i modelli Gemini 3.x TTS hanno lo stesso schema di richiesta e lo stesso formato di prompt. Tuttavia, di seguito sono riportate alcune differenze relative ai casi in cui potresti utilizzare ciascun modello.

Funzionalità o workload gemini-3.8-flash-tts gemini-3.8-flash-lite-tts
Punto di forza principale Fedeltà vocale di livello professionale, sfumature di recitazione e ampia copertura dei dialetti Throughput elevato, bassa latenza e convenienza
Casi d'uso migliori Audiolibri, narrazione in studio, dialoghi complessi con più relatori, tag di vocalizzazione frequenti, pronuncia difficile, dialetti regionali Produzione ad alto volume, cascate di agenti vocali in tempo reale, funzionalità UI di lettura ad alta voce, parlato quotidiano con un singolo speaker
Lingue supportate 132 lingue 103 lingue

Genera parlato dal testo

Puoi generare parlato da un input di testo con una voce di un singolo speaker o un dialogo tra due speaker, come file WAV completo (generateContent) o come stream audio PCM non elaborato a bassa latenza (generateContentStream).

Genera voce con un singolo interlocutore

Prima di provare questo esempio, completa la sezione Prima di iniziare di questa guida per configurare il progetto e l'app.
In questa sezione, farai anche clic su un pulsante per il provider Gemini API scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina.

Ecco come generare audio con un singolo speaker:

  1. Nel tuo GenerationConfig, imposta responseModalities su AUDIO e configura un SpeechConfig con quanto segue:

  2. Crea un TextPart con quanto segue:

    • (Obbligatorio) La trascrizione letterale da pronunciare.

    • (Facoltativo) Un SpeechMetadata con una descrizione style (ad esempio, "cheerful and friendly").

  3. Chiama generateContent. Per impostazione predefinita, le richieste unarie restituiscono un file audio WAV (audio/wav) completo (PCM lineare a 16 bit, 24 kHz, mono, con un'intestazione RIFF standard di 44 byte) nelle parti di dati in linea della risposta.

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

Per Kotlin, i metodi in questo SDK sono funzioni di sospensione e devono essere chiamati da un ambito 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

Per Java, i metodi di streaming in questo SDK restituiscono un tipo Publisher dalla libreria 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);
    }
  }
}

Genera voce con più relatori

Prima di provare questo esempio, completa la sezione Prima di iniziare di questa guida per configurare il progetto e l'app.
In questa sezione, farai anche clic su un pulsante per il provider Gemini API scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina.

Puoi generare una conversazione naturale tra due persone in un'unica richiesta assegnando a ogni persona una voce distinta e passando ogni riga di dialogo come TextPart:

  1. Crea un MultiSpeakerVoiceConfig che mappa due nomi di speaker (ad esempio, "Joe" e "Jane") alle loro SpeakerVoiceConfig voci.

  2. Nel tuo GenerationConfig, imposta responseModalities su AUDIO e passa il tuo MultiSpeakerVoiceConfig (e l'elemento facoltativo languageCode) in SpeechConfig.

  3. Fornisci un array o un elenco di oggetti TextPart, in particolare un TextPart per turno di dialogo. Su ogni TextPart, imposta SpeechMetadata con quanto segue:

    • (Obbligatorio) Un speaker che corrisponde a uno dei nomi degli speaker definiti nel MultiSpeakerVoiceConfig.
    • (Facoltativo) Una descrizione di style (ad esempio, "cheerful and friendly").
  4. Chiama generateContent. Il modello sintetizza l'intera conversazione e restituisce un file audio WAV (audio/wav) completo.

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

Per Kotlin, i metodi in questo SDK sono funzioni di sospensione e devono essere chiamati da un ambito 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

Per Java, i metodi di streaming in questo SDK restituiscono un tipo Publisher dalla libreria 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);
    }
  }
}

Visualizza la risposta in modo dinamico

Prima di provare questo esempio, completa la sezione Prima di iniziare di questa guida per configurare il progetto e l'app.
In questa sezione, farai anche clic su un pulsante per il provider Gemini API scelto, in modo da visualizzare i contenuti specifici del provider in questa pagina.

Per un tempo di risposta più breve (TTFA) e una riproduzione in tempo reale, puoi riprodurre in streaming la risposta audio man mano che viene generata, anziché attendere il completamento dell'intero clip. Lo streaming funziona con configurazioni sia con speaker singolo sia con più speaker.

Per trasmettere l'audio in streaming, chiama generateContentStream anziché generateContent. A differenza delle richieste unarie (che restituiscono un file WAV), le richieste di streaming restituiscono chunk PCM non elaborati a 16 bit con segno little-endian senza intestazione (audio/l16, 24 kHz, mono), in modo da poter aggiungere ogni chunk direttamente al buffer di 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

Per Kotlin, i metodi in questo SDK sono funzioni di sospensione e devono essere chiamati da un ambito 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

Per Java, i metodi di streaming in questo SDK restituiscono un tipo Publisher dalla libreria 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);
    }
}



Controlla la sintesi vocale con metadati e tag incorporati

I modelli Gemini 3.x TTS trattano il text all'interno di ogni TextPart rigorosamente come una trascrizione letterale da leggere ad alta voce. Non scrivere istruzioni narrative (come "Say cheerfully:") all'interno della stringa di testo, altrimenti il modello potrebbe leggere queste parole ad alta voce.

Puoi dirigere l'interpretazione vocale utilizzando le seguenti tecniche:

Tag vocali style a livello di turno e incorporati

Suddividi le istruzioni per l'esecuzione in base all'ambito tra SpeechMetadata e i tag tra parentesi angolari in linea (<...>).

Ambito Posizionamento Cosa controlla Esempi
A livello di curva
(sostenuta per l'intera curva)
SpeechMetadata.style Emozione, persona, tono, inflessione, tono e velocità di pronuncia complessiva "cheerful and friendly",
"whispered, nervous",
"speaking rapidly",
"out of breath",
"sarcastic"
Point-in-time
(localizzato in un momento specifico della frase)
In linea nel testo TextPart utilizzando <...> Suoni vocali umani non vocali, respiri, pause o cambiamenti momentanei nell'intonazione "Wait... <short pause> did you hear that? <gasp> Someone's at the door."

Ritmo, pause, tono ed enfasi

  • Punteggiatura e puntini di sospensione: utilizza virgole, trattini (--) e puntini di sospensione (...) nella trascrizione per creare un fraseggio e un'esitazione naturali.

  • Tag di pausa espliciti: inserisci <short pause> o <long pause> in linea nel punto esatto in cui lo speaker deve fare una pausa:

    Hold on, let me think... <short pause> Alright, I've got it.
    
  • Velocità di pronuncia e tono: imposta style in SpeechMetadata per controllare il ritmo, il tono o l'inflessione generali della battuta (ad esempio, "speaking rapidly and excitedly", "speaking slowly" o "monotone and flat"). Se l'emozione o il ritmo cambiano a metà monologo, dividi lo script in battute TextPart separate, ciascuna con il proprio style.

  • Enfasi parola: scrivi parole specifiche nella trascrizione con la prima lettera maiuscola per enfatizzarle:

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

Espressioni vocali e suoni non vocali

Inserisci vocalizzazioni umane non vocali in linea utilizzando le parentesi angolari (<...>) in corrispondenza del confine esatto della parola in cui deve verificarsi il suono. Utilizza vocalizzazioni umane anziché effetti sonori non vocali. Ecco i tag consigliati da utilizzare:

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

Interiezioni e voci sovrapposte

Nel dialogo con più interlocutori, puoi racchiudere le brevi reazioni dell'ascoltatore tra caratteri pipe (|reaction|) all'interno della trascrizione dell'interlocutore attivo. L'interlocutore non attivo interviene naturalmente in quel momento senza richiedere un turno separato:

  • Brevi segnali di ascolto:

    • Turno 1 (speaker: "Joe"): "So the launch is Thursday |oh hmm| Are we actually ready?"
    • Turno 2 (speaker: "Jane"): "Ready enough |oh really?| The last blocker cleared this morning."
  • Discorso sovrapposto: puoi utilizzare più segmenti di pipe per simulare un discorso simultaneo (funziona meglio con gemini-3.8-flash-tts), ad esempio:

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

Best practice per la coerenza

  • Esegui prima un test senza style, poi aggiungi modifiche concise a style: la maggior parte delle richieste suona naturale con un campo style vuoto. Aggiungi una breve frase style (come "casual, friendly" o "reflective and awe-inspired") solo quando un turno richiede un aggiustamento specifico della consegna e riutilizza la stessa breve stringa nei turni quando vuoi una base di riferimento coerente.

  • Scrivi trascrizioni naturali del parlato: includi contrazioni colloquiali e disfluenze naturali (come "Oh, uh, yeah I think... hm, that's interesting") direttamente nel testo della trascrizione.

  • Evita blocchi [Audio Profile] e meta-istruzioni legacy: paragrafi lunghi sulla persona, blocchi [Director's Notes] o meta-istruzioni come "maintain identical timbre" aumentano la deviazione della voce. Scegli invece una voce corrispondente dalla Raccolta di voci estesa o crea una voce persistente per il personaggio con Voice Design.

  • Non provare a eseguire l'override dei tratti vocali immutabili in style: evita di utilizzare SpeechMetadata.style per modificare l'età, il genere o l'accento permanente di una voce. Seleziona o progetta invece una voce con queste caratteristiche.



Voci supportate

I modelli Gemini 3.x TTS supportano tre modi per specificare una voce:

Tutte le voci sono multilingue, il che significa che puoi utilizzare la stessa voce per generare il parlato in una qualsiasi delle lingue supportate, mantenendo un'identità di chi parla coerente. Ad esempio, se imposti la voce predefinita Kore e invii prompt in spagnolo, hindi e vietnamita, le risposte utilizzano tutte la voce Kore in ciascuna di queste lingue. Sebbene le 30 voci predefinite principali siano voci multilingue per uso generico, le voci della libreria di voci estesa e le voci personalizzate sono ancorate a un'impostazione internazionale o a un accento regionale principale. Ciò significa che possono comunque parlare altre lingue, ma suonano più autentiche nella loro lingua principale.

Voci predefinite principali

I modelli TTS Gemini supportano 30 voci predefinite di base (come Kore, Puck, Zephyr, Charon e Fenrir), ognuna con caratteristiche vocali distinte. Passa il nome della voce in SpeechConfig (come mostrato negli esempi di singolo speaker e più speaker riportati in precedenza in questa pagina).

Voci preimpostate dalla libreria di voci estesa

Oltre alle 30 voci predefinite, la libreria di voci estesa offre più di 2000 voci preimpostate selezionate che coprono diverse lingue, accenti regionali, fasce d'età, personaggi e casi d'uso (come audiolibri, agenti di assistenza clienti e lettori di notizie).

Ecco come utilizzare qualsiasi voce della Libreria di voci estesa nella tua app:

  1. Sfoglia e visualizza l'anteprima delle voci utilizzando una di queste opzioni:

  2. Passa la stringa id della voce della libreria come nome della voce in SpeechConfig (simile a quanto mostrato nell'esempio di singolo speaker precedente in questa pagina).

Voci personalizzate: progettazione e replica vocale

I modelli Gemini 3.x TTS supportano anche le voci personalizzate utilizzando una delle seguenti opzioni:

  • Voice Design (anteprima): genera una voce personalizzata unica da una descrizione in linguaggio naturale dell'età, del timbro vocale, dell'accento e della personalità di chi parla (senza bisogno di audio di riferimento). Restituisce un ID voce memorizzato (voice_...).

  • Replica vocale (anteprima): replica la voce, il tono e la cadenza di un oratore da una registrazione di riferimento e da una registrazione del consenso vocale. Restituisce un ID voce archiviato nel progetto (voice_...) o una chiave di replica vocale stateless gestita dall'app (voicekey_...).

Utilizza una voce personalizzata nell'app Firebase AI Logic

La creazione e la gestione di voci personalizzate è un'operazione amministrativa o lato server, pertanto gli SDK client Firebase AI Logic non espongono direttamente gli endpoint di gestione delle voci (CreateVoice, ListVoices, DeleteVoice).

Per utilizzare una voce personalizzata, devi invece:

  1. Crea la voce personalizzata una volta utilizzando una di queste opzioni:

  2. Passa la stringa voice_<id> o voicekey_<id> come nome della voce in SpeechConfig (simile a quanto mostrato nell'esempio di singolo speaker riportato in precedenza in questa pagina).

Tieni presente i seguenti requisiti quando utilizzi voci personalizzate:

  • Località (Agent Platform Gemini API (formerly Vertex AI)): le voci personalizzate (voice_... e voicekey_...) sono supportate solo nella località global (che è la località predefinita quando utilizzi Firebase AI Logic).

  • Richieste con un solo speaker: MultiSpeakerVoiceConfig supporta solo le voci predefinite di base. Per utilizzare voci progettate o replicate personalizzate in un dialogo con più personaggi, sintetizza il turno di ogni personaggio in una richiesta separata con un singolo speaker.

  • Conservazione e scadenza: le voci personalizzate archiviate (voice_...) scadono se non vengono utilizzate per 1 anno (ogni richiesta di sintesi reimposta il timer di conservazione di 1 anno); le chiavi di replica vocale stateless (voicekey_...) scadono 7 giorni dopo la creazione.

Lingue supportate

I modelli Gemini 3.x TTS rilevano automaticamente la lingua dal testo di input, anche quando un prompt cambia lingua tra i turni di un dialogo con più interlocutori.

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

(Facoltativo) Imposta esplicitamente un codice lingua

Se vuoi limitare esplicitamente la sintesi vocale a un'impostazione locale specifica, puoi passare un languageCode BCP-47 nel tuo SpeechConfig:



Formati di uscita audio

Il formato audio predefinito restituito in InlineDataPart dipende dal fatto che tu effettui una richiesta unaria o in streaming:

Metodo di richiesta Tipo MIME restituito predefinito Dettagli del formato audio
Unario
(generateContent)
audio/wav File WAV completo (PCM lineare a 16 bit, 24 kHz, mono, little-endian) con un'intestazione RIFF standard di 44 byte.

Può essere riprodotto direttamente dai lettori audio standard della piattaforma (come AVAudioPlayer sulle piattaforme Apple, Web Audio decodeAudioData o lettori basati su file).

Streaming
(generateContentStream)
audio/l16 Chunk PCM non elaborati senza intestazione a 16 bit signed, little endian a 24 kHz, mono.

Progettato per la coda di buffer a bassa latenza e la concatenazione senza intestazioni di file per chunk.



Limitazioni e requisiti

Tieni presente le seguenti limitazioni e i seguenti requisiti quando utilizzi i modelli Gemini 3.x TTS:

  • Input solo di testo, output solo audio: i modelli TTS accettano solo input di testo (TextPart) e richiedono che responseModalities sia impostato su AUDIO.

  • Solo sintesi letterale: i modelli recitano la trascrizione fornita letteralmente e non generano risposte di testo conversazionali.

  • Limiti di token: l'input massimo è di 8192 token e l'output massimo è di 16.384 token per richiesta.

  • Limite di più interlocutori: MultiSpeakerVoiceConfig richiede 2 interlocutori e supporta solo le voci predefinite di base. Ogni TextPart in una richiesta con più speaker deve includere un SpeechMetadata.speaker corrispondente a uno degli speaker configurati.

  • Parametri e metodi non supportati:

    • Gli SDK Firebase AI Logic non supportano ancora l'impostazione di responseFormat in GenerationConfig per eseguire l'override del formato di output audio predefinito.
    • L'impostazione systemInstruction, temperature, topP, topK, candidateCount, presencePenalty o frequencyPenalty non è supportata e causa l'errore delle richieste con un errore 400 INVALID_ARGUMENT.
    • La chiamata a countTokens non è supportata per i modelli TTS (i conteggi dei token vengono restituiti in usageMetadata nella risposta).
  • Località (Agent Platform Gemini API (formerly Vertex AI)): le voci personalizzate (voice_... e voicekey_...) richiedono la località global (che è la località predefinita quando utilizzi Firebase AI Logic).



Esegui la migrazione da gemini-3.1-flash-tts-preview

Sia gemini-3.8-flash-tts che gemini-3.8-flash-lite-tts utilizzano la stessa struttura di richiesta. Consulta la tabella di confronto modelli per scegliere il sostituto migliore per il tuo workload e aggiorna il codice come segue:

Area gemini-3.1-flash-tts-preview (Legacy) gemini-3.8-flash-tts e
gemini-3.8-flash-lite-tts
Stile di presentazione e regia Incorporati nel testo del prompt. Ad esempio:
"Say cheerfully: ...",
[Audio Profile],
[Director's Notes]
Passato in SpeechMetadata(style: "...") su ogni TextPart

Mantieni il testo TextPart rigorosamente fedele alla trascrizione letterale del parlato.

Dialogo con più interlocutori Singola stringa di testo con prefissi "Speaker: ..." in linea Un TextPart per turno di dialogo, con SpeechMetadata(speaker: "...", style: "...") su ogni TextPart
Tag vocali in linea Parentesi quadre. Ad esempio,
[sigh] o [laughs]
Parentesi angolari. Ad esempio,
<sigh> o <laugh> o <short pause>

Scrivi le disfluenze del parlato come "uhm" direttamente nel testo.

Formato audio unario predefinito (generateContent) PCM non elaborato a 16 bit senza intestazione (audio/pcm, 24 kHz, mono) File WAV completo (audio/wav, PCM a 16 bit, 24 kHz, mono, con un'intestazione RIFF a 44 byte)

Lo streaming (generateContentStream) rimane PCM a 16 bit non elaborato senza intestazione (audio/l16).

Istruzioni di sistema, temperatura, top-P, top-K Ignorato Rifiutata con un errore 400 INVALID_ARGUMENT. Rimuovi questi parametri dalla configurazione del modello.

Elenco di controllo per la migrazione

  • Esegui l'upgrade all'ultima versione dell'SDK Firebase AI Logic e aggiorna il nome del modello in gemini-3.8-flash-tts o gemini-3.8-flash-lite-tts.

  • Sposta le istruzioni di stile in SpeechMetadata.style: rimuovi i prefissi "Say cheerfully:", [Audio Profile], [Scene] e i blocchi [Director's Notes] dalle stringhe dei prompt in modo che il modello non li legga ad alta voce. Passa invece una descrizione concisa dello stile in SpeechMetadata.style.

  • Suddividi gli script con più interlocutori in turni TextPart separati: sostituisci i blocchi di testo "Joe: ... \n Jane: ..." con un array/elenco di oggetti TextPart in cui ogni turno imposta SpeechMetadata.speaker.

  • Converti i tag [...] in tag <...>: sostituisci i tag audio tra parentesi quadre (come [whispers], [sighs], [laughs]) con i tag vocali tra parentesi angolari (come <whispers>, <sigh>, <laugh>, <short pause>).

  • Aggiorna la riproduzione audio unaria: poiché generateContent ora restituisce un file WAV completo (con un'intestazione RIFF di 44 byte) anziché un PCM non elaborato senza intestazione, rimuovi qualsiasi codice che anteponga manualmente un'intestazione WAV alle risposte unarie (o salta l'intestazione di 44 byte se inserisci campioni PCM non elaborati in un'API buffer di basso livello come AudioTrack di Android o AudioClip di Unity).

  • Rimuovi i parametri di configurazione non supportati: rimuovi temperature, topP, topK, candidateCount, presencePenalty, frequencyPenalty e systemInstruction dalla configurazione TTS GenerativeModel.



Cos'altro sai fare?

Prova altre funzionalità

Scopri come controllare la generazione di contenuti

Puoi anche sperimentare con i prompt e le configurazioni dei modelli e persino ottenere uno snippet di codice generato utilizzando Google AI Studio.

Scopri di più sui modelli supportati

Scopri di più sui modelli disponibili per vari casi d'uso e sulle relative quote e prezzi.


Invia un feedback sulla tua esperienza con Firebase AI Logic