Cómo usar la traducción de voz a voz

La función de traducción de voz a voz usa la IA para interpretar el lenguaje, lo que permite conversaciones entre personas y sistemas que hablan diferentes idiomas. Tu aplicación puede usar esta función para procesar un flujo de audio que contenga voz en un idioma y traducirlo a otro idioma en tiempo real.

A diferencia de otras funciones de la API de Live que admiten conversaciones por turnos, la traducción de voz a voz procesa continuamente la entrada de audio y transmite las siguientes salidas a medida que están disponibles:

  • Transcripción: Es el texto reconocido del flujo de audio de entrada en el idioma original.
  • Traducción: Es el texto traducido al idioma de destino.
  • Audio sintetizado: Es una transmisión de audio del texto traducido que se habla en el idioma de destino y que coincide con la voz del orador original.

Modelos compatibles

Puedes usar la traducción de voz a voz con el siguiente modelo:

Versión del modelo Nivel de disponibilidad
gemini-2.5-flash-s2st-exp-11-2025 Experimental privado

Requisitos de audio de entrada

La traducción de voz a voz solo admite entrada de audio. Para obtener información sobre los formatos de audio, los códecs y las especificaciones compatibles, como la frecuencia de muestreo, consulta Formatos de audio compatibles.

Cómo usar la traducción de voz a voz

Para usar la traducción de voz a voz, consulta los siguientes ejemplos de código:

Python

# Set language_code to your desired language, in this case, Mandarin Chinese.
speech_config = SpeechConfig(language_code="cmn")

config = LiveConnectConfig(
    response_modalities=["AUDIO"],
    speech_config=speech_config,
    input_audio_transcription=input_transcription,
    output_audio_transcription=output_transcription,
)

audio_file = Part.from_uri(file_uri=audio_url, mime_type="audio/mpeg")
contents = [audio_file]

response = client.models.generate_content(model=MODEL_ID, contents=contents)
display(Markdown(response.text))

Python

import asyncio

# Set model generation_config
CONFIG = {
    "response_modalities": ["AUDIO"],
    "speech_config": {
        "language_code": "cmn",
    },
}

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {bearer_token[0]}",
}

# Connect to the server
async with connect(SERVICE_URL, additional_headers=headers) as ws:
    # Setup the session
    await ws.send(
        json.dumps(
            {
                "setup": {
                    "model": MODEL,
                    "generation_config": CONFIG,
                    "input_audio_transcription": {},
                    "output_audio_transcription": {},
                    "enable_speech_to_speech_translation": True,
                }
            }
        )
    )

    # Receive setup response
    raw_response = await ws.recv(decode=False)
    setup_response = json.loads(raw_response.decode("ascii"))
    print(setup_response)

    msg = {
        "realtime_input": {
            "audio": {
                "mime_type": "audio/pcm",
                "data": base64.b64encode(wav_data).decode('utf-8'),
            }
        }
    }

    await ws.send(json.dumps(msg))

    overall_responses = []
    timeout_seconds = 10 # Set timeout to 3 seconds

    # Receive chucks of server response with a timeout
    try:
        while True:
            try:
                raw_response = await asyncio.wait_for(ws.recv(decode=False), timeout_seconds)
                response = json.loads(raw_response.decode())
                server_content = response.pop("serverContent", None)
                if server_content is None:
                    break

                # Input Transcription.
                input_transcription = server_content.pop("inputTranscription", None)
                if input_transcription is not None:
                  raw_text = input_transcription.pop("text", None)
                  if raw_text is not None:
                    display(Markdown(f"**Input >** {raw_text}"))

                # Output Transcription.
                output_transcription = server_content.pop("outputTranscription", None)
                if output_transcription is not None:
                  raw_text = output_transcription.pop("text", None)
                  if raw_text is not None:
                    display(Markdown(f"**Response >** {raw_text}"))

                model_turn = server_content.pop("modelTurn", None)
                if model_turn is not None:
                    parts = model_turn.pop("parts", None)
                    if parts is not None:
                        for part in parts:
                            pcm_data = base64.b64decode(part["inlineData"]["data"])
                            overall_responses.append(np.frombuffer(pcm_data, dtype=np.int16))

                # End of turn
                # turn_complete = server_content.pop("turnComplete", None)
                # if turn_complete:
                #     break
            except asyncio.TimeoutError:
                print(f"Timeout: No response received from the websocket within {timeout_seconds} seconds.")
                if overall_responses:
                  display(Audio(np.concatenate(overall_responses), rate=24000, autoplay=True))
                break # Exit the loop on timeout
            except websockets.exceptions.ConnectionClosed as e:
              print(f"Connection closed by exception, code: {e.code}, reason: {e.reason}")
              if overall_responses:
                display(Audio(np.concatenate(overall_responses), rate=24000, autoplay=True))
              break # Exit the loop on connection closed
            except Exception as e:
              print(f"An unexpected error occurred: {e}")
              if overall_responses:
                display(Audio(np.concatenate(overall_responses), rate=24000, autoplay=True))
              break # Exit the loop on other exceptions

    finally:
        try:
          await ws.close(code=1000, reason="Normal closure") #example close
        except websockets.exceptions.ConnectionClosed as e:
          print(f"Connection closed by exception, code: {e.code}, reason: {e.reason}")
        except Exception as e:
          print(f"An unexpected error occurred: {e}")

Idiomas compatibles

Código de idioma Idioma
aaAfar
abAbjasio
aceAchenés
achacholi
afAfrikaans
akAkan
alzAlur
a.m.Amárico
unaAragonés
arÁrabe
asAsamés
avAvaric
awaAwadhi
ayAimara
azAzerí
baBaskir
balBaluchi
banBalinés
bbcToba
bciBaoulé
beBielorruso
bemBemba
berBereber
bewBetawi
bgBúlgaro
bgcHaryanvi
bhoBhojpuri
biBislama
bmBambara
bnBengalí
boTibetano
alBretón
bsBosnio
btsSimalungun
btxKaro
acCatalán
ceChecheno
cebCebuano
cggChiga
chChamorro
chkChuukés
cmnChino mandarín
cnhChin de Hakha
coCorso
crCree
crhTártaro de Crimea
crsCriollo seychelense
csCheco
cvChuvasio
cyGalés
daDanés
deAlemán
dinDinka
doiDogri
dovNdombe
dvDivehi
dyuDiula
dzDzongkha
eeEwe
elGriego
enInglés
eoEsperanto
esEspañol
etEstonio
euEuskara
faPersa
ffFulah
fiFinlandés
filFilipino
fjFiyiano
foFeroés
fonFon
frFrancés
pelajeFriulano
fyFrisón occidental
dgIrlandés
gaaGa
gdGaélico
glGallego
gnGuaraní
guGuyaratí
gvManés
haHausa
hawHawaiano
heHebreo
hiHindi
hilHiligainón
hmnHmong
hoHiri Motu
hCroata
hrxHunsrik
htHaitiano, criollo haitiano
huHúngaro
hyArmenio
hzHerero
ibaIban
idIndonesio
igIgbo
iloIlocano
esIslandés
itItaliano
iuLenguas inuit
jaJaponés
jamInglés criollo jamaiquino
jvJavanés
kaGeorgiano
kacKachin
kekKekchí
kgCongo
khaKhasi
kiKikuyu
kjKuanyama
kkKazajo
klGroenlandés
kmCamboyano central
knCanarés
koCoreano
kokKonkani
krKanuri
kriKrio
ksCachemir
ktuKituba
kuKurdo
kvKomi
kwCórnico
kyKirguizo
laLatín
lbLuxemburgués
lgluganda
liLimburgués
lijLigur
lmoLombardo
lnLingala
loLaosiano
ltLituano
luLuba-Katanga
luachiluba
luoDholuo
lusMizo
lvLetón
madMadurés
maiMaithili
makMakasar
mamMam
mfecriollo mauriciano
mgMalgache
mhMarshallese
minMinangkabau
mkMacedonio
mlMalayalam
mnMongol
mrMaratí
msMalayo
mtMaltés
mwrMarwari
myBirmano
naNauru
nbbokmal noruego
ndNorth Ndebele
ndcNdau
neNepalí
nuevoNewarí
ngNdonga
nheNáhuatl de la Huasteca oriental
nlHolandés
nnNoruego (Nynorsk)
nrNdebele del sur
nsoPedi
nusNuer
nvNavajo
nyChichewa
ocOccitano
ojOjibwa
omOromo
oOriya
osOsetio
paPunyabí
pagPangasinán
pamPampanga
papPapiamento
plPolaco
psPastún
ptPortugués
quQuechua
rmRomanche
rnKirundi
roRumano
ruRuso
rwKiñaruanda
saSánscrito
sahYakut
se sentóSantali
scSardo
scnSiciliano
sdSindhi
seSami del norte
sgSango
shnShan
siCingalés
skEslovaco
slEsloveno
smSamoano
snShona
soSomalí
sqAlbanés
srSerbio
ssSuazi
stSesoto meridional
suSundanés
svSueco
swSuajili
szlSilesio
taTamil
tcyTulu
teTelugu
tetTetun
tgTayiko
thTailandés
tiTigrinya
tivTiv
TKTurkmeno
tlTagalo
tnSetsuana
aTonga
tpiTok pisin
trTurco
trpKokborok
tsTsonga
ttTártaro
tumTumbuka
twTwi
tyTahitiano
tyvTuvano
udmUdmurto
µgUigur
ukUcraniano
urUrdu
uzUzbeko
veVenda
vecVeneciano
viVietnamita
waValón
guerraSamareño
woWólof
xhXhosa
yiYiddish
yoYoruba
yuaMaya yucateco
yueCantonés
zaChuang
zhChino
zuZulú

Facturación

Como se trata de una función experimental, no se te cobrará por usar la traducción de voz a voz.

Para obtener más información sobre los precios y la facturación, consulta los precios de Vertex AI.