xAI Voice (Texte à la parole)

Les voix suivantes sont disponibles. Les noms vocaux ne sont pas sensibles à la casse. Par exemple, ara, Ara et ARA sont acceptés.

Vous pouvez convertir du texte en discours à l'aide de l'API de reconnaissance de la parole audio compatible avec OCI OpenAI ou de la diffusion en continu WebSocket.

L'API de reconnaissance de la parole audio compatible avec OCI OpenAI ne prend pas en charge la diffusion en continu en temps réel. Pour diffuser du texte à la parole en continu, utilisez le point d'extrémité WebSocket.

Utilisez l'API de reconnaissance de la parole audio compatible avec OCI OpenAI pour générer de l'audio à partir d'une seule demande.

Point d'extrémité compatible avec OCI OpenAI

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

Dans la demande, appelez le modèle xai.grok-tts et utilisez l'une des voix Grok Voice répertoriées dans cette rubrique. N'utilisez pas de noms de modèle de synthèse vocale OpenAI ou de noms vocaux OpenAI.

Spécifiez ces valeurs dans la demande de parole audio compatible OpenAI standard :

• model: xai.grok-tts
• input : Texte à convertir en parole
• voice : Une des voix vocales Grok prises en charge, par exemple ara, eve, leo, rex ou sal
• response_format : Format de réponse audio, par exemple mp3

Placez les options propres à xAI, telles que language et output_format, dans extra_body.

Par exemple, utilisez extra_body pour les paramètres tels que :

• language
• output_format.sample_rate
• output_format.bit_rate

Utilisez la diffusion en continu WebSocket pour les flux de travail de synthèse vocale en temps réel ou interactifs. Avec cette option, vous envoyez du texte au service sous forme de messages et recevez de l'audio sous forme de blocs audio encodés en base64.

Point d'extrémité OCI WebSocket :

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

N'utilisez pas le point d'extrémité xAI directement.

Configurez la connexion WebSocket avec des paramètres d'interrogation de synthèse vocale xAI tels que :

Après avoir ouvert la connexion WebSocket, envoyez du texte à l'aide de messages text.delta. Envoyer text.done pour indiquer la fin de l'énoncé courant.

Le service retourne :

La connexion WebSocket peut rester ouverte après audio.done. Vous pouvez donc envoyer une autre séquence text.delta et text.done sans vous reconnecter.

Les paramètres que vous utilisez dépendent de l'option d'accès.

Pour l'API de reconnaissance de la parole audio compatible OCI OpenAI, utilisez le format de demande de parole audio compatible OpenAI. Réglez model à xai.grok-tts, utilisez une voix xAI prise en charge et placez les paramètres propres à xAI dans extra_body.

Pour la diffusion en continu de WebSocket, utilisez les paramètres de diffusion de texte à parole xAI. Configurez la voix, le langage, le codec, le taux d'échantillonnage et le débit binaire en tant que paramètres d'interrogation WebSocket. Envoyez du texte avec des messages text.delta et terminez chaque énoncé avec text.done.

Text to Speech prend en charge les formats audio courants pour différents cas d'utilisation.

Text to Speech prend en charge de nombreuses langues. Utilisez un code de langue pris en charge, tel que en, ou utilisez auto pour la détection automatique de langue lorsqu'il est pris en charge par la méthode d'accès.

Les limites de texte à parole dépendent de l'option d'accès.

Pour un texte plus long, fractionnez le contenu en segments logiques, tels que des paragraphes ou des phrases. Cela permet de maintenir chaque requête ou fragment de texte dans la limite des caractères et facilite la combinaison de l'audio généré dans l'ordre.

Pour la diffusion en continu de WebSocket, envoyez du texte à l'aide de messages text.delta et envoyez text.done lorsque l'énoncé courant est terminé. Chaque message text.delta doit rester dans la limite de caractères.

Pour les dates de lancement et de mise hors service et les options de modèle de remplacement, voir : Dates de mise hors service de modèle (mode sur demande).

• Text to Speech sur xAI
• Diffusion en continu de TTS WebSocket sur xAI
• Text to Speech sur OpenAI

Les exemples suivants montrent les deux options d'accès prises en charge. L'exemple compatible OCI OpenAI utilise le point d'extrémité compatible OCI OpenAI et le modèle xai.grok-tts. L'exemple WebSocket utilise le point d'extrémité xAI WebSocket pour OCI et les paramètres de diffusion en continu xAI.

API de reconnaissance de la parole audio compatible avec 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)

Diffusion en continu 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())