Tradução em tempo real

A tradução em tempo real permite enviar áudio de origem em streaming para uma sessão dedicada à tradução e receber áudio traduzido e atualizações incrementais da transcrição enquanto a pessoa ainda está falando. Use esse recurso para interpretação ao vivo, chamadas multilíngues, transmissões, reuniões, aulas e salas de vídeo.

Use gpt-realtime-translate quando seu aplicativo precisar traduzir o que uma pessoa diz. Se você precisar de um assistente que responda a perguntas, chame ferramentas e gerencie uma conversa, use gpt-realtime-2.1 com uma sessão Realtime padrão.

Como as sessões de tradução se diferenciam

As sessões de tradução em tempo real usam uma arquitetura diferente das sessões de agentes de voz:

A tradução começa a partir do próprio fluxo de áudio. Continue adicionando áudio, incluindo o silêncio entre as frases, e processe os eventos de saída à medida que chegarem.

Escolha um transporte

Use WebRTC quando o navegador capturar ou reproduzir áudio. O WebRTC envia o áudio de origem como uma faixa de mídia e recebe a fala traduzida como uma faixa de áudio remota, para que você não precise reamostrar nem reproduzir trechos PCM manualmente.

Use WebSockets quando seu servidor já receber áudio bruto, como no caso de Twilio Media Streams, mídia SIP, ingestão de transmissões ou um processo de mídia. Com WebSockets, envie áudio PCM16 de 24 kHz codificado em base64 e gerencie a reprodução dos trechos de áudio retornados.

Crie uma sessão WebRTC no navegador

Para aplicativos de navegador, crie um segredo de cliente de curta duração no seu servidor. Não exponha sua chave de API padrão no navegador.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25app.post("/session", async (req, res) => {
  const language = req.body.targetLanguage ?? "es";

  const response = await fetch(
    "https://api.openai.com/v1/realtime/translations/client_secrets",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
        "Content-Type": "application/json",
        "OpenAI-Safety-Identifier": "hashed-user-id",
      },
      body: JSON.stringify({
        session: {
          model: "gpt-realtime-translate",
          audio: {
            output: { language },
          },
        },
      }),
    }
  );

  res.status(response.status).json(await response.json());
});

No navegador, capture o áudio, crie uma conexão entre pares e envie a oferta SDP via POST para o endpoint de chamadas de tradução:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50const { value: clientSecret } = await fetch("/session", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ targetLanguage: "es" }),
}).then((response) => response.json());

const sourceStream = await navigator.mediaDevices.getUserMedia({
  audio: true,
});

const pc = new RTCPeerConnection();
pc.addTrack(sourceStream.getAudioTracks()[0], sourceStream);

const translatedAudio = new Audio();
translatedAudio.autoplay = true;
pc.ontrack = ({ streams }) => {
  translatedAudio.srcObject = streams[0];
};

const events = pc.createDataChannel("oai-events");
events.onmessage = ({ data }) => {
  const event = JSON.parse(data);
  if (event.type === "session.output_transcript.delta") {
    subtitles.textContent += event.delta;
  }
};

const offer = await pc.createOffer();
await pc.setLocalDescription(offer);

const sdpResponse = await fetch(
  "https://api.openai.com/v1/realtime/translations/calls",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${clientSecret}`,
      "Content-Type": "application/sdp",
    },
    body: offer.sdp,
  }
);

if (!sdpResponse.ok) {
  throw new Error(await sdpResponse.text());
}

await pc.setRemoteDescription({
  type: "answer",
  sdp: await sdpResponse.text(),
});

Crie uma sessão WebSocket

Conecte-se ao endpoint dedicado à tradução e selecione o modelo na URL:

Antes de executar este exemplo, instale ws para Node.js, websocket-client para Python ou async-websocket para Ruby (gem install async-websocket).

1
2
3
4
5
6
7
8
9
10
11import WebSocket from "ws";

const ws = new WebSocket(
  "wss://api.openai.com/v1/realtime/translations?model=gpt-realtime-translate",
  {
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "OpenAI-Safety-Identifier": "hashed-user-id",
    },
  }
);

1
2
3
4
5
6
7
8
9
10
11import os
import websocket

ws = websocket.WebSocket()
ws.connect(
    "wss://api.openai.com/v1/realtime/translations?model=gpt-realtime-translate",
    header=[
        f"Authorization: Bearer {os.environ['OPENAI_API_KEY']}",
        "OpenAI-Safety-Identifier: hashed-user-id",
    ],
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21require "async"
require "async/http/endpoint"
require "async/websocket/client"
require "json"

endpoint = Async::HTTP::Endpoint.parse("wss://api.openai.com/v1/realtime/translations?model=gpt-realtime-translate", timeout: 10, alpn_protocols: ["http/1.1"])
headers = {
  "Authorization" => "Bearer #{ENV.fetch("OPENAI_API_KEY")}",
  "OpenAI-Safety-Identifier" => "hashed-user-id"
}
Sync do |task|
  task.with_timeout(120) do
    Async::WebSocket::Client.connect(endpoint, headers: headers) do |connection|
      message = connection.read or raise "Connection closed before session creation"
      event = JSON.parse(message.to_str)
      raise "Expected session.created: #{event}" unless event["type"] == "session.created"

      puts(event.fetch("type"))
    end
  end
end

Para Ruby, insira os trechos de código de configuração e de adição de áudio a seguir dentro do bloco Async::WebSocket::Client.connect, após a verificação de que a sessão foi criada e antes do fim do bloco. Mantenha a conexão aberta enquanto envia áudio e recebe eventos de tradução.

Configure o idioma de destino após a abertura do socket:

1
2
3
4
5
6
7
8
9
10
11
12
13
14ws.on("open", () => {
  ws.send(
    JSON.stringify({
      type: "session.update",
      session: {
        audio: {
          output: {
            language: "es",
          },
        },
      },
    })
  );
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import json

ws.send(
    json.dumps(
        {
            "type": "session.update",
            "session": {
                "audio": {
                    "output": {
                        "language": "es",
                    },
                },
            },
        }
    )
)

1
2connection.write(JSON.generate(type: "session.update", session: { audio: { output: { language: "es" } } }))
connection.flush

Em seguida, adicione áudio continuamente:

1
2
3
4
5
6ws.send(
  JSON.stringify({
    type: "session.input_audio_buffer.append",
    audio: base64Pcm16,
  })
);

1
2
3
4
5
6
7
8ws.send(
    json.dumps(
        {
            "type": "session.input_audio_buffer.append",
            "audio": base64_pcm16,
        }
    )
)

1
2
3
4
5
6
7
8require "base64"

File.open("speech.pcm", "rb") do |audio|
  while (chunk = audio.read(4_800))
    connection.write(JSON.generate(type: "session.input_audio_buffer.append", audio: Base64.strict_encode64(chunk)))
    connection.flush
  end
end

Aguarde os eventos de áudio traduzido e transcrições:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15ws.on("message", (data) => {
  const event = JSON.parse(data.toString());

  if (event.type === "session.output_audio.delta") {
    playPcm16(event.delta);
  }

  if (event.type === "session.output_transcript.delta") {
    process.stdout.write(event.delta);
  }

  if (event.type === "session.input_transcript.delta") {
    updateSourceTranscript(event.delta);
  }
});

1
2
3
4
5
6
7
8
9
10
11while True:
    event = json.loads(ws.recv())

    if event["type"] == "session.output_audio.delta":
        play_pcm16(event["delta"])

    if event["type"] == "session.output_transcript.delta":
        print(event["delta"], end="", flush=True)

    if event["type"] == "session.input_transcript.delta":
        update_source_transcript(event["delta"])

Encerre uma sessão WebSocket

Quando o fluxo de origem terminar, envie um evento session.close antes de fechar o WebSocket. O evento instrui o serviço a processar todo o áudio de entrada pendente, emitir qualquer saída restante de áudio traduzido e transcrição e, em seguida, enviar um evento session.closed. O evento session.close só é compatível com sessões de tradução.

Após enviar session.close, pare de adicionar áudio e continue lendo eventos no seu loop de recebimento normal até receber session.closed. Fechar o socket imediatamente pode causar a perda de saídas traduzidas que a sessão ainda está enviando.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37let translationSessionClosing = false;

function closeTranslationSession() {
  if (translationSessionClosing) {
    return;
  }

  translationSessionClosing = true;
  ws.send(
    JSON.stringify({
      type: "session.close",
    })
  );
}

ws.on("message", (data) => {
  const event = JSON.parse(data.toString());

  if (event.type === "session.output_audio.delta") {
    playPcm16(event.delta);
  }

  if (event.type === "session.output_transcript.delta") {
    process.stdout.write(event.delta);
  }

  if (event.type === "session.input_transcript.delta") {
    updateSourceTranscript(event.delta);
  }

  if (event.type === "session.closed") {
    ws.close();
  }
});

// Call this when the source stream ends.
closeTranslationSession();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30translation_session_closing = False


def close_translation_session():
    global translation_session_closing
    if translation_session_closing:
        return

    translation_session_closing = True
    ws.send(json.dumps({"type": "session.close"}))


# Call this when the source stream ends.
close_translation_session()

while True:
    event = json.loads(ws.recv())

    if event["type"] == "session.output_audio.delta":
        play_pcm16(event["delta"])

    if event["type"] == "session.output_transcript.delta":
        print(event["delta"], end="", flush=True)

    if event["type"] == "session.input_transcript.delta":
        update_source_transcript(event["delta"])

    if event["type"] == "session.closed":
        ws.close()
        break

Implemente a tradução para ouvintes

Use a tradução para ouvintes quando precisar disponibilizar a um público o áudio traduzido de uma única pessoa ou transmissão de origem. Alguns exemplos são transmissões ao vivo, palestras em conferências, webinars, teleconferências de resultados financeiros, aulas expositivas e vídeos.

A arquitetura típica é:

source audio -> translation session -> translated audio + subtitles

Crie uma sessão de tradução para cada idioma de destino. Se a mesma fonte em inglês precisar de saída em espanhol e francês, crie uma sessão de inglês para espanhol e outra de inglês para francês.

Para aplicativos de tradução para ouvintes no navegador, capture o áudio da aba com getDisplayMedia(), envie-o por WebRTC e reproduza a faixa remota de áudio traduzido. Para transmissões em produção, execute a tradução em um processo de mídia no servidor e publique faixas de áudio traduzido ou legendas para os ouvintes.

Implemente a tradução de conversas

Use a tradução de conversas quando dois ou mais participantes se comunicarem em idiomas diferentes. Alguns exemplos são chamadas de suporte, chamadas de vendas, aulas particulares e salas de vídeo.

Mantenha separadas as faixas de áudio dos participantes. Misturar as falas em um único fluxo dificulta a identificação de quem fala, a atribuição de legendas a cada pessoa e o tratamento de falas sobrepostas.

Para uma chamada entre duas pessoas, crie uma sessão de tradução para cada direção:

Caller A audio -> translate into Caller B language -> play to Caller B
Caller B audio -> translate into Caller A language -> play to Caller A

Em salas com grupos, o número de sessões depende dos participantes que estão falando e dos idiomas de destino:

translation sessions ~= active source speaker tracks x distinct target languages

Em salas pequenas, cada ouvinte pode criar componentes auxiliares de tradução no navegador para os participantes remotos cujas falas deseja traduzir. Em salas maiores, use um participante ou processo de mídia no servidor que assine o fluxo de cada falante de origem uma única vez, crie uma sessão de tradução por idioma de destino e republique as faixas traduzidas.

Teste a qualidade e a latência

Teste a tradução com áudio real e revisão bilíngue. Métricas automatizadas podem ajudar, mas não detectarão todos os erros que os usuários percebem.

Teste:

• a qualidade por par de idiomas;
• nomes, números, datas, moedas e números de telefone;
• a terminologia específica do domínio;
• a alternância entre idiomas e conversas que misturam idiomas;
• sotaques, fala rápida e falas sobrepostas;
• a latência até o primeiro áudio traduzido;
• a latência ao final da fala;
• a sincronização das legendas;
• a consistência da voz;
• o comportamento na reconexão.

Se o seu caso de uso depende da exatidão de nomes ou termos do domínio, monte um conjunto de referência antes do lançamento e revise as falhas manualmente.

Lista de verificação para produção

• Escolha WebRTC para mídia no navegador e WebSockets para mídia no servidor.
• Use o endpoint dedicado /v1/realtime/translations.
• Transmita áudio continuamente, incluindo o silêncio entre as frases.
• Use session.close e aguarde session.closed antes de fechar uma sessão WebSocket.
• Mantenha separadas as faixas de áudio de cada participante para a tradução de conversas.
• Use uma sessão por idioma de saída.
• Exiba as transcrições nos idiomas de origem e de destino quando for útil.
• Disponibilize controles para áudio original, áudio traduzido, legendas, silenciamento e volume.
• Exiba os estados de reconexão, atraso e indisponibilidade.
• Monitore a latência separadamente da qualidade da tradução.

Guias relacionados