Cómo armar un traductor voz a voz entre 70+ idiomas en 30 minutos con Gemini 3.5 Live Translate

brew install portaudio

python3 -m venv translate-env
source translate-env/bin/activate   # o translate-env\Scripts\activate en Windows
pip install google-genai pyaudio

export GEMINI_API_KEY="tu-api-key-aqui"

import asyncio
import os
from google import genai
from google.genai import types

client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
MODEL = "gemini-3.5-live-translate-preview"

config = types.LiveConnectConfig(
    response_modalities=[types.Modality.AUDIO],
    translation_config=types.TranslationConfig(
        target_language_code="es",
        echo_target_language=True,
    ),
)

async def main():
    async with client.aio.live.connect(model=MODEL, config=config) as session:
        print("✓ Conexión exitosa")
        print(f"  Modelo: {MODEL}")

if __name__ == "__main__":
    asyncio.run(main())

python3 test_conexion.py

import argparse
import asyncio
import os
import struct
import pyaudio
from google import genai
from google.genai import types

# === Configuración global ===
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
MODEL = "gemini-3.5-live-translate-preview"

# Formato de audio (según documentación oficial)
FORMAT = pyaudio.paInt16
CHANNELS = 1
SEND_SAMPLE_RATE = 16000     # micrófono → 16 kHz
RECEIVE_SAMPLE_RATE = 24000  # parlante ← 24 kHz
CHUNK_SIZE = 1600            # 100ms a 16kHz (lo que recomienda la doc)

IDIOMAS_COMUNES = {
    "es":      "Español",
    "en":      "English",
    "pt-BR":   "Português (Brasil)",
    "pt-PT":   "Português (Portugal)",
    "fr":      "Français",
    "de":      "Deutsch",
    "it":      "Italiano",
    "ja":      "日本語",
    "ko":      "한국어",
    "zh-Hans": "中文 (Simplified)",
    "ar":      "العربية",
    "hi":      "हिन्दी",
    "ru":      "Русский",
}


class Traductor:
    def __init__(self, target_language: str):
        self.target_language = target_language
        self.config = types.LiveConnectConfig(
            response_modalities=[types.Modality.AUDIO],
            translation_config=types.TranslationConfig(
                target_language_code=target_language,
                echo_target_language=True,
            ),
            input_audio_transcription=types.AudioTranscriptionConfig(),
            output_audio_transcription=types.AudioTranscriptionConfig(),
        )
        self.audio_a_gemini = asyncio.Queue(maxsize=10)
        self.audio_desde_gemini = asyncio.Queue()
        self.session = None
        self.pya = pyaudio.PyAudio()

    async def captura_microfono(self):
        mic_info = self.pya.get_default_input_device_info()
        print(f"📢 Micrófono: {mic_info['name']}")

        stream = await asyncio.to_thread(
            self.pya.open,
            format=FORMAT, channels=CHANNELS, rate=SEND_SAMPLE_RATE,
            input=True, input_device_index=mic_info["index"],
            frames_per_buffer=CHUNK_SIZE,
        )

        chunk_count = 0
        while True:
            data = await asyncio.to_thread(stream.read, CHUNK_SIZE, exception_on_overflow=False)
            chunk_count += 1
            if chunk_count % 10 == 0:
                samples = struct.unpack(f"{len(data)//2}h", data)
                nivel = sum(abs(s) for s in samples) / len(samples)
                estado = "🔇 silencio" if nivel < 500 else f"🎤 voz (nivel: {int(nivel)})"
                print(f"  {estado}")
            await self.audio_a_gemini.put(data)

    async def envia_a_gemini(self):
        while True:
            chunk = await self.audio_a_gemini.get()
            await self.session.send_realtime_input(
                audio=types.Blob(
                    data=chunk,
                    mime_type=f"audio/pcm;rate={SEND_SAMPLE_RATE}",
                )
            )
            self.audio_a_gemini.task_done()

    async def recibe_de_gemini(self):
        async for response in self.session.receive():
            server_content = response.server_content
            if not server_content:
                continue

            if server_content.model_turn:
                for part in server_content.model_turn.parts:
                    if part.inline_data and isinstance(part.inline_data.data, bytes):
                        self.audio_desde_gemini.put_nowait(part.inline_data.data)

            if server_content.input_transcription and server_content.input_transcription.text:
                lang = server_content.input_transcription.language_code or "?"
                print(f"  🗣️  Oí ({lang}): {server_content.input_transcription.text}", flush=True)

            if server_content.output_transcription and server_content.output_transcription.text:
                lang = server_content.output_transcription.language_code or "?"
                print(f"  💬 Traducción ({lang}): {server_content.output_transcription.text}", flush=True)

    async def reproduce_audio(self):
        stream = await asyncio.to_thread(
            self.pya.open,
            format=FORMAT, channels=CHANNELS, rate=RECEIVE_SAMPLE_RATE, output=True,
        )
        while True:
            audio = await self.audio_desde_gemini.get()
            await asyncio.to_thread(stream.write, audio)

    async def run(self):
        try:
            async with client.aio.live.connect(model=MODEL, config=self.config) as session:
                self.session = session
                print(f"✓ Conectado a {MODEL}. Idioma destino: {self.target_language}")
                print("  Habla normal — Ctrl+C para salir.\n")
                async with asyncio.TaskGroup() as tg:
                    tg.create_task(self.captura_microfono())
                    tg.create_task(self.envia_a_gemini())
                    tg.create_task(self.recibe_de_gemini())
                    tg.create_task(self.reproduce_audio())
        finally:
            self.pya.terminate()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Traductor en vivo voz a voz con Gemini Live Translate.",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""Ejemplos:
  python3 translator.py                 # traduce al español (default)
  python3 translator.py -t en           # traduce al inglés
  python3 translator.py --target pt-BR  # traduce al portugués brasileño
  python3 translator.py -l              # lista idiomas comunes""",
    )
    parser.add_argument("-t", "--target", default="es",
        help="Código BCP-47 del idioma destino (default: es)")
    parser.add_argument("-l", "--list-languages", action="store_true",
        help="Muestra los idiomas más comunes y termina")
    args = parser.parse_args()

    if args.list_languages:
        print("\nIdiomas comunes (códigos BCP-47):\n")
        for codigo, nombre in IDIOMAS_COMUNES.items():
            print(f"  {codigo:<10}  {nombre}")
        print("\nLista completa: https://ai.google.dev/gemini-api/docs/live-api/live-translate#supported-languages")
        exit(0)

    try:
        asyncio.run(Traductor(args.target).run())
    except KeyboardInterrupt:
        print("\nFin.")

# Default: traduce al español
python3 translator.py

# Traducir al inglés
python3 translator.py -t en

# Ver idiomas disponibles
python3 translator.py -l

# Ver ayuda
python3 translator.py -h

✓ Conectado a gemini-3.5-live-translate-preview. Idioma destino: en
  Habla normal — Ctrl+C para salir.

📢 Micrófono: EarPods Microphone
  🔇 silencio
  🎤 voz (nivel: 2456)
  🗣️  Oí (es): Hola, ¿puedes oírme?
  💬 Traducción (en): Hello, can you hear me?