Gemini 3.8 Flash është tani në dispozicion. Provojeni .

Kjo faqe është përkthyer nga Cloud Translation API.

Gjenerimi i tekstit në të folur (TTS)

API-ja Gemini mund të transformojë tekstin e futur në audio me një ose shumë folës duke përdorur aftësitë e gjenerimit të tekstit në të folur (TTS) të Gemini. Gjenerimi i tekstit në të folur është i kontrollueshëm , që do të thotë se mund të kombinoni meta të dhënat e kthesës së strukturuar ( speech_metadata ) dhe etiketat vokale të integruara për të udhëhequr stilin , theksin , ritmin dhe tonin e audios.

Aftësia TTS ndryshon nga gjenerimi i të folurit i ofruar përmes Live API , i cili është projektuar për audio interaktive, të pastrukturuar dhe hyrje dhe dalje multimodale. Ndërsa Live API shkëlqen në kontekstet dinamike të bisedave, TTS përmes Gemini API është përshtatur për skenarë që kërkojnë recitim të saktë të tekstit me kontroll të imët mbi stilin dhe tingullin, siç është gjenerimi i podkasteve ose i librave audio.

Ky udhëzues ju tregon se si të gjeneroni audio me një dhe shumë altoparlantë nga teksti duke përdorur Gemini 3.8 Flash TTS ( gemini-3.8-flash-tts ) dhe Gemini 3.8 Flash-Lite TTS ( gemini-3.8-flash-lite-tts ).

Para se të filloni

Sigurohuni që përdorni një model Gemini TTS të listuar në seksionin Modelet e mbështetura dhe përditësojeni në SDK-në më të fundit të Google GenAI ( google-genai >= 2.25.0 për Python ose @google/genai >= 2.24.0 për JavaScript/TypeScript) ose përdorni REST API. Për rezultate optimale, shqyrtoni Kur të përdorni cilin model për të zgjedhur modelin më të mirë për ngarkesën tuaj të punës.

Mund ta gjeni të dobishme të testoni modelet Gemini TTS në AI Studio përpara se të filloni ndërtimin.

TTS me një folës të vetëm

Për të konvertuar tekstin në audio me një altoparlant të vetëm me modelet Gemini 3.8 TTS, kaloni transkriptin fjalë për fjalë në input , bashkëngjitni stilimin e nivelit të radhës duke përdorur një shënim speech_metadata dhe konfiguroni zërin tuaj në generation_config.speech_config . Mund të zgjidhni një zë nga opsionet e parapërgatitura të Zërit , Biblioteka e Zërit e Zgjeruar ( GET /v1beta/voices ), një ID të dizajnit të Zërit të personalizuar ( voice_... ) ose një ID të replikimit të Zërit ( voice_... , ose voicekey_... ).

Ky shembull ruan audion e daljes së parazgjedhur WAV ( audio/wav ) nga modeli direkt në një skedar:

Python

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash-tts",
    input=[{
        "type": "user_input",
        "content": [{
            "type": "text",
            "text": "Have a wonderful day!",
            "annotations": [{
                "type": "speech_metadata",
                "style": "cheerful and friendly",
            }],
        }],
    }],
    response_format={"type": "audio"},
    generation_config={
        "speech_config": [
            {"voice": "Kore"},
        ]
    },
)

with open("out.wav", "wb") as f:
    f.write(base64.b64decode(interaction.output_audio.data))

JavaScript

import * as fs from 'node:fs';
import {GoogleGenAI} from '@google/genai';

async function main() {
   const client = new GoogleGenAI({});

   const interaction = await client.interactions.create({
      model: 'gemini-3.8-flash-tts',
      input: [{
         type: 'user_input',
         content: [{
            type: 'text',
            text: 'Have a wonderful day!',
            annotations: [{
               type: 'speech_metadata',
               style: 'cheerful and friendly',
            }],
         }],
      }],
      response_format: { type: 'audio' },
      generation_config: {
         speech_config: [
            { voice: 'Kore' },
         ],
      },
   });

   const audioBuffer = Buffer.from(interaction.output_audio.data, 'base64');
   fs.writeFileSync('out.wav', audioBuffer);
}
await main();

Shko

package main

import (
    "context"
    "encoding/base64"
    "encoding/binary"
    "log"
    "os"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func saveWaveFile(filename string, pcmData []byte) error {
    f, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer f.Close()

    sampleRate := uint32(24000)
    numChannels := uint16(1)
    bitsPerSample := uint16(16)
    byteRate := sampleRate * uint32(numChannels) * uint32(bitsPerSample/8)
    blockAlign := numChannels * (bitsPerSample / 8)
    dataSize := uint32(len(pcmData))

    f.WriteString("RIFF")
    binary.Write(f, binary.LittleEndian, uint32(36+dataSize))
    f.WriteString("WAVEfmt ")
    binary.Write(f, binary.LittleEndian, uint32(16))
    binary.Write(f, binary.LittleEndian, uint16(1))
    binary.Write(f, binary.LittleEndian, numChannels)
    binary.Write(f, binary.LittleEndian, sampleRate)
    binary.Write(f, binary.LittleEndian, byteRate)
    binary.Write(f, binary.LittleEndian, blockAlign)
    binary.Write(f, binary.LittleEndian, bitsPerSample)
    f.WriteString("data")
    binary.Write(f, binary.LittleEndian, dataSize)
    _, err = f.Write(pcmData)
    return err
}

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    generationConfig := &interactions.GenerationConfig{
        SpeechConfig: genai.Ptr(interactions.NewSpeechConfigUnion([]interactions.SpeechConfig{
            {Voice: genai.Ptr("Kore")},
        })),
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash-tts"),
            Input: interactions.NewInteractionsInput("Say cheerfully: Have a wonderful day!"),
            ResponseFormat: genai.Ptr(interactions.NewCreateModelInteractionResponseFormat(
                interactions.NewResponseFormat(interactions.AudioResponseFormat{}),
            )),
            GenerationConfig: generationConfig,
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    if res.Interaction.OutputAudio != nil && res.Interaction.OutputAudio.Data != nil {
        pcmBytes, err := base64.StdEncoding.DecodeString(*res.Interaction.OutputAudio.Data)
        if err != nil {
            log.Fatal(err)
        }
        if err := saveWaveFile("out.wav", pcmBytes); err != nil {
            log.Fatal(err)
        }
    }
}

PUSHTIM

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": [{
      "type": "user_input",
      "content": [{
        "type": "text",
        "text": "Have a wonderful day!",
        "annotations": [{
          "type": "speech_metadata",
          "style": "cheerful and friendly"
        }]
      }]
    }],
    "response_format": {
      "type": "audio"
    },
    "generation_config": {
      "speech_config": [
        { "voice": "Kore" }
      ]
    }
  }' | jq -r '[.steps[] | select(.type=="model_output") | .content[] | select(.type=="audio")] | last | .data' | base64 --decode > out.wav

Në SDK-të e Python dhe JavaScript, mund të merrni të dhënat audio të gjeneruara duke përdorur vetinë e lehtësisë interaction.output_audio , e cila kthen bllokun audio të gjeneruar së fundmi (në përgjigjet e papërpunuara REST JSON, audioja e koduar në base64 ruhet në steps[].content[].data ). Për detaje mbi vetitë e lehtësisë, shihni përmbledhjen e Ndërveprimeve .

TTS me shumë folës

Për dialog me shumë folës, konfiguroni dy folës në speech_config.speakers dhe kaloni çdo kthesë si një artikull teksti të veçantë me një shënim speech_metadata që specifikon speaker dhe style opsional të nivelit të kthesës. Vini re se speech_config pranon një varg ( [{"voice": "..."}] ) për gjenerimin e një folësi të vetëm dhe një objekt ( {"speakers": [...]} ) për gjenerimin e një folësi të vetëm:

Python

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash-tts",
    input=[{
        "type": "user_input",
        "content": [
            {
                "type": "text",
                "text": "How's it going today Jane?",
                "annotations": [{
                    "type": "speech_metadata",
                    "speaker": "Joe",
                    "style": "cheerful and friendly",
                }],
            },
            {
                "type": "text",
                "text": "Not too bad, how about you? Ready to test these new voices?",
                "annotations": [{
                    "type": "speech_metadata",
                    "speaker": "Jane",
                    "style": "calm and relaxed",
                }],
            },
        ],
    }],
    response_format={"type": "audio"},
    generation_config={
        "speech_config": {
            "speakers": [
                {"speaker": "Joe", "voice": "Puck"},
                {"speaker": "Jane", "voice": "Kore"},
            ],
        }
    },
)

with open("out.wav", "wb") as f:
    f.write(base64.b64decode(interaction.output_audio.data))

JavaScript

import * as fs from 'node:fs';
import {GoogleGenAI} from '@google/genai';

async function main() {
   const client = new GoogleGenAI({});

   const interaction = await client.interactions.create({
      model: 'gemini-3.8-flash-tts',
      input: [{
         type: 'user_input',
         content: [
            {
               type: 'text',
               text: "How's it going today Jane?",
               annotations: [{
                  type: 'speech_metadata',
                  speaker: 'Joe',
                  style: 'cheerful and friendly',
               }],
            },
            {
               type: 'text',
               text: 'Not too bad, how about you? Ready to test these new voices?',
               annotations: [{
                  type: 'speech_metadata',
                  speaker: 'Jane',
                  style: 'calm and relaxed',
               }],
            },
         ],
      }],
      response_format: { type: 'audio' },
      generation_config: {
         speech_config: {
            speakers: [
               { speaker: 'Joe', voice: 'Puck' },
               { speaker: 'Jane', voice: 'Kore' },
            ],
         },
      },
   });

   const audioBuffer = Buffer.from(interaction.output_audio.data, 'base64');
   fs.writeFileSync('out.wav', audioBuffer);
}

await main();

Shko

package main

import (
    "context"
    "encoding/base64"
    "encoding/binary"
    "log"
    "os"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func saveWaveFile(filename string, pcmData []byte) error {
    f, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer f.Close()

    sampleRate := uint32(24000)
    numChannels := uint16(1)
    bitsPerSample := uint16(16)
    byteRate := sampleRate * uint32(numChannels) * uint32(bitsPerSample/8)
    blockAlign := numChannels * (bitsPerSample / 8)
    dataSize := uint32(len(pcmData))

    f.WriteString("RIFF")
    binary.Write(f, binary.LittleEndian, uint32(36+dataSize))
    f.WriteString("WAVEfmt ")
    binary.Write(f, binary.LittleEndian, uint32(16))
    binary.Write(f, binary.LittleEndian, uint16(1))
    binary.Write(f, binary.LittleEndian, numChannels)
    binary.Write(f, binary.LittleEndian, sampleRate)
    binary.Write(f, binary.LittleEndian, byteRate)
    binary.Write(f, binary.LittleEndian, blockAlign)
    binary.Write(f, binary.LittleEndian, bitsPerSample)
    f.WriteString("data")
    binary.Write(f, binary.LittleEndian, dataSize)
    _, err = f.Write(pcmData)
    return err
}

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    prompt := "TTS the following conversation between Joe and Jane:\n" +
        "Joe: How's it going today Jane?\n" +
        "Jane: Not too bad, how about you?"

    generationConfig := &interactions.GenerationConfig{
        SpeechConfig: genai.Ptr(interactions.NewSpeechConfigUnion([]interactions.SpeechConfig{
            {Speaker: genai.Ptr("Joe"), Voice: genai.Ptr("Kore")},
            {Speaker: genai.Ptr("Jane"), Voice: genai.Ptr("Puck")},
        })),
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash-tts"),
            Input: interactions.NewInteractionsInput(prompt),
            ResponseFormat: genai.Ptr(interactions.NewCreateModelInteractionResponseFormat(
                interactions.NewResponseFormat(interactions.AudioResponseFormat{}),
            )),
            GenerationConfig: generationConfig,
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    if res.Interaction.OutputAudio != nil && res.Interaction.OutputAudio.Data != nil {
        pcmBytes, err := base64.StdEncoding.DecodeString(*res.Interaction.OutputAudio.Data)
        if err != nil {
            log.Fatal(err)
        }
        if err := saveWaveFile("out.wav", pcmBytes); err != nil {
            log.Fatal(err)
        }
    }
}

PUSHTIM

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": [{
      "type": "user_input",
      "content": [
        {
          "type": "text",
          "text": "How'\''s it going today Jane?",
          "annotations": [{
            "type": "speech_metadata",
            "speaker": "Joe",
            "style": "cheerful and friendly"
          }]
        },
        {
          "type": "text",
          "text": "Not too bad, how about you? Ready to test these new voices?",
          "annotations": [{
            "type": "speech_metadata",
            "speaker": "Jane",
            "style": "calm and relaxed"
          }]
        }
      ]
    }],
    "response_format": {
      "type": "audio"
    },
    "generation_config": {
      "speech_config": {
        "mode": "conversational",
        "speakers": [
          { "speaker": "Joe", "voice": "Puck" },
          { "speaker": "Jane", "voice": "Kore" }
        ]
      }
    }
  }'

Kontrolloni stilin e të folurit me metadata dhe etiketa

Gemini 3.8 TTS e trajton fushën text në mënyrë strikte si një transkript fjalë për fjalë. Për të kontrolluar transmetimin pa pasur nevojë që udhëzimet e skenës të lexohen me zë të lartë, ndani udhëzimet tuaja sipas fushëveprimit:

Transmetim i qëndrueshëm në nivel radhe ( speech_metadata.style ): Vendos emocionet, stilin e transmetimit, prozodinë, ritmin dhe volumin që zbatohen në të gjithë raundin në fushën e style (për shembull, "style": "whispered urgently" , "style": "out of breath" ose "style": "warm and enthusiastic" ).
Ngjarjet në kohë (etiketat brenda rreshtit): Vendosni shpërthime ose pauza të çastit vokal jo-folës direkt brenda transkriptit duke përdorur kllapa këndore (për shembull, "Wait... <short pause> did you hear that? <sigh>" ose "Excuse me <cough> as I was saying..." ).

Shihni udhëzuesin e Nxitjeve për praktikat më të mira gjithëpërfshirëse.

Shko

package main

import (
    "context"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    transcriptRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash"),
            Input: interactions.NewInteractionsInput(
                "Generate a short transcript around 100 words that reads " +
                    "like it was clipped from a podcast by excited herpetologists. " +
                    "The hosts names are Dr. Anya and Liam.",
            ),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    var transcript string
    if transcriptRes.Interaction.OutputText != nil {
        transcript = *transcriptRes.Interaction.OutputText
    }

    generationConfig := &interactions.GenerationConfig{
        SpeechConfig: genai.Ptr(interactions.NewSpeechConfigUnion([]interactions.SpeechConfig{
            {Speaker: genai.Ptr("Dr. Anya"), Voice: genai.Ptr("Kore")},
            {Speaker: genai.Ptr("Liam"), Voice: genai.Ptr("Puck")},
        })),
    }

    ttsRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash-tts"),
            Input: interactions.NewInteractionsInput(transcript),
            ResponseFormat: genai.Ptr(interactions.NewCreateModelInteractionResponseFormat(
                interactions.NewResponseFormat(interactions.AudioResponseFormat{}),
            )),
            GenerationConfig: generationConfig,
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    _ = ttsRes
}

Gjenerimi i të folurit në transmetim

Mund ta transmetoni audion e gjeneruar ndërsa sintetizohet duke vendosur stream: true . Ndryshe nga kërkesat unary (të cilat kthejnë një skedar të plotë WAV me një kokë RIFF), kërkesat e transmetimit kthejnë copa lineare PCM lineare little-endian 16-bit pa kokë ( audio/l16 , 24 kHz, mono) si parazgjedhje, kështu që copat audio mund të luhen ose të bashkohen vazhdimisht pa kokatene kontejnerësh.

Python

import base64
from google import genai

client = genai.Client()

stream = client.interactions.create(
    model="gemini-3.8-flash-tts",
    input=[{
        "type": "user_input",
        "content": [{
            "type": "text",
            "text": "Have a wonderful day!",
            "annotations": [{
                "type": "speech_metadata",
                "style": "cheerful and friendly",
            }],
        }],
    }],
    response_format={"type": "audio"},
    generation_config={
        "speech_config": [
            {"voice": "Kore"},
        ]
    },
    stream=True,
)

for event in stream:
    if event.event_type == "step.delta":
        if event.delta.type == "audio":
            audio_data = base64.b64decode(event.delta.data)
            # Process the audio chunk (e.g. play it or write to a file)

JavaScript

import {GoogleGenAI} from '@google/genai';

async function main() {
   const client = new GoogleGenAI({});

   const stream = await client.interactions.create({
      model: 'gemini-3.8-flash-tts',
      input: [{
         type: 'user_input',
         content: [{
            type: 'text',
            text: 'Have a wonderful day!',
            annotations: [{
               type: 'speech_metadata',
               style: 'cheerful and friendly',
            }],
         }],
      }],
      response_format: { type: 'audio' },
      generation_config: {
         speech_config: [
            { voice: 'Kore' },
         ],
      },
      stream: true,
   });

   for await (const event of stream) {
      if (event.event_type === 'step.delta') {
         if (event.delta.type === 'audio') {
            const audioBuffer = Buffer.from(event.delta.data, 'base64');
            // Process the audio buffer
         }
      }
   }
}
await main();

PUSHTIM

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  --no-buffer \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": [{
      "type": "user_input",
      "content": [{
        "type": "text",
        "text": "Have a wonderful day!",
        "annotations": [{
          "type": "speech_metadata",
          "style": "cheerful and friendly"
        }]
      }]
    }],
    "response_format": {
      "type": "audio"
    },
    "generation_config": {
      "speech_config": [
        { "voice": "Kore" }
      ]
    },
    "stream": true
  }'

Formatet e daljes audio

Modelet Gemini 3.8 TTS përdorin formate të ndryshme audio të parazgjedhura në varësi të faktit nëse kërkesa është unare apo transmetim:

Kërkesat unare ( stream=False ): Kthen audio të plotë WAV ( audio/wav ) me një kokë standarde RIFF (24 kHz, mono, PCM little-endian 16-bit me shenjë). Mund t'i ruani bajtet e dekoduara audio direkt në një skedar .wav pa i shtuar manualisht një kokë WAV.
Kërkesat për transmetim ( stream=True ): Kthen si parazgjedhje copëza PCM lineare ( audio/l16 ) të papërpunuara pa kokë (24 kHz, mono, PCM little-endian 16-bit me shenjë) në mënyrë që copëzat të mund të transmetohen ose të bashkohen vazhdimisht pa kokëza kontejnerësh në secilën copë.

Për të kërkuar një kodim audio ose shpejtësi mostrimi të ndryshme, konfiguroni mime_type dhe sample_rate opsionale brenda response_format :

Formati	vlera `mime_type`	Përshkrimi
WAV (parazgjedhje unare)	`"audio/wav"`	Skedar WAV i pakompresuar me një kokë RIFF (PCM little-endian 16-bit me shenjë, mono, 24 kHz parazgjedhje). Parazgjedhje për kërkesat unare.
PCM Raw (L16) (transmetim i parazgjedhur)	`"audio/l16"`	Audio lineare PCM 16-bitëshe me shenjë little-endian, e pakompresuar dhe pa kokë (24 kHz, mono). Cilësim i parazgjedhur për kërkesat e transmetimit.
Mu-law	`"audio/mulaw"`	Audio e koduar 8-bit G.711 mu-law (përdoret zakonisht në sistemet telefonike/IVR të Amerikës së Veriut dhe Japonisë).
A-ligj	`"audio/alaw"`	Audio e koduar sipas ligjit A G.711 8-bit (e përdorur zakonisht në sistemet telefonike evropiane dhe ndërkombëtare).

Gjithashtu mund të specifikoni sample_rate në Hertz (për shembull, 24000 , 16000 ose 8000 ).

Python

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash-tts",
    input=[{
        "type": "user_input",
        "content": [{
            "type": "text",
            "text": "Have a wonderful day!",
            "annotations": [{
                "type": "speech_metadata",
                "style": "cheerful and friendly",
            }],
        }],
    }],
    response_format={
        "type": "audio",
        "mime_type": "audio/l16",  # "audio/wav" (default), "audio/l16", "audio/mulaw", or "audio/alaw"
        "sample_rate": 24000,
    },
    generation_config={
        "speech_config": [
            {"voice": "Kore"},
        ]
    },
)

with open("out.pcm", "wb") as f:
    f.write(base64.b64decode(interaction.output_audio.data))

JavaScript

import * as fs from 'node:fs';
import {GoogleGenAI} from '@google/genai';

async function main() {
   const client = new GoogleGenAI({});

   const interaction = await client.interactions.create({
      model: 'gemini-3.8-flash-tts',
      input: [{
         type: 'user_input',
         content: [{
            type: 'text',
            text: 'Have a wonderful day!',
            annotations: [{
               type: 'speech_metadata',
               style: 'cheerful and friendly',
            }],
         }],
      }],
      response_format: {
         type: 'audio',
         mime_type: 'audio/l16', // 'audio/wav' (default), 'audio/l16', 'audio/mulaw', or 'audio/alaw'
         sample_rate: 24000,
      },
      generation_config: {
         speech_config: [
            { voice: 'Kore' },
         ],
      },
   });

   const audioBuffer = Buffer.from(interaction.output_audio.data, 'base64');
   fs.writeFileSync('out.pcm', audioBuffer);
}
await main();

Shko

package main

import (
    "context"
    "encoding/base64"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    generationConfig := &interactions.GenerationConfig{
        SpeechConfig: genai.Ptr(interactions.NewSpeechConfigUnion([]interactions.SpeechConfig{
            {Voice: genai.Ptr("Kore")},
        })),
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash-tts"),
            Input: interactions.NewInteractionsInput("Say cheerfully: Have a wonderful day!"),
            ResponseFormat: genai.Ptr(interactions.NewCreateModelInteractionResponseFormat(
                interactions.NewResponseFormat(interactions.AudioResponseFormat{}),
            )),
            GenerationConfig: generationConfig,
            Stream:           genai.Ptr(true),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    stream := res.InteractionSSEStreamEvent
    defer stream.Close()

    for stream.Next() {
        event := stream.Value()
        if stepDelta := event.GetDataStepDelta(); stepDelta != nil {
            if audioDelta := stepDelta.GetDeltaAudio(); audioDelta != nil && audioDelta.Data != nil {
                audioData, err := base64.StdEncoding.DecodeString(*audioDelta.Data)
                if err != nil {
                    log.Fatal(err)
                }
                // Process the audio chunk (e.g. play it or write to a file)
                _ = audioData
            }
        }
    }
    if err := stream.Err(); err != nil {
        log.Fatal(err)
    }
}

PUSHTIM

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash-tts",
    "input": [{
      "type": "user_input",
      "content": [{
        "type": "text",
        "text": "Have a wonderful day!",
        "annotations": [{
          "type": "speech_metadata",
          "style": "cheerful and friendly"
        }]
      }]
    }],
    "response_format": {
      "type": "audio",
      "mime_type": "audio/l16",
      "sample_rate": 24000
    },
    "generation_config": {
      "speech_config": [
        { "voice": "Kore" }
      ]
    }
  }'

Opsionet e zërit

Gemini 3.8 TTS mbështet katër mënyra për të zgjedhur ose krijuar zëra:

Zëra studioje të parapërgatitur: 30 zëra të kuruar të listuar në tabelën vijuese.
Biblioteka e Zërit e Zgjeruar: Qindra zëra shtesë në gjuhë, thekse dhe arketipe karakteresh të arritshme duke përdorur client.voices.list() ( GET /v1beta/voices ).
Dizajni i zërit : Gjeneroni një personazh vokal të personalizuar nga një përshkrim në gjuhën natyrore në Google AI Studio ose duke përdorur POST /v1beta/voices ( type="prompted" , i cili kthen një ID të vazhdueshëm voice_... dhe një pamje paraprake sample_audio WAV në CreateVoice dhe GetVoice ).
Replikimi i zërit : Replikoni zërin e një folësi nga audioja e referencës dhe pëlqimit në Google AI Studio ose duke përdorur POST /v1beta/voices ( type="replicated" , persistence store=True si parazgjedhje ose stateless store=False opsionale).

Kufijtë e zërit të personalizuar dhe TTL

Lloji i zërit	Modaliteti i ruajtjes	Kuotë / limit	Mbajtja (TTL)
Zëra shtetërorë ( `voice_...` , të nxitur ose të replikuar)	`store=True`	200 zëra për projekt (të ndarë midis zërave të nxitur dhe të replikuar)	1 vit nga përdorimi i fundit*
Taste zanore pa shtetësi ( `voicekey_...` , të replikuara)	`store=False`	Menaxhuar nga klienti	7 ditë

* Zgjatja TTL: Dritarja 1-vjeçare e ruajtjes rivendoset çdo herë që zëri përdoret në mënyrë aktive (ose duke sintetizuar të folurit me zërin ose duke e përdorur atë si zë bazë për ripërpunim). Zërat pa aktivitet për 1 vit fshihen automatikisht.

Zëra të parapërgatitur

Zephyr -- I ndritshëm	Puck -- Optimist	Karoni -- Informues
Kore -- Firmë	Fenrir -- I emocionueshëm	Leda -- Rinor
Orus -- Firmë	Aoede -- Breezy	Callirrhoe -- I qetë
Autonoe -- E ndritshme	Enceladus -- Frymëmarrësi	Iapetus -- I Qartë
Umbriel -- I qetë	Algieba -- E lëmuar	Despina -- E butë
Erinome -- I qartë	Algenib -- Gravelly	Rasalgethi -- Informative
Laomedeia -- Optimiste	Achernar -- I butë	Alnilam -- Firmë
Schedar -- Madje	Gacrux -- I pjekur	Pulcherrima -- Përpara
Achird -- Miqësor	Zubenelgenubi -- I rastësishëm	Vindemiatrix -- E butë
Sadachbia -- Gjallë	Sadaltager -- I ditur	Sulafat -- I ngrohtë

Biblioteka e Zërit e Zgjeruar dhe Filtrimi

Përtej 30 zërave të paraqitur në studio në tabelën e mëparshme, Biblioteka e Zërit e Zgjeruar ofron qindra zëra shtesë në gjuhë, thekse rajonale, personazhe dhe domene. Ju mund të shfletoni, filtroni dhe dëgjoni Bibliotekën e plotë të Zërit në mënyrë interaktive në Google AI Studio , ose të bëni pyetje në të në mënyrë programore duke përdorur client.voices.list() ( GET /v1beta/voices , duke përdorur google-genai 2.25.0+ / @google/genai 2.24.0+).

ListVoices kthen zërat tuaj të ruajtur të personalizuar (të renditur më të rinjtë së pari) të ndjekur nga zëra të katalogut të parapërgatitur që përputhen me kriteret tuaja të filtrit. Kur kalohen vlera të shumëfishta për një filtër liste, kthehen zëra që përputhen me çdo vlerë në atë filtër ( OR ), ndërsa parametra të dallueshëm të filtrit kombinohen me AND :

Parametri	Lloji	Përshkrimi
`language_code`	`list[str]`	Etiketa(t) gjuhësore BCP-47 (për shembull, `["en-US", "en-GB"]` ). Përputhje e saktë pa ndjeshmëri ndaj shkronjave të mëdha dhe të mëdha.
`region_code`	`list[str]`	Kodi(et) e rajonit ISO 3166-1 alfa-2 ose UN M.49 (për shembull, `["US", "GB"]` ).
`accent`	`list[str]`	Përshkrues(ë) të theksit rajonal (për shembull, `["American", "British"]` ).
`gender`	`list[str]`	Prezantimi i perceptuar i gjinisë ( `"female"` , `"male"` ose `"neutral"` ).
`pitch`	`list[str]`	Klasifikimi i lartësisë së zërit ( `"low"` , `"medium"` ose `"high"` ).
`persona`	`list[str]`	Personazh vokal ose arketip personazhi (për shembull, `["Warm, Friendly"]` , `["Narrator"]` ).
`contexts` ( `context` në REST)	`list[str]`	Domeni i përdorimit optimal (për shembull, `["Audiobook", "Conversational", "News"]` ).
`type` ( `type_` në Python)	`list[str]`	Filtro sipas burimit të zërit: `"prebuilt"` , `"prompted"` ( Dizajn zëri ) ose `"replicated"` ( Replikim zëri ).
`search`	`str`	Kërkimi i nënvargut me tekst të lirë përputhej pa ndjeshmëri ndaj shkronjave të mëdha dhe të mëdha si me `display_name` ashtu edhe `description` .
`page_size`	`int`	Numri maksimal i zërave të kthyer për faqe (parazgjedhur `50` , maksimumi `1000` ).
`page_token`	`str`	Token nga `response.next_page_token` për të marrë faqen tjetër të rezultateve.

Python

from google import genai

client = genai.Client()

# Filter the Voice Library by language, gender, pitch, domain context, and keyword
response = client.voices.list(
    language_code=["en-US", "en-GB"],
    gender=["female"],
    pitch=["medium", "low"],
    contexts=["Audiobook", "Conversational"],
    type_=["prebuilt"],
    search="warm",
    page_size=50,
)

for voice in response.voices or []:
    print(
        f"{voice.id} | {voice.display_name} ({voice.language_code},"
        f" {voice.accent}, {voice.gender}, pitch={voice.pitch}):"
        f" {voice.description}"
    )

JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI();

// Filter the Voice Library by language, gender, pitch, domain context, and keyword
const response = await ai.voices.list({
  language_code: ["en-US", "en-GB"],
  gender: ["female"],
  pitch: ["medium", "low"],
  contexts: ["Audiobook", "Conversational"],
  type: ["prebuilt"],
  search: "warm",
  page_size: 50,
});

for (const voice of response.voices ?? []) {
  console.log(
    `${voice.id} | ${voice.display_name} (${voice.language_code}, ${voice.accent}, ${voice.gender}, pitch=${voice.pitch}): ${voice.description}`
  );
}

PUSHTIM

curl -G "https://generativelanguage.googleapis.com/v1beta/voices" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  --data-urlencode "language_code=en-US" \
  --data-urlencode "language_code=en-GB" \
  --data-urlencode "gender=female" \
  --data-urlencode "pitch=medium" \
  --data-urlencode "context=Audiobook" \
  --data-urlencode "type=prebuilt" \
  --data-urlencode "search=warm" \
  --data-urlencode "page_size=50"

Gjuhët e mbështetura

Modelet TTS e zbulojnë automatikisht gjuhën e hyrjes. Gemini 3.8 Flash TTS ( gemini-3.8-flash-tts ) mbështet mbi 130 gjuhë , dhe Gemini 3.8 Flash-Lite TTS ( gemini-3.8-flash-lite-tts ) mbështet mbi 100 gjuhë :

Gjuha	TTS me Flash Gemini 3.8	TTS Gemini 3.8 Flash-Lite
Açenisht (shkrimi arab)	✔️	✔️
Afrikanisht	✔️	✔️
Akan	✔️	✔️
Amarike	✔️	✔️
armenisht	✔️	✔️
Asamezisht	✔️	✔️
Awadhi	✔️	✔️
Balinez	✔️	✔️
Banglaisht	✔️	✔️
Banjar (shkrim arab)	✔️	—
Banjar (shkrimi latin)	✔️	✔️
Bashkir	✔️	—
bask	✔️	✔️
Bjellorusisht	✔️	✔️
Bemba	✔️	—
Bhojpuri	✔️	✔️
boshnjak	✔️	✔️
Buginezisht	✔️	✔️
bullgar	✔️	✔️
birmanisht	✔️	—
kantonezisht	✔️	✔️
Katalanisht	✔️	✔️
Cebuanisht	✔️	✔️
Kurdishtja Qendrore	✔️	✔️
Çatisgarhi	✔️	✔️
Kinezisht (shkrimi Hans)	✔️	✔️
Kinezisht (shkrimi Hant)	✔️	✔️
Tatarisht i Krimesë	✔️	—
Kroatisht	✔️	✔️
Çeke	✔️	✔️
danez	✔️	✔️
holandez	✔️	✔️
Dyula	✔️	—
Dzongkha	✔️	—
Arabishtja egjiptiane	✔️	✔️
Anglisht	✔️	✔️
Estonisht	✔️	✔️
Filipinase	✔️	✔️
finlandez	✔️	—
frëngjisht	✔️	✔️
galike	✔️	✔️
Ganda	✔️	✔️
gjeorgjian	✔️	✔️
gjermanisht	✔️	✔️
grek	✔️	✔️
Guarani	✔️	—
Guxharatisht	✔️	✔️
Kreolishtja e Haitit	✔️	✔️
Halh Mongolisht	✔️	✔️
Hausisht	✔️	✔️
Hebraisht	✔️	✔️
Hindisht	✔️	✔️
hungareze	✔️	✔️
Islandeze	✔️	✔️
Igbo	✔️	—
Iloko	✔️	✔️
Indonezisht	✔️	✔️
persisht iranian	✔️	✔️
italiane	✔️	✔️
Japonez	✔️	✔️
Javanisht	✔️	✔️
Kabile	✔️	—
Kamba	✔️	✔️
Kannada	✔️	✔️
Kashmiri (shkrim arab)	✔️	✔️
Kashmiri (shkrimi Deva)	✔️	✔️
Kazake	✔️	✔️
Khmer	✔️	✔️
Kikuyu	✔️	✔️
Kinyarwanda	✔️	✔️
Kongo	✔️	✔️
Koreane	✔️	✔️
kirgizisht	✔️	✔️
Lao	✔️	✔️
Latgalian	✔️	—
Lingala	✔️	✔️
lituanisht	✔️	—
Luksemburgase	✔️	—
maqedonase	✔️	✔️
Magahi	✔️	✔️
Maithili	✔️	✔️
Malajalamisht	✔️	✔️
maltezisht	✔️	✔️
Manipuri	✔️	✔️
Marathi	✔️	✔️
Minangkabau (shkrimi arab)	✔️	✔️
Minangkabau (shkrimi latin)	✔️	—
Mizo	✔️	✔️
Nepalisht (gjuhë individuale)	✔️	✔️
Fulfulde nigeriane	✔️	✔️
Azerbajxhani i Veriut	✔️	✔️
Soto Veriore	✔️	✔️
Uzbekistani Verior	✔️	✔️
Bokmål norvegjez	✔️	✔️
Nynorsk norvegjez	✔️	✔️
Nyanja	✔️	✔️
Oksitanisht	✔️	—
Odia (gjuhë individuale)	✔️	✔️
Pangasinan	✔️	—
Persisht (Afganistan)	✔️	✔️
polak	✔️	✔️
portugalisht	✔️	✔️
Punjabi	✔️	✔️
rumanisht	✔️	✔️
ruse	✔️	✔️
Santali	✔️	✔️
serbisht	✔️	✔️
Sindhi	✔️	—
Sinhalisht	✔️	✔️
Sllovakisht	✔️	✔️
sllovenisht	✔️	—
somalisht	✔️	—
Azerbajxhani Jugor	✔️	✔️
Pashto Jugore	✔️	✔️
Sotho Jugore	✔️	—
Spanjisht	✔️	✔️
Arabishtja standarde (shkrimi arab)	✔️	✔️
Arabishtja standarde (shkrimi latin)	✔️	✔️
Letonishtja standarde	✔️	✔️
Malajishtja standarde	✔️	✔️
Suahili (gjuhë individuale)	✔️	—
Swati	✔️	—
suedeze	✔️	—
Taxhikisht	✔️	—
Tamil	✔️	✔️
Teluguisht	✔️	✔️
Tajlandeze	✔️	—
Tigrinjane	✔️	—
Toskërisht	✔️	—
turk	✔️	✔️
Ujgur	✔️	—
Vietnamez	✔️	✔️

Modelet e mbështetura

Model	Një folës i vetëm	Shumëfolës	Dizajni i zërit	Replikimi i zërit
TTS me shkëndija Binjakët 3.8 ( `gemini-3.8-flash-tts` )	✔️	✔️	✔️	✔️
Gemini 3.8 Flash-Lite TTS ( `gemini-3.8-flash-lite-tts` )	✔️	✔️	✔️	✔️
Pamje paraprake e Gemini 3.1 Flash TTS	✔️	✔️	—	—
TTS për Pamjen e Pamjes së Gemini 2.5 Pro	✔️	✔️	—	—

Kur të përdorni cilin model

Të dy modelet Gemini 3.8 TTS ndajnë të njëjtën skemë API dhe format të sugjerimit, duke ju lejuar të kaloni midis tyre me një ndryshim të vetëm të parametrit:

Përdorni Gemini 3.8 Flash TTS ( gemini-3.8-flash-tts ) kur besnikëria maksimale akustike, aktrimi i nuancuar dhe kontrolli ekspresiv janë përparësia kryesore. Është ideal për punë krijuese në nivel studioje, dialog kompleks me shumë folës, etiketa të rënda vokale-shpërthyese, shqiptime të vështira, dialekte rajonale ose të pakicave dhe rrëfime të gjata që kërkojnë një zë të fortë si shkëmbi dhe stabilitet të tonit të dhomës.
Përdorni Gemini 3.8 Flash-Lite TTS ( gemini-3.8-flash-lite-tts ) si zëvendësimin tuaj të shpejtë dhe me kosto efektive për gemini-3.1-flash-tts-preview . Është i optimizuar për prodhim masiv me volum të lartë, kaskada të agjentëve zanorë bisedorë, veçori leximi me zë të lartë, replikim të besueshëm të zërit dhe të folur të përditshëm nga një folës i vetëm në gjuhët kryesore.

Udhëzues për migrimin

Nëse po migroni nga gemini-3.1-flash-tts-preview ose modele më të hershme Gemini TTS në Gemini 3.8 TTS:

Zhvendosni udhëzimet e nivelit të radhës në speech_metadata : Gemini 3.8 TTS e trajton tekstin e futur në mënyrë strikte si një transkript fjalë për fjalë. Zhvendosni udhëzimet e dhënies së vazhdueshme ( style - si p.sh. "whispering" , "out of breath" ose "speaking slowly" ) dhe etiketat e folësit ( speaker ) në shënimet e strukturuara speech_metadata në vend që të ngulisni udhëzime skenike në tekstin e transkriptit.
Përdorni etiketa me kllapa këndore vetëm për ngjarjet vokale në kohë: Mbani vokalizimet dhe pauzat e çastit jo-folëse në transkript duke përdorur kllapa këndore (si p.sh. <laugh> , <sigh> , <cough> , <breath> ose <short pause> ). Shmangni etiketat e efekteve zanore (si p.sh. duartrokitje ose bum) dhe vendosni stilet e të transmetuarit në speech_metadata.style .
Specifikoni speaker në çdo raund në kërkesat për shumë folës: Çdo raund në një kërkesë për shumë folës duhet të përfshijë në mënyrë të qartë speaker brenda speech_metadata që përputhet me një nga folësit e konfiguruar.
Dizajnoni personazhe që në fillim me dizajnin Voice: Zëvendësoni blloqet shumëparagrafëshe "Audio Profile" ose "Director's Notes" me një zë të personalizuar të krijuar në dizajnin Voice , pastaj përcillni atë ID voice_... përmes kërkesave tuaja TTS me vargje style minimale ose boshe.
Merrni parasysh daljen parazgjedhur WAV ( audio/wav ) në kërkesat unary: Ndryshe nga gemini-3.1-flash-tts-preview dhe modelet e mëparshme TTS (të cilat kthyen audio/l16 të papërpunuar PCM pa kokë si parazgjedhje), Gemini 3.8 TTS kthen audio WAV ( audio/wav ) me një kokë standarde RIFF si parazgjedhje për kërkesat unary.
- Nëse kodi juaj më parë ka mbështjellë bajt PCM të papërpunuar në një kokë WAV (për shembull, duke përdorur modulin wave të Python ose ffmpeg ), hiqni mbështjellësin manual të kokës dhe shkruani bajtet e kthyera direkt në një skedar .wav .
- Nëse tubacioni juaj kërkon PCM të papërpunuar pa kokë, mu-law ose audio A-law, vendosni në mënyrë të qartë response_format.mime_type në "audio/l16" , "audio/mulaw" ose "audio/alaw" (për shembull, {"response_format": {"type": "audio", "mime_type": "audio/l16"}} në Interactions API, ose AUDIO_L16 në generateContent ). Shihni Formatet e daljes audio .

Udhëzues nxitës

Modelet Gemini 3.8 TTS e trajtojnë tekstin e futur në mënyrë strikte si një transkript fjalë për fjalë . Ndryshe nga modelet e mëparshme të parapamjes ku udhëzimet skenike ishin të integruara në tekst të thjeshtë, Gemini 3.8 TTS ndan udhëzimet e qëndrueshme në nivel kthese ( speech_metadata ) nga etiketat vokale të integruara në kohë të caktuar.

Fusha e stilit kundrejt etiketave të brendshme

Ndani udhëzimet e performancës sipas fushëveprimit:

Transmetimi në nivel radhe ( speech_metadata.style ): Vendosni atribute të transmetimit të qëndrueshëm - të tilla si emocioni, prozodia, ritmi i përgjithshëm ose stili i transmetimit (si "whispering" , "out of breath" , "muttering" ose "sarcastic" ) - në fushën e style të speech_metadata . Për të krijuar një personazh dhe performancë të qëndrueshme në të gjitha raundet, dizajnoni personazhin që në fillim në dizajnin e Zërit dhe përdorni style vetëm për ndryshime opsionale në nivel radhe.
Ngjarjet në kohë (etiketat e brendshme): Vendosni shpërthime vokale të çastit jo-folëse, frymëmarrje ose pauza brenda transkriptit duke përdorur kllapa këndore ( <cough> , <breath> , <sigh> , <short pause> ). Përdorni kllapa këndore ( <...> ) për cilësinë më të lartë të audios dhe përqendrohuni te vokalizimet njerëzore në vend të efekteve zanore jo-vokale.

Fushëveprimi	Ku të vendoset	Shembuj
Niveli i kthesës (i qëndrueshëm përgjatë kthesës)	`speech_metadata.style`	`"angry tone"` , `"speaking rapidly"` , `"out of breath"` , `"whispers"` , `"sarcastic"`
Pika në kohë (ndodh në një fjalë specifike)	Inline në `text` ( `<...>` )	`"<cough> Thank you all for coming tonight! <throat-clearing> As I was saying..."`

Ritmi dhe pauzat

Ju mund të kontrolloni ritmin dhe heshtjen në tre nivele të granularitetit:

Pikësimi dhe elipsat: Përdorni presje, viza ( -- ) dhe elipsat ( ... ) për hezitim të natyrshëm në bisedë.
Etiketat e pauzës brenda rreshtit: Vendosni <short pause> ose <long pause> në pikat e sakta në skript ku një folës duhet të bëjë pauzë: text Hold on, let me think... <short pause> Alright, I've got it.
Ritmi në nivel radhe: Vendos "style": "speaking rapidly" ose "style": "speaking slowly" në speech_metadata për të kontrolluar shpejtësinë e të folurit gjatë gjithë raundit.

Prozodi dhe ton

Përdorni speech_metadata.style për të kontrolluar prozodinë, lartësinë dhe infleksin gjatë një kthese (për shembull, "style": "high pitch, cheerful and excited inflection" ose "style": "monotone and flat" ). Nëse emocioni ose prozodia ndryshon në mes të dialogut, ndani skenarin në kthesa të veçanta me vlera të dallueshme style për secilën kthesë.

Theksimi

Shkruaj me shkronjë të madhe fjalë specifike në transkript, të kombinuara me pikësim dhe etiketa vokale brenda rreshtit, për të vendosur theksin natyror vokal mbi fjalët kyçe:

This is a VERY important point!
It was a VERY long day <sigh> ... nobody listens anymore.

Shpërthime vokale dhe tinguj jo-folës

Vendosni vokalizimet jo-folëse njerëzore në rresht duke përdorur kllapa këndore ( <...> ) në pikën e saktë ku duhet të ndodhë tingulli. Etiketat vokale të rekomanduara përfshijnë:

`<argh>`	`<breath>`	`<heavy breath>`	`<exhales>`
`<cackle>`	`<cheer>`	`<chuckle>` / `<chuckles>`	`<cough>`
`<cry>`	`<gasp>`	`<giggle>`	`<groan>`
`<growl>`	`<grunt>`	`<grr>`	`<hiss>`
`<laugh>` / `<laughter>`	`<moan>`	`<pant>`	`<pff>` / `<phew>`
`<scream>`	`<shout>`	`<shriek>`	`<sigh>` / `<sighs>`
`<sneeze>`	`<snicker>`	`<snort>`	`<sob>`
`<throat-clearing>`	`<tsk>`	`<whimper>`	`<whispers>` / `<whispering>`
`<yawn>`	`<short pause>`	`<long pause>`

Kanalet e prapavijës dhe të folurit që mbivendoset

Në dialogun me shumë folës, mbështillni reagimet e dëgjuesve në karaktere tubash ( |reaction| ) brenda radhës së një folësi për të krijuar kanale të prapme natyrale ose të folur të mbivendosur pa u ndarë në një radhë të veçantë për reagim.

Shkëmbime të shkurtra në kanalin e brendshëm: Vendosni reagime të shkurtra të dëgjuesve ( |oh hmm| , |oh really?| , |absolutely| ) brenda radhës së folësit aktiv:
- Radha 1 (Folësi A): "So the launch is Thursday |oh hmm| Are we actually ready?"
- Radha 2 (Folësi B): "Ready enough |oh really?| The last blocker cleared this morning."
- Radha 3 (Folësi A): "Then let's ship it |absolutely| and watch the dashboards."
Të folurit mbivendosës dhe të ndërthurur: Përdorni segmente të shumëfishta tubash për të simuluar të folurit e njëkohshëm ose të ndërthurur midis dy folësve (funksionon më së miri me gemini-3.8-flash-tts ):
- Numërim mbrapsht/refren i njëkohshëm: "Let's surprise him on three |ok| ready?" e ndjekur nga "one. two. three. |happy| happy |birthday| birthday!"
- Mbivendosje e plotë e folësve: "Hello |oh| there |my| it |goodness| must |gracious| be |would| almost |you| time |look| for |at that| dinner"

Konsistenca ndër breza dhe çfarë duhet shmangur

Ndiqni këto udhëzime për të mbajtur identitetin vokal të qëndrueshëm në të gjitha kthesat:

Dizajnoni personazhe që në fillim në dizajnin Voice në vend të blloqeve të gjata stilistike: Paragrafët e gjatë "Audio Profile" dhe "Director's Notes" me shumë pika të mbartura nga modelet e mëparshme janë shkaku më i zakonshëm i ndryshimit të zërit. Përdorni të njëjtën intuitë krijuese që në fillim në dizajnin Voice për të gjeneruar një personazh të personalizuar voice_... të vazhdueshëm, pastaj mbajeni atë ID zëri përmes thirrjeve tuaja TTS.
Mbështetuni te referenca zanore për stabilitet (hiqni meta-udhëzimet): Modelet Gemini 3.8 TTS janë trajnuar të ankorohen së pari te referenca audio. Mos përfshini udhëzime që i thonë modelit ta mbajë zërin të qëndrueshëm (si p.sh. "do not switch speaker identity" ose "maintain identical timbre" ) - teksti shtesë i shpejtë rrit zhvendosjen. Hiqni udhëzimet e panevojshme të stilit dhe lëreni modelin të ndryshojë natyrshëm rreth pikës së qëndrueshme të ofruar nga referenca zanore.
Mos u përpiqni të ndryshoni tiparet e pandryshueshme të folësit në style : Shmangni vendosjen e ndryshimeve të përhershme të moshës, gjinisë, emrave ose theksit në speech_metadata.style . Në vend të kësaj, zgjidhni një zë rajonal nga Biblioteka e Zërit të Zgjeruar ose krijoni një me dizajnin e Zërit .

Rrjedha e rekomanduar e punës

Ndërtoni personazhin një herë: Krijoni personazhin tuaj në Dizajnin e Zërit ose zgjidhni një zë rajonal nga Biblioteka e Zërit të Zgjeruar që përputhet me gjuhën dhe personalitetin tuaj të synuar.
Shkruani transkripte të folura natyrale me rrjedhshmëri të gabuar: Për natyrshmëri maksimale, shkruajeni text si një transkript të folur të vërtetë - duke përfshirë rrjedhshmëritë dhe hezitimet e natyrshme të bisedës (për shembull, "Oh uh yeah I think... hm, so that's interesting" ).
Testoni së pari TTS-në e thjeshtë: Sintetizoni së pari transkriptin tuaj me një fushë bosh style - shumica e kërkesave nuk kanë nevojë fare për udhëzime style .
Shtoni udhëzime të shkurtra style vetëm për ndryshime: Shtoni një varg style konciz (si p.sh. "casual, friendly" ose "muttering, then reassuring" ) vetëm për kthesat që kanë nevojë për një rregullim specifik të ofrimit dhe ripërdoreni atë varg të shkurtër në të gjitha kthesat kur dëshironi një vijë bazë të qëndrueshme.

Agjentë dialogu dhe zëri me shumë kthesa

Kur ndërtoni agjentë zanorë bisedorë në kohë reale ose aplikacione me shumë kthesa:

Bëni një thirrje TTS për çdo raund, ndërsa mbërrijnë pjesë të tekstit LLM.
Lejo që voice i konfiguruar (i parapërgatitur, i projektuar voice_... ose i replikuar voice_... / voicekey_... ) të mbajë identitetin e folësit nëpër raunde - mos e ridërgo kurrë një personazh të gjatë në çdo raund.
Lëreni bosh fushën style për çdo kthesë ose dërgoni një varg të shkurtër konstant (si p.sh. "casual, friendly" ) për të gjithë bisedën.
Ndani përgjigjet e gjata të agjentëve në raunde më të shkurtra në vend që të kërkoni udhëzime më të forta stilistike.

Kufizime

Modelet TTS pranojnë hyrje vetëm me tekst dhe gjenerojnë dalje vetëm me audio.
Gjenerimi i shumëfolësve me një kërkesë të vetme ( speech_config.speakers ) mbështet deri në 2 folës duke përdorur zëra të parapërgatitur. Për të kombinuar zëra të personalizuar ( voice_... ) ose të replikuar ( voice_... / voicekey_... ) në dialog me shumë karaktere, sintetizoni individualisht raundin e secilit folës. Meqenëse kërkesat unary kthejnë audio/wav me një kokë RIFF 44-bajtëshe si parazgjedhje, kërkoni PCM të papërpunuar ( {"type": "audio", "mime_type": "audio/l16"} ) ose hiqni kokën WAV nga secila raund para se të bashkoni kornizat audio PCM 24kHz.
Limitet e ruajtjes së zërit të personalizuar dhe TTL:
- Zëra shtetërorë ( store=True , të nxitur ose të replikuar): Maksimumi 200 zëra për projekt me një TTL (kohëzgjatje jetese) 1-vjeçare .
- Çelësa zanorë pa shtetësi ( store=False , voicekey_... ): TTL (koha e qëndrueshmërisë) 7-ditore .
Rishikoni seksionin Gjuhët e Mbështetura për mbulimin gjuhësor.

Çfarë vjen më pas

Krijoni personazhe vokale të personalizuara nga gjuha natyrore me Dizajnin e Zërit .
Replikoni zërin e një folësi ekzistues në Replikimin e zërit .
Krahasoni specifikimet e modelit në faqet e modeleve Gemini 3.8 Flash TTS dhe Gemini 3.8 Flash-Lite TTS .
Eksploroni audion interaktive dypalëshe me Live API .