xAI Voice (da testo a voce)

Sono disponibili le seguenti voci. Non viene fatta distinzione tra maiuscole e minuscole nei nomi voce. Ad esempio, ara, Ara e ARA sono accettati.

È possibile convertire il testo in voce utilizzando l'API Audio Speech compatibile con OCI OpenAI o lo streaming WebSocket.

L'API Audio Speech compatibile con OCI OpenAI non supporta lo streaming in tempo reale. Per lo streaming di sintesi vocale, utilizzare l'endpoint WebSocket.

Utilizza l'API Audio Speech compatibile con OCI OpenAI per generare audio da una singola richiesta.

Endpoint compatibile con OCI OpenAI

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

Nella richiesta, chiamare il modello xai.grok-tts e utilizzare una delle voci Grok Voice elencate in questo argomento. Non utilizzare nomi di modello text-to-speech OpenAI o nomi vocali OpenAI.

Specificare questi valori nella richiesta audio speech standard compatibile con OpenAI:

• model: xai.grok-tts
• input: testo da convertire in sintesi vocale
• voice: una delle voci Grok Voice supportate, ad esempio ara, eve, leo, rex o sal
• response_format: formato di risposta audio, ad esempio mp3

Posizionare le opzioni specifiche di xAI, come language e output_format, in extra_body.

Ad esempio, utilizzare extra_body per impostazioni quali:

• language
• output_format.sample_rate
• output_format.bit_rate

Utilizza lo streaming WebSocket per flussi di lavoro text-to-speech in tempo reale o interattivi. Con questa opzione, invii testo al servizio come messaggi e ricevi audio come chunk audio con codifica base64.

Endpoint WebSocket OCI:

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

Non utilizzare direttamente l'endpoint xAI.

Impostare la connessione WebSocket con i parametri di query xAI text-to-speech, ad esempio:

Dopo aver aperto la connessione WebSocket, inviare il testo utilizzando i messaggi text.delta. Inviare text.done per indicare la fine dell'espressione corrente.

Il servizio restituisce:

La connessione WebSocket può rimanere aperta dopo audio.done, quindi è possibile inviare un'altra sequenza text.delta e text.done senza riconnettersi.

I parametri utilizzati dipendono dall'opzione di accesso.

Per l'API Audio Speech di OCI OpenAI, utilizza il formato di richiesta audio speech compatibile con OpenAI. Impostare model su xai.grok-tts, utilizzare una voce xAI supportata e inserire le impostazioni specifiche di xAI in extra_body.

Per lo streaming WebSocket, utilizzare i parametri di streaming text-to-speech xAI. Configura voce, lingua, codec, frequenza di esempio e bit rate come parametri di query WebSocket. Invia il testo con i messaggi text.delta e termina ogni enunciato con text.done.

Text to Speech supporta formati audio comuni per diversi casi d'uso.

Text to Speech supporta molte lingue. Utilizzare un codice lingua supportato, ad esempio en, oppure utilizzare auto per il rilevamento automatico della lingua se supportato dal metodo di accesso.

I limiti da testo a voce dipendono dall'opzione di accesso.

Per testo più lungo, suddividere il contenuto in segmenti logici, ad esempio paragrafi o frasi. Questo aiuta a mantenere ogni richiesta o blocco di testo entro il limite di caratteri e rende più facile combinare l'audio generato in ordine.

Per lo streaming WebSocket, inviare il testo utilizzando i messaggi text.delta e inviare text.done quando l'espressione corrente è completa. Ogni messaggio text.delta deve rimanere entro il limite di caratteri.

Per le date di rilascio e smobilizzo e le opzioni del modello di sostituzione, vedere Date di smobilizzo del modello (modalità su richiesta).

• Testo per la sintesi vocale su xAI
• Streaming di TTS WebSocket su xAI
• Dal testo al parlato su OpenAI

Gli esempi seguenti mostrano le due opzioni di accesso supportate. L'esempio compatibile con OCI OpenAI utilizza l'endpoint compatibile con OCI OpenAI e il modello xai.grok-tts. L'esempio WebSocket utilizza l'endpoint xAI WebSocket OCI e i parametri di streaming xAI.

API Audio Speech compatibile con 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 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())