xAI Voice (Texto al discurso)

Las siguientes voces están disponibles. Los nombre de voz no distinguen entre mayúsculas y minúsculas. Por ejemplo, se aceptan ara, Ara y ARA.

Puede convertir texto a voz mediante la API de voz de audio compatible con OCI OpenAI o la transmisión de WebSocket.

La API de voz de audio compatible con OpenAI de OCI no admite la transmisión en tiempo real. Para transmitir texto a voz, utilice el punto final de WebSocket.

Utiliza la API de voz de audio compatible con OpenAI de OCI para generar audio a partir de una sola solicitud.

Punto final compatible con OpenAI de OCI

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

En la solicitud, llame al modelo xai.grok-tts y utilice una de las voces de Grok Voice que se muestran en este tema. No utilice nombres de modelo de texto a voz de OpenAI ni nombres de voz de OpenAI.

Especifique estos valores en la solicitud de voz de audio compatible con OpenAI estándar:

• model: xai.grok-tts
• input: texto para convertir a voz
• voice: una de las voces de voz Grok compatibles, como ara, eve, leo, rex o sal
• response_format: formato de respuesta de audio, como mp3

Ponga las opciones específicas de xAI, como language y output_format, en extra_body.

Por ejemplo, utilice extra_body para valores como:

• language
• output_format.sample_rate
• output_format.bit_rate

Utilice la transmisión de WebSocket para flujos de trabajo de texto a voz interactivos o en tiempo real. Con esta opción, se envía texto al servicio como mensajes y se recibe audio como fragmentos de audio codificados en base64.

Punto final de OCI WebSocket:

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

No utilice el punto final de xAI directamente.

Configure la conexión de WebSocket con parámetros de consulta de texto a voz xAI, como:

Después de abrir la conexión WebSocket, envíe texto mediante mensajes text.delta. Envíe text.done para indicar el final de la expresión actual.

El servicio devuelve:

La conexión WebSocket puede permanecer abierta después de audio.done, por lo que puede enviar otra secuencia text.delta y text.done sin volver a conectarse.

Los parámetros que utilice dependerán de la opción de acceso.

Para la API de voz de audio compatible con OpenAI de OCI, utilice el formato de solicitud de voz de audio compatible con OpenAI. Defina model en xai.grok-tts, utilice una voz xAI soportada y coloque la configuración específica de xAI en extra_body.

Para Transmisión de WebSocket, utilice los parámetros de transmisión de texto a voz de xAI. Configure la voz, el idioma, el códec, la frecuencia de muestreo y la velocidad de bits como parámetros de consulta de WebSocket. Envíe texto con mensajes text.delta y finalice cada expresión con text.done.

Text to Speech es compatible con formatos de audio comunes para diferentes casos de uso.

Text to Speech es compatible con muchos idiomas. Utilice un código de idioma soportado, como en, o bien utilice auto para la detección automática de idiomas cuando esté soportado por el método de acceso.

Los límites de texto a voz dependen de la opción de acceso.

Para texto más largo, divida el contenido en segmentos lógicos, como párrafos o frases. Esto ayuda a mantener cada solicitud o fragmento de texto dentro del límite de caracteres y hace que sea más fácil combinar el audio generado en orden.

Para el flujo de WebSocket, envíe texto mediante mensajes text.delta y envíe text.done cuando se complete la expresión actual. Cada mensaje text.delta debe estar dentro del límite de caracteres.

Para conocer las fechas de lanzamiento y baja y las opciones del modelo de sustitución, consulte Model Retirement Dates (On-Demand Mode).

• Texto a voz en xAI
• Streaming TTS WebSocket en xAI
• Texto a voz en OpenAI

Los siguientes ejemplos muestran las dos opciones de acceso admitidas. El ejemplo compatible con OCI OpenAI utiliza el punto final compatible con OCI OpenAI y el modelo xai.grok-tts. El ejemplo de WebSocket utiliza el punto final de WebSocket de OCI xAI y los parámetros de transmisión de xAI.

API de voz de audio compatible con OpenAI de OCI

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)

Transmisión de 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())