Generowanie tekstu na mowę (TTS) za pomocą interfejsu Gemini API


Możesz poprosić model Gemini TTS o wygenerowanie mowy (dźwięku) na podstawie promptu tekstowego. Gdy korzystasz z Firebase AI Logic, możesz wysłać tę prośbę bezpośrednio z aplikacji.

Generowanie tekstu na mowę (TTS) jest kontrolowane, co oznacza, że podajesz dokładny tekst, który ma zostać przekształcony w mowę. W promptach możesz też używać języka naturalnego, aby określić styl, akcent, tempo i ton wyjścia audio. Zamiana tekstu na mowę to odwrotność transkrypcji (zamiany mowy na tekst).

Ta funkcja jest dostępna w przypadku wszystkich modeli Gemini -tts, które są zoptymalizowane pod kątem generowania mowy o wysokiej jakości i niskim opóźnieniu.

Dzięki tej funkcji możesz na przykład:

  • Interaktywne opowiadanie historii: twórz wciągające audiobooki lub gry fabularne, w których model zmienia głos w zależności od postaci lub dostosowuje ton (np. szepcze w momencie napięcia lub śmieje się z żartu), aby dopasować go do narracji.

  • Nauka języków: twórz przewodniki wymowy, które mogą odczytywać tekst z określonymi akcentami regionalnymi lub w wolniejszym tempie, aby pomóc uczniom w ćwiczeniu trudnych wymów.

  • Czytniki treści uwzględniające kontekst: czytaj na głos artykuły, przepisy lub posty na blogu, używając głosu i tonu emocjonalnego dopasowanego do treści (np. poważnego tonu w przypadku najnowszych wiadomości lub ciepłego, cierpliwego tonu w przypadku instrukcji gotowania krok po kroku).

Z tego przewodnika dowiesz się, jak generować mowę z tekstu wejściowego z jednym lub wieloma mówcami oraz jak przesyłać strumieniowo odpowiedź audio.

Przejdź do kodu dla jednego głośnika Przejdź do kodu dla wielu głośników Przejdź do kodu dla przesyłanych strumieniowo odpowiedzi

Porównanie TTS i Live API

Zarówno modele zamiany tekstu na mowę (TTS), jak i Live API to modele generujące mowę o niskim poziomie opóźnień, które można skonfigurować pod kątem różnych głosów odpowiedzi i języków. Służą one jednak do bardzo różnych celów.

  • Generowanie tekstu na mowę (TTS) to jednokierunkowa interakcja typu żądanie-odpowiedź (tekst na wejściu, dźwięk na wyjściu). Jest ona dostosowana do scenariuszy, które wymagają dokładnego odczytania podanego tekstu z precyzyjną kontrolą stylu i dźwięku, takich jak narracja w podcaście, audiobooki czy czytanie artykułów na głos.

  • Live API generacji obsługuje dwukierunkowe przesyłanie strumieniowe w przypadku rozmów głosowych w czasie rzeczywistym (głos przychodzący i wychodzący). Sprawdza się w dynamicznych kontekstach konwersacyjnych, w których model decyduje, która odpowiedź głosowa jest odpowiednia. Pamiętaj, że najnowsze modele Live API obsługują też dane wejściowe w postaci filmów i obrazów.

Zanim zaczniesz

Kliknij Gemini API dostawcę, aby wyświetlić na tej stronie treści i kod dostawcy.

Jeśli jeszcze tego nie zrobisz, zapoznaj się z przewodnikiem dla początkujących, w którym znajdziesz informacje o tym, jak skonfigurować projekt Firebase, połączyć aplikację z Firebase, dodać pakiet SDK, zainicjować usługę backendu dla wybranego dostawcy Gemini API i utworzyć instancję GenerativeModel.

Do testowania promptów i wprowadzania w nich poprawek zalecamy używanie Google AI Studio.

Modele obsługujące tę funkcję

  • gemini-3.1-flash-tts-preview

Generowanie mowy na podstawie tekstu

Możesz wygenerować mowę z podanego tekstu za pomocą modelu TTS Gemini.

Generowanie mowy za pomocą jednego głośnika

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlać treści dotyczące tego dostawcy.

Możesz skonfigurować model tak, aby generował dźwięk przy użyciu jednego głosu.

W GenerationConfig podaj te informacje:

Zadzwoń do generateContent, używając prompta tekstowego. Model zwraca surowe dane audio PCM w częściach odpowiedzi.

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.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt.
let prompt = "Say cheerfully: Have a wonderful day!"

// Call `generateContent` to generate the speech output based on your text prompt.
let response = try await model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let data = part.data          // Raw PCM audio bytes (24kHz, 1 channel, 16-bit)
  let mimeType = part.mimeType  // for example: "audio/pcm"
  print("Received audio data with MIME type: \(mimeType)")

  // To play back raw PCM audio bytes, you'll need to write your own `playRawPcm` function.
  playRawPcm(data: data)
}

Kotlin

W przypadku języka Kotlin metody w tym pakiecie SDK są funkcjami zawieszania i muszą być wywoływane w zakresie współprogramu. 

// 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.
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt.
val prompt = "Say cheerfully: Have a wonderful day!"

// Call `generateContent` to generate the speech output based on your text prompt.
val response = model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val pcmData = part.inlineData  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
    val mimeType = part.mimeType   // for example: "audio/pcm"

    // To play back PCM audio data, you'll need to write your own `playAudio` function.
    playAudio(pcmData)
}

Java

W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki 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.1-flash-tts-preview", config);

// Use the GenerativeModelFutures Java compatibility layer.
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt.
String prompt = "Say cheerfully: Have a wonderful day!";
Content content = new Content.Builder().addText(prompt).build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output based on your text prompt.
// Extract the 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[] pcmData = ((InlineDataPart) part).getInlineData();
            String mimeType = ((InlineDataPart) part).getMimeType();

            // To play back PCM audio data, you'll need to write your own `playAudio` function.
            playAudio(pcmData);
        }
    }

    @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.1-flash-tts-preview",
  generationConfig
});

// Provide a text prompt.
const prompt = "Say cheerfully: Have a wonderful day!";

// Call `generateContent` to generate the speech output based on your text prompt.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const pcmBase64 = inlineDataParts[0].inlineData.data;
  // Decode base64 to ArrayBuffer
  const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;

  // To play back a PCM buffer, you'll need to write your own `playAudio` function.
  playAudio(pcmBuffer);
}

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: [ResponseModality.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.1-flash-tts-preview',
  config: config,
);

// Provide a text prompt.
final prompt = 'Say cheerfully: Have a wonderful day!';

// Call `generateContent` to generate the speech output based on your text prompt.
final response = await model.generateContent([Content.text(prompt)]);

// Extract the 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 pcmData = part.bytes;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

  // To play back PCM audio data, you'll need to write your own `playAudio` function.
  await playAudio(pcmData);
}

Unity 


using Firebase.AI;

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

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.1-flash-tts-preview",
  generationConfig: config
);

// Provide a text prompt.
var prompt = "Say cheerfully: Have a wonderful day!";

// Call `GenerateContentAsync` to generate the speech output based on your text prompt.
var response = await model.GenerateContentAsync(prompt);

// Extract the 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[] pcmData = inlineData.Data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

      // To play back PCM audio data, you'll need to write your own `playAudio` function.
      playAudio(pcmData);
    }
  }
}

Generowanie mowy z udziałem wielu rozmówców

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlać treści dotyczące tego dostawcy.

Możesz skonfigurować model tak, aby używał różnych głosów dla różnych rozmówców w tekście. Przydaje się to do generowania dźwięku w przypadku dialogów lub rozmów.

  1. Utwórz MultiSpeakerVoiceConfig, który przypisuje nazwy mówców (których użyjesz w prompcie) do konkretnych nazw głosów odpowiedzi (np. Kore).

    Konfiguracja z wieloma głośnikami obsługuje dokładnie 2 głośniki.

  2. W GenerationConfig podaj te informacje:

    • Ustaw responseModalities, aby zawierało AUDIO.

    • Skonfiguruj SpeechConfig w ten sposób:

  3. W prompcie wskaż, kto mówi, używając nazw mówców jako prefiksów (np. Joe: Hello. Jane: Hi.).

Zadzwoń do generateContent, używając prompta tekstowego. Model zwraca surowe dane audio PCM w częściach odpowiedzi.

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.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt that includes the names of the speakers.
let prompt = """
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
"""

// Call `generateContent` to generate the speech output based on your text prompt.
let response = try await model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
for part in response.inlineDataParts {
  let data = part.data          // Raw PCM audio bytes (24kHz, 1 channel, 16-bit)
  let mimeType = part.mimeType  // for example: "audio/pcm"
  print("Received audio data with MIME type: \(mimeType)")

  // To play back raw PCM audio bytes, you'll need to write your own `playRawPcm` function.
  playRawPcm(data: data)
}

Kotlin

W przypadku języka Kotlin metody w tym pakiecie SDK są funkcjami zawieszania i muszą być wywoływane w zakresie współprogramu. 

// 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.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt that includes the names of the speakers.
val prompt = """
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
"""

// Call `generateContent` to generate the speech output based on your text prompt.
val response = model.generateContent(prompt)

// Extract the audio data and handle it for downstream use. For example:
val part = response.candidates.firstOrNull()?.content?.parts?.firstOrNull()
if (part is InlineDataPart) {
    val pcmData = part.inlineData  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
    val mimeType = part.mimeType   // for example: "audio/pcm"

    // To play back PCM audio data, you'll need to write your own `playAudio` function.
    playAudio(pcmData)
}

Java

W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki 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);

// 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.1-flash-tts-preview", config);

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt that includes the names of the speakers.
String prompt = "Joe: How's it going today Jane?\nJane: Not too bad, how about you?";
Content content = new Content.Builder().addText(prompt).build();
Executor executor = Executors.newSingleThreadExecutor();

// Call `generateContent` to generate the speech output based on your text prompt.
// Extract the 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[] pcmData = ((InlineDataPart) part).getInlineData();  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
            String mimeType = ((InlineDataPart) part).getMimeType();   // for example: "audio/pcm"

            // To play back PCM audio data, you'll need to write your own `playAudio` function.
            playAudio(pcmData);
        }
    }

    @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.1-flash-tts-preview",
  generationConfig
});

// Provide a text prompt that includes the names of the speakers.
const prompt = `
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
`;

// Call `generateContent` to generate the speech output based on your text prompt.
const result = await model.generateContent(prompt);
const inlineDataParts = result.response.inlineDataParts();

// Extract the audio data and handle it for downstream use. For example:
if (inlineDataParts?.[0]) {
  const pcmBase64 = inlineDataParts[0].inlineData.data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
  const pcmBuffer = Uint8Array.from(atob(pcmBase64), c => c.charCodeAt(0)).buffer;

  // To play back a PCM buffer, you'll need to write your own `playAudio` function.
  playAudio(pcmBuffer);
}

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: [ResponseModality.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.1-flash-tts-preview',
  config: config,
);

// Provide a text prompt that includes the names of the speakers.
final prompt = '''
Joe: How's it going today Jane?
Jane: Not too bad, how about you?
''';

// Call `generateContent` to generate the speech output based on your text prompt.
final response = await model.generateContent([Content.text(prompt)]);

// Extract the 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 pcmData = part.bytes;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

  // To play back PCM audio data, you'll need to write your own `playAudio` function.
  await playAudio(pcmData);
}

Unity 


using Firebase.AI;

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

// Set `responseModalities` to include `Audio`.
var config = new GenerationConfig(
  responseModalities: new System.Collections.Generic.List<ResponseModality> { ResponseModality.Audio },
  speechConfig: multiSpeechConfig
);

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports speech generation.
var model = ai.GetGenerativeModel(
  modelName: "gemini-3.1-flash-tts-preview",
  generationConfig: config
);

// Provide a text prompt that includes the names of the speakers.
var prompt = "Joe: How's it going today Jane?\nJane: Not too bad, how about you?";

// Call `GenerateContentAsync` to generate the speech output based on your text prompt.
var response = await model.GenerateContentAsync(prompt);

// Extract the 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[] pcmData = inlineData.Data;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

      // To play back PCM audio data, you'll need to write your own `playAudio` function.
      playAudio(pcmData);
    }
  }
}

Przesyłanie odpowiedzi strumieniowo

Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, aby skonfigurować projekt i aplikację.
W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlać treści dotyczące tego dostawcy.

Możesz uzyskać szybsze interakcje i mniejsze opóźnienia, przesyłając strumieniowo odpowiedź audio w miarę jej generowania, zamiast czekać na ukończenie całego pliku audio.

Przesyłanie strumieniowe wygenerowanej mowy jest obsługiwane w przypadku konfiguracji jednego i wielu głośników. Jest ona obsługiwana tylko w przypadku modeli Gemini 3.x TTS.

Aby przesyłać strumieniowo odpowiedź głosową, wywołaj funkcję generateContentStream zamiast generateContent i obsługuj fragmenty w miarę ich przybywania. Poniższe przykłady pokazują, jak przesyłać strumieniowo odpowiedź jednego głośnika:

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.1-flash-tts-preview",
  generationConfig: config
)

// Provide a text prompt.
let prompt = "Tell me a story about a brave knight."

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
let responseStream = try model.generateContentStream(prompt)

// Extract the audio data and handle it for downstream use. For example:
for try await chunk in responseStream {
  for part in chunk.inlineDataParts {
    let data = part.data          // Raw PCM audio bytes (24kHz, 1 channel, 16-bit)
    let mimeType = part.mimeType  // for example: "audio/pcm"

    // Append the audio chunk to your audio queue/buffer for playback.
    appendAudioChunk(data)
  }
}

Kotlin

W przypadku języka Kotlin metody w tym pakiecie SDK są funkcjami zawieszania i muszą być wywoływane w zakresie współprogramu. 

// 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.1-flash-tts-preview",
        generationConfig = config
    )

// Provide a text prompt.
val prompt = "Tell me a story about a brave knight."

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
// Extract the audio data and handle it for downstream use.
model.generateContentStream(prompt).collect { chunk ->
    val part = chunk.candidates.firstOrNull()?.content?.parts?.firstOrNull()
    if (part is InlineDataPart) {
        val pcmChunk = part.inlineData  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
        val mimeType = part.mimeType    // for example: "audio/pcm"

        // Append the audio chunk to your audio queue/buffer for playback.
        appendAudioChunk(pcmChunk)
    }
}

Java

W przypadku Javy metody strumieniowania w tym pakiecie SDK zwracają typ Publisher z biblioteki 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.1-flash-tts-preview", config);

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt.
String prompt = "Tell me a story about a brave knight.";
Content content = new Content.Builder().addText(prompt).build();

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

// Extract the audio data and handle it for downstream use.
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();  // Raw PCM bytes (24kHz, 1 channel, 16-bit)
          String mimeType = ((InlineDataPart) part).getMimeType();    // for example: "audio/pcm"

          // Append the audio chunk to your audio queue/buffer for playback.
          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.1-flash-tts-preview",
  generationConfig
});

// Provide a text prompt.
const prompt = "Tell me a story about a brave knight.";

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
const result = await model.generateContentStream(prompt);

// Extract the audio data and handle it for downstream use. For example:
const playbackQueue = [];
for await (const chunk of result.stream) {
  const inlineDataParts = chunk.inlineDataParts();
  if (inlineDataParts?.[0]) {
    const pcmBase64 = inlineDataParts[0].inlineData.data;  // 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.
    playbackQueue.push(pcmBuffer);
  }
}

// To play back an array of PCM buffers in sequence, you'll need to write your own `processPlaybackQueue` function.
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: [ResponseModality.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.1-flash-tts-preview',
  config: config,
);

// Provide a text prompt.
final prompt = 'Tell me a story about a brave knight.';

// Call `generateContentStream` to generate the speech output stream based on your text prompt.
final responseStream = model.generateContentStream([Content.text(prompt)]);

// Extract the audio data and handle it for downstream use. For example:
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;  // Raw PCM bytes (24kHz, 1 channel, 16-bit)

    // Append the audio chunk to your audio queue/buffer for playback.
    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.1-flash-tts-preview",
    generationConfig: config
);

// Provide a text prompt.
var prompt = "Tell me a story about a brave knight.";

// Call `GenerateContentStreamAsync` to generate the speech output stream based on your text prompt.
var responseStream = model.GenerateContentStreamAsync(prompt);

// Extract the audio data and handle it for downstream use. For example:
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; // Raw PCM bytes (24kHz, 1 channel, 16-bit)

        // Append the audio chunk to your audio queue/buffer for playback.
        appendAudioChunk(pcmChunk);
    }
}


Sterowanie odpowiedzią głosową za pomocą promptów

Możesz wpływać na ton, tempo i styl wygenerowanej mowy, stosując określone techniki promptowania.

W podrozdziałach dotyczących struktury promptu i tagów audio znajdziesz ogólne wytyczne. Szczegółowe wskazówki znajdziesz w tym przewodniku po promptach.

Struktura promptu

Aby uzyskać najlepsze wyniki, podziel prompt na te części:

  • Audio Profile: opisz osobowość, tożsamość i archetyp mówcy (np. A warm, professional narrator).

  • Scene: opisz otoczenie i klimat emocjonalny (np. In a quiet library lub Amidst a noisy crowd).

  • Director's Notes: opisz emocje, tempo, styl i akcent (np. Speak slowly and with mystery).

  • Sample Context: podaj modelowi punkt początkowy (np.The speaker is greeting a close friend).

  • Transkrypcja: tekst, który ma być odczytany. Aby uzyskać najlepsze wyniki, upewnij się, że ton i kontekst tekstu są zgodne z profilem głosu i uwagami reżysera.

Przykładowy prompt:

[Audio Profile: A young, energetic voice]
[Scene: A lively sports broadcast]
[Director's Notes: Speak fast, with high energy and excitement]
[Sample Context: The game just ended with a last-second touchdown]
Welcome back fans! What an incredible game we're witnessing today!

Tagi audio

Aby wpływać na działanie modelu, możesz wstawiać tagi formatowania bezpośrednio do promptu tekstowego.

Tagi audio są obsługiwane tylko w przypadku korzystania z modeli Gemini 3.x TTS.

Często używane tagi:

  • [whispers]: mówić szeptem;
  • [laughs]: Aby dodać śmiech
  • [giggles]: Aby dodać chichot
  • [sighs]: Aby dodać westchnienie
  • [gasp]: Aby dodać westchnienie
  • [shouting]: To shout
  • [excited]: mówić z ekscytacją,
  • [serious]: Mówić poważnie
  • [sighs whispers]: połączone emocje (możesz łączyć tagi);

Korzystając z tagów audio, pamiętaj o tych kwestiach:

  • Brak wyczerpującej listy: nie ma stałej listy obsługiwanych tagów. Możesz eksperymentować z różnymi emocjami i wyrazami twarzy (np. [bored], [sarcastically] lub nawet [like dracula]), aby zobaczyć, jak zmienia się wynik.

  • Prompt tekstowy w innym języku niż angielski: jeśli prompt tekstowy nie jest w języku angielskim, dla uzyskania najlepszych wyników używaj tagów audio w języku angielskim.

Przykładowy prompt:

I have a secret to tell you. [whispers] I found the hidden treasure. [laughs] I can't believe it!


Ograniczenia i wymagania

Korzystając z generowania mowy, pamiętaj o tych ograniczeniach i wymaganiach:

  • Konfiguracja z wieloma głośnikami obsługuje dokładnie 2 głośniki.

  • Te funkcje są obsługiwane tylko w przypadku modeli Gemini 3.x TTS: przesyłanie strumieniowe, tagi audio i dodatkowe automatycznie wykrywane języki.

Ograniczenia dotyczące gemini-3.1-flash-tts-preview

  • Niespójność głosu: jeśli ton i kontekst promptu nie są zgodne z profilem wybranego mówcy (np. głęboki męski głos próbujący mówić jak mała dziewczynka), dane wyjściowe modelu mogą nie zawsze ściśle odpowiadać wybranemu mówcy. Upewnij się, że kontekst promptu pasuje do głosu.
  • Dłuższe wyjścia: jakość i spójność mowy mogą się pogorszyć w przypadku dźwięku trwającego dłużej niż kilka minut. Zalecamy dzielenie długich promptów tekstowych na mniejsze części.
  • Sporadyczne zwracanie tokenów tekstowych: model sporadycznie zwraca tokeny tekstowe zamiast tokenów audio, co powoduje niepowodzenie żądania z błędem 500. Dzieje się to losowo w przypadku niewielkiego odsetka żądań, dlatego w aplikacji należy zaimplementować logikę ponawiania.
  • Fałszywe odrzucenia klasyfikatora: niejasne prompty mogą nie przejść klasyfikatora syntezy mowy, co spowoduje odrzucenie żądania (PROHIBITED_CONTENT) lub sprawi, że model odczyta na głos instrukcje dotyczące stylu. Aby tego uniknąć, użyj strukturalnego prompta z jasnym wstępem (np. Audio Profile i Director's Notes) na początku prompta.


Obsługiwane głosy i języki

Modele TTS Gemini przyjmują tekst jako dane wejściowe i generują wyjście audio, więc odpowiedź to sama zsyntetyzowana mowa. W podsekcjach poniżej znajdziesz listę obsługiwanych głosów i języków, w których mogą „mówić” (lub odpowiadać) modele TTS Gemini.

Głosy są wielojęzyczne, co oznacza, że możesz używać tego samego głosu do generowania mowy w dowolnym z obsługiwanych języków. Możesz na przykład ustawić głos na Kore i wysłać zestaw promptów tekstowych w języku hiszpańskim, hindi i wietnamskim. Odpowiedzi będą generowane głosem Kore, ale w różnych językach.

Nazwy głosów

Gemini Modele TTS obsługują 30 różnych syntetyzowanych głosów HD, z których każdy ma odmienne cechy. Listę opcji głosowych i przykłady każdego głosu możesz wyświetlić, rozwijając sekcję poniżej.

Języki

Gemini Modele TTS mogą automatycznie wykrywać następujące języki w prompcie tekstowym. Wygenerowana mowa będzie w tym języku.

Pamiętaj, że w konfiguracji mowy możesz opcjonalnie jawnie ustawić kod języka.

Języki obsługiwane przez wszystkie modele generujące dźwięk
Język Kod BCP-47 Język Kod BCP-47
arabski (egipski), ar-EG niemiecki (Niemcy) de-DE
angielski (USA) en-US hiszpański (USA) es-US
francuski (Francja) fr-FR hindi (Indie) hi-IN
indonezyjski (Indonezja) id-ID włoski (Włochy) it-IT
japoński (Japonia) ja-JP koreański (Korea) ko-KR
portugalski (Brazylia) pt-BR rosyjski (Rosja) ru-RU
niderlandzki (Holandia) nl-NL polski (Polska) pl-PL
tajski (Tajlandia) th-TH turecki (Turcja) tr-TR
wietnamski (Wietnam) vi-VN rumuński (Rumunia) ro-RO
ukraiński (Ukraina) uk-UA bengalski (Bangladesz) bn-BD
angielski (Indie) Pakiet en-IN i hi-IN marathi (Indie) mr-IN
tamilski (Indie) ta-IN telugu (Indie) te-IN
Dodatkowe języki obsługiwane przez modele 3.x generujące dźwięk
Język Kod BCP-47 Język Kod BCP-47
afrikaans af filipiński fil
albański sq fiński fi
amharski am galicyjski gl
ormiański hy gruziński ka
azerski az grecki el
baskijski eu gudżarati gu
białoruski be kreolski haitański ht
bułgarski bg hebrajski he
birmański moje węgierski hu
kataloński urząd certyfikacji islandzki jest
cebuański ceb jawajski jv
chiński (mandaryński), cmn kannada kn
chorwacki godz. konkani kok
czeski cs laotański lo
duński da łaciński la
estoński et łotewski lv
litewski lt luksemburski lb
macedoński mk maithili mai
malgaski mg malajski ms
malajalam ml mongolski mn
nepalski ne norweski (bokmål), nb
norweski (nynorsk), nn orija lub
paszto ps perski fa
pendżabski pa serbski sr
sindhi sd syngaleski si
słowacki sk słoweński sl
suahili sw szwedzki sv
urdu ur

(Opcjonalnie) Jawne ustawienie kodu języka

Jeśli w konfiguracji mowy nie określisz kodu języka, model automatycznie wykryje język w prompcie tekstowym.

Możesz jednak opcjonalnie ustawić język w sposób jawny (za pomocą parametru languageCode w konfiguracji mowy). Aby to zrobić, musisz użyć jednego z tych obsługiwanych kodów języka BCP-47:

  • arabski: ar-XA
  • bengalski: bn-IN
  • chiński (mandaryński): cmn-CN
  • Dutch: nl-NL
  • English: en-US, en-GB, en-AU, en-IN
  • French: fr-FR, fr-CA
  • niemiecki: de-DE
  • gudżarati: gu-IN
  • Hindi: hi-IN
  • Indonezyjski: id-ID
  • włoski: it-IT
  • Język japoński: ja-JP
  • Kannada: kn-IN
  • koreański: ko-KR
  • Malayalam: ml-IN
  • marathi: mr-IN
  • Polish: pl-PL
  • Portugalski: pt-BR
  • Russian: ru-RU
  • Spanish: es-US, es-ES
  • Tamilski: ta-IN
  • Telugu: te-IN
  • Thai: th-TH
  • turecki: tr-TR
  • wietnamski: vi-VN


Co jeszcze możesz zrobić?

Wypróbuj inne funkcje

Dowiedz się, jak kontrolować generowanie treści

Możesz też eksperymentować z promptami i konfiguracjami modeli, a nawet uzyskać wygenerowany fragment kodu za pomocą Google AI Studio.

Więcej informacji o obsługiwanych modelach

Dowiedz się więcej o modelach dostępnych w różnych przypadkach użycia, ich limitach i cenach.


Prześlij opinię o korzystaniu z usługi Firebase AI Logic