xAI Voice (Texto para Fala)

As seguintes vozes estão disponíveis. Nomes de voz não fazem distinção entre maiúsculas e minúsculas. Por exemplo, ara, Ara e ARA são aceitos.

Você pode converter texto em fala usando a API do OCI OpenAI-compatible Audio Speech ou streaming WebSocket.

A API de Áudio Speech compatível com OCI OpenAI não suporta streaming em tempo real. Para streaming de texto para fala, use o ponto final WebSocket.

Use a API de Audio Speech compatível com o OCI OpenAI para gerar áudio de uma única solicitação.

Ponto final compatível com OCI OpenAI

https://inference.generativeai.{region}.oci.oraclecloud.com/openai/v1

Na solicitação, chame o modelo xai.grok-tts e use uma das vozes do Grok Voice listadas neste tópico. Não use nomes de modelo de texto para fala OpenAI ou nomes de voz OpenAI.

Especifique estes valores na solicitação de fala de áudio compatível com OpenAI padrão:

• model: xai.grok-tts
• input: Texto para conversão em fala
• voice: Uma das vozes do Grok Voice suportadas, como ara, eve, leo, rex ou sal
• response_format: Formato de resposta de áudio, como mp3

Coloque opções específicas de xAI, como language e output_format, em extra_body.

Por exemplo, use extra_body para definições como:

• language
• output_format.sample_rate
• output_format.bit_rate

Use o streaming WebSocket para fluxos de trabalho de texto para fala em tempo real ou interativos. Com esta opção, você envia texto para o serviço como mensagens e recebe áudio como partes de áudio codificadas por base64.

Ponto final do OCI WebSocket:

wss://inference.generativeai.{region}.oci.oraclecloud.com/xai/v1/tts

Não use o ponto final xAI diretamente.

Configure a conexão WebSocket com parâmetros de consulta de texto para fala xAI, como:

Depois de abrir a conexão WebSocket, envie texto usando mensagens text.delta. Envie text.done para indicar o fim da declaração atual.

O serviço retorna:

A conexão WebSocket pode permanecer aberta após o audio.done, para que você possa enviar outra sequência text.delta e text.done sem se reconectar.

Os parâmetros que você usa dependem da opção de acesso.

Para a API do OCI OpenAI-compatible Audio Speech, use o formato de solicitação de fala de áudio compatível com OpenAI. Defina model como xai.grok-tts, use uma voz xAI suportada e coloque definições específicas de xAI em extra_body.

Para WebSocket Streaming, use parâmetros de streaming de texto para fala xAI. Configure voz, idioma, codec, taxa de amostragem e taxa de bits como parâmetros de consulta do WebSocket. Envie texto com mensagens text.delta e conclua cada declaração com text.done.

O Text to Speech suporta formatos de áudio comuns para diferentes casos de uso.

O Text to Speech suporta vários idiomas. Use um código de idioma suportado, como en, ou use auto para detecção automática de idioma quando suportado pelo método de acesso.

Os limites de texto para fala dependem da opção de acesso.

Para texto mais longo, divida o conteúdo em segmentos lógicos, como parágrafos ou frases. Isso ajuda a manter cada solicitação ou bloco de texto dentro do limite de caracteres e facilita a combinação do áudio gerado em ordem.

Para streaming do WebSocket, envie texto usando mensagens text.delta e envie text.done quando a declaração atual estiver concluída. Cada mensagem text.delta deve permanecer dentro do limite de caracteres.

Para datas de liberação e baixa e opções de modelo de substituição, consulte Datas de Baixa do Modelo (Modo Sob Demanda).

• Texto para Fala no xAI
• Streaming TTS WebSocket na xAI
• Texto para Fala na OpenAI

Os exemplos a seguir mostram as duas opções de acesso suportadas. O exemplo compatível com OCI OpenAI usa o ponto final compatível com OCI OpenAI e o modelo xai.grok-tts. O exemplo WebSocket usa o ponto final xAI WebSocket da OCI e os parâmetros de streaming xAI.

API de fala de áudio compatível com OCI OpenAI

from openai import OpenAI
from oci_openai import OciSessionAuth

client = OpenAI(
    api_key="<not-used>",
    base_url="https://inference.generativeai.us-chicago-1.oci.oraclecloud.com/openai/v1",
    http_client=httpx.Client(
        auth=OciSessionAuth(profile_name=<profile>),
        headers={"CompartmentId": <compartment_id>}
    ),
)

speech = client.audio.speech.create(
    model="xai.grok-tts",
    input="hello",
    voice="ara",
    response_format="mp3",
    extra_body={
        "language": "en",
        "output_format": {
            "sample_rate": 44100,
            "bit_rate": 192000
        }
    }
)

audio_file = f"output.mp3"
with open(audio_file, "wb") as f:
    f.write(speech.content)

Streaming do WebSocket

import asyncio
import base64
import inspect
import json
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urlencode

import websockets


CONFIG = {
    "endpoint": "wss://inference.generativeai.us-chicago-1.oci.oraclecloud.com/xai/v1/tts",
    "api_key": "<YOUR GENAI API KEY>",
    "text": "Hi, this is an audio sample.",
    "voice": "eve",
    "language": "en",
    "codec": "mp3",
    "sample_rate": 24000,
    "bit_rate": 128000,
    "output_dir": "./",
}


def tts_url():
    params = {
        "language": CONFIG["language"],
        "voice": CONFIG["voice"],
        "codec": CONFIG["codec"],
        "sample_rate": CONFIG["sample_rate"],
    }
    if CONFIG["codec"] == "mp3":
        params["bit_rate"] = CONFIG["bit_rate"]
    return "{}?{}".format(CONFIG["endpoint"], urlencode(params))


def output_file():
    folder = Path(CONFIG["output_dir"]).expanduser()
    folder.mkdir(parents=True, exist_ok=True)
    timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
    return folder / "grok_tts_{}.{}".format(timestamp, CONFIG["codec"])


async def main():
    if CONFIG["api_key"] == "<YOUR GENAI API KEY>":
        raise ValueError("Set api_key before running this sample.")

    path = output_file()
    headers = {"Authorization": "Bearer {}".format(CONFIG["api_key"])}
    header_arg = (
        "additional_headers"
        if "additional_headers" in inspect.signature(websockets.connect).parameters
        else "extra_headers"
    )

    async with websockets.connect(tts_url(), **{header_arg: headers}) as ws:
        await ws.send(json.dumps({"type": "text.delta", "delta": CONFIG["text"]}))
        await ws.send(json.dumps({"type": "text.done"}))

        with open(str(path), "wb") as audio_file:
            async for message in ws:
                event = json.loads(message)
                if event["type"] == "audio.delta":
                    audio_file.write(base64.b64decode(event["delta"]))
                elif event["type"] == "audio.done":
                    print("Saved audio to {}".format(path))
                    break
                elif event["type"] == "error":
                    raise RuntimeError(event.get("message", message))


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