xAI Voice (Text zu Sprache)

Folgende Stimmen stehen zur Verfügung. Bei Sprachnamen wird die Groß-/Kleinschreibung nicht beachtet. Beispiel: ara, Ara und ARA werden akzeptiert.

Sie können Text mit der OCI OpenAI-kompatiblen Audio Speech API oder dem WebSocket-Streaming in Sprache konvertieren.

Die OCI OpenAI-kompatible Audio Speech API unterstützt kein Echtzeit-Streaming. Verwenden Sie für das Streaming von Text-zu-Sprache den WebSocket-Endpunkt.

Verwenden Sie die OCI OpenAI-kompatible Audio Speech API, um Audio aus einer einzigen Anforderung zu generieren.

OCI OpenAI-kompatibler Endpunkt

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

Rufen Sie in der Anforderung das Modell xai.grok-tts an, und verwenden Sie eine der in diesem Thema aufgeführten Grok Voice-Stimmen. Verwenden Sie keine OpenAI-Text-zu-Sprache-Modellnamen oder OpenAI-Sprachnamen.

Geben Sie die folgenden Werte in der standardmäßigen OpenAI-kompatiblen Audio-Sprachanforderung an:

• model: xai.grok-tts
• input: Text für die Konvertierung in Sprache
• voice: Eine der unterstützten Grok Voice-Stimmen, wie ara, eve, leo, rex oder sal
• response_format: Audioantwortformat, wie mp3

Setzen Sie xAI-spezifische Optionen, wie language und output_format, in extra_body.

Beispiel: Verwenden Sie extra_body für Einstellungen wie:

• language
• output_format.sample_rate
• output_format.bit_rate

Verwenden Sie WebSocket-Streaming für Echtzeit- oder interaktive Text-zu-Sprache-Workflows. Mit dieser Option senden Sie Text als Nachrichten an den Dienst und empfangen Audio als base64-codierte Audio-Chunks.

OCI WebSocket-Endpunkt:

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

Verwenden Sie den xAI-Endpunkt nicht direkt.

Richten Sie die WebSocket-Verbindung mit xAI-Abfrageparametern für Text-zu-Sprache ein, wie:

Nachdem Sie die WebSocket-Verbindung geöffnet haben, senden Sie Text mit text.delta-Nachrichten. Senden Sie text.done, um das Ende der aktuellen Äußerung anzugeben.

Der Service gibt Folgendes zurück:

Die WebSocket-Verbindung kann nach audio.done geöffnet bleiben, sodass Sie eine weitere text.delta- und text.done-Sequenz senden können, ohne erneut eine Verbindung herzustellen.

Welche Parameter Sie verwenden, hängt von der Zugriffsoption ab.

Verwenden Sie für die OCI OpenAI-kompatible Audio Speech API das OpenAI-kompatible Audio-Sprachanforderungsformat. Setzen Sie model auf xai.grok-tts, verwenden Sie eine unterstützte xAI-Sprache, und legen Sie xAI-spezifische Einstellungen in extra_body ab.

Verwenden Sie für WebSocket-Streaming xAI-Streamingparameter für Text-zu-Sprache. Konfigurieren Sie Sprach-, Sprach-, Codec-, Beispiel- und Bitrate als WebSocket-Abfrageparameter. Senden Sie Text mit text.delta-Nachrichten, und beenden Sie jede Äußerung mit text.done.

Text to Speech unterstützt gängige Audioformate für verschiedene Anwendungsfälle.

Text to Speech unterstützt viele Sprachen. Verwenden Sie einen unterstützten Sprachcode, wie en, oder verwenden Sie auto zur automatischen Spracherkennung, wenn dies von der Zugriffsmethode unterstützt wird.

Die Beschränkung von Text zu Sprache hängt von der Zugriffsoption ab.

Teilen Sie den Inhalt bei längerem Text in logische Segmente wie Absätze oder Sätze auf. Dies hilft, jede Anfrage oder jeden Text-Chunk innerhalb der Zeichengrenze zu halten und erleichtert das Kombinieren der generierten Audiodaten in der richtigen Reihenfolge.

Senden Sie für WebSocket-Streaming Text mit text.delta-Nachrichten, und senden Sie text.done, wenn die aktuelle Äußerung abgeschlossen ist. Jede text.delta-Nachricht muss innerhalb der Zeichenbegrenzung bleiben.

Informationen zu Freigabe- und Abgangsdaten und Ersatzmodelloptionen finden Sie unter Abgangsdatumsangaben für Modelle (On-Demand-Modus).

• Text-to-Speech auf xAI
• Streaming von TTS WebSocket auf xAI
• Text to Speech auf OpenAI

Die folgenden Beispiele zeigen die beiden unterstützten Zugriffsoptionen. Das OCI OpenAI-kompatible Beispiel verwendet den OCI OpenAI-kompatiblen Endpunkt und das xai.grok-tts-Modell. Im WebSocket-Beispiel werden der OCI xAI WebSocket-Endpunkt und die xAI-Streamingparameter verwendet.

OCI OpenAI-kompatible Audio Speech-API

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)

WebSocket-Streaming

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