xAI Voice (texte à la parole)

Les voix suivantes sont disponibles. Les noms vocaux ne distinguent pas les majuscules des minuscules. Par exemple, ara, Ara et ARA sont acceptés.

Vous pouvez convertir du texte en texte vocal à l'aide de l'API Audio Speech compatible avec OCI OpenAI ou de la diffusion en continu de sockets Web.

L'API Audio Speech compatible avec OCI OpenAI ne prend pas en charge la diffusion en temps réel. Pour diffuser du texte dans la synthèse vocale, utilisez l'adresse WebSocket.

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

Adresse 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èles de synthèse vocale ou de noms de voix OpenAI.

Indiquez les valeurs suivantes dans la requête vocale audio standard compatible OpenAI :

• model: xai.grok-tts
• input : texte à convertir en discours
• voice : l'une des voix Grok prises en charge, telle que ara, eve, leo, rex ou sal
• response_format : format de réponse audio, tel que mp3

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

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

• language
• output_format.sample_rate
• output_format.bit_rate

Utilisez WebSocket Streaming pour les workflows 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 codés en base64.

Adresse OCI WebSocket :

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

N'utilisez pas directement l'adresse xAI.

Configurez la connexion WebSocket à l'aide de paramètres de requête de synthèse vocale xAI, tels que :

Après avoir ouvert la connexion WebSocket, envoyez du texte à l'aide de messages text.delta. Envoyez text.done pour indiquer la fin de la variation en cours.

Le service renvoie :

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 Audio Speech compatible avec OCI OpenAI, utilisez le format de demande audio vocale compatible avec OpenAI. Définissez model sur 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 sockets Web, utilisez les paramètres de transmission en continu de texte à parole xAI. Configurez la voix, la langue, le codec, le taux d'échantillonnage et le débit en tant que paramètres de requête WebSocket. Envoyez du texte avec des messages text.delta et terminez chaque variation par 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 du langage lorsque la méthode d'accès le prend en charge.

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

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

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

Pour les dates de déblocage et de sortie et les options de modèle de remplacement, voir Dates de sortie du modèle (mode à la demande).

• du texte à la parole sur xAI
• Socket Web TTS Streaming sur xAI
• du texte à la parole sur OpenAI

Les exemples suivants présentent les deux options d'accès prises en charge. L'exemple compatible avec OCI OpenAI utilise l'adresse compatible avec OCI OpenAI et le modèle xai.grok-tts. L'exemple de socket Web utilise l'adresse de socket Web OCI xAI et les paramètres de transmission en continu xAI.

API audio Speech 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)

Streaming de socket Web

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())