### Quickstart TTS API Call

Source: https://docs.rumik.ai/muga

This example demonstrates how to generate a .wav audio file using the Muga TTS model via a curl command. Ensure you replace 'rk_live_•••••••••' with your actual API key.

```bash
curl -X POST https://silk-api.rumik.ai/v1/tts \
  -H "Authorization: Bearer rk_live_•••••••••" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muga",
    "text": "[happy] <laugh> Yaar tumne phir wahi joke maara!",
    "temperature": 0.7
  }' \
  --output muga.wav
```

--------------------------------

### Install Rumik AI SDK

Source: https://docs.rumik.ai/sdk/quickstart

Install the core SDK for batch synthesis or with the 'ws' extra for streaming and sessions.

```bash
pip install rumik-ai            # core: batch synthesis
pip install "rumik-ai[ws]"      # + streaming and sessions
```

--------------------------------

### Set up Project and Install Packages

Source: https://docs.rumik.ai/cookbook/voice-agent-pipecat

Create a project folder, set up a virtual environment, and install the necessary Pipecat packages including support for Deepgram, OpenAI, Silero, and the Rumik TTS service.

```bash
mkdir rumik-voice-agent && cd rumik-voice-agent
python -m venv venv
source venv/bin/activate        # windows: venv\Scripts\activate

pip install "pipecat-ai[deepgram,openai,silero]" pipecat-rumik
```

--------------------------------

### Start the Agent Worker

Source: https://docs.rumik.ai/cookbook/voice-agent-livekit

Run this command in your terminal to start the agent worker. This is the first step to get your voice agent running.

```bash
python agent.py dev
```

--------------------------------

### Install livekit-plugins-rumik-ai

Source: https://docs.rumik.ai/livekit

Install the Rumik AI TTS plugin for LiveKit agents using pip.

```bash
pip install livekit-plugins-rumik-ai
```

--------------------------------

### Create Streaming Session Request Example

Source: https://docs.rumik.ai/api-reference/speech/create-a-streaming-session

This example demonstrates the JSON payload for initiating a streaming session. Specify the desired model and the text to be synthesized.

```json
{
  "model": "mulberry",
  "text": "Streaming in real time."
}
```

--------------------------------

### Muga Model Tagging Example

Source: https://docs.rumik.ai/normalization

For the 'muga' model, the tone tag must be at the very start. Normalization preserves tags and <events> without interference.

```text
[excited] Aapko 3400 reward points mile hain, coupon "FEST50" abhi use karo!
```

--------------------------------

### Mulberry Model Text Input Example

Source: https://docs.rumik.ai/api-reference

Example of text input for the 'mulberry' model, requiring a natural-language description for voice generation.

```JSON
{
  "model": "mulberry",
  "text": "Hello, how are you?",
  "description": "a female 30s hindi voice, smooth timbre, conversational pacing, like a podcast host"
}
```

--------------------------------

### Install LiveKit Agents and Plugins

Source: https://docs.rumik.ai/cookbook/voice-agent-livekit

Installs the necessary LiveKit agents packages, including support for Deepgram, OpenAI, Silero, and the Rumik AI TTS plugin.

```bash
mkdir rumik-livekit-agent && cd rumik-livekit-agent
python -m venv venv
source venv/bin/activate        # windows: venv\Scripts\activate

pip install "livekit-agents[deepgram,openai,silero]" livekit-plugins-rumik-ai
```

--------------------------------

### Install Pipecat with LiveKit and other services

Source: https://docs.rumik.ai/cookbook/voice-agent-pipecat-livekit

Installs the necessary Pipecat libraries, including the LiveKit transport and integrations for Deepgram, OpenAI, and Silero.

```bash
pip install "pipecat-ai[livekit,deepgram,openai,silero]" pipecat-rumik
```

--------------------------------

### Muga Model Text Input Example

Source: https://docs.rumik.ai/api-reference

Example of text input for the 'muga' model, including a tone tag for voice steering.

```JSON
{
  "model": "muga",
  "text": "[happy] Namaste! Kaise hain aap?"
}
```

--------------------------------

### Example of Silk Text Normalization

Source: https://docs.rumik.ai/normalization

This example demonstrates how to use Silk's text normalization by quoting a digit-by-digit ID and including currency and dates written naturally. The output shows how Silk speaks these elements.

```bash
curl -X POST https://silk-api.rumik.ai/v1/tts \
  -H "Authorization: Bearer rk_live_•••••••••" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muga",
    "text": "[neutral] Aapka OTP \"482093\" hai. Rs 2,45,600 debit hue 09/03/2025 ko."
  }' --output out.wav
# speaks: "…OTP four eight two zero nine three hai. two lakh forty five thousand six
#          hundred rupees debit hue ninth March two thousand twenty five ko."
```

--------------------------------

### Run the Voice Agent

Source: https://docs.rumik.ai/cookbook/voice-agent-pipecat

Execute the agent script to start the voice agent. This command initiates the process where you can speak into your microphone and hear the agent's response.

```bash
python agent.py
```

--------------------------------

### Muga TTS Quickstart

Source: https://docs.rumik.ai/muga

This snippet demonstrates how to use the Muga TTS API to convert text into speech. It shows a basic POST request to the /v1/tts endpoint with a specified model, text, and temperature, saving the output to a WAV file.

```APIDOC
## POST /v1/tts

### Description
Converts the given text into speech using the specified model and parameters. The output is a WAV audio file.

### Method
POST

### Endpoint
https://silk-api.rumik.ai/v1/tts

### Parameters
#### Request Body
- **model** (string) - Required - The model ID to use for speech synthesis. For this API, it is `muga`.
- **text** (string) - Required - The text to convert to speech. Can include tones like `[happy]` and events like `<laugh>`.
- **temperature** (number) - Optional - Controls the randomness of the speech. Defaults to 0.7.

### Request Example
```json
{
  "model": "muga",
  "text": "[happy] <laugh> Yaar tumne phir wahi joke maara!",
  "temperature": 0.7
}
```

### Response
#### Success Response (200)
- The response body is the raw WAV audio data.

#### Response Example
(Binary audio data saved to muga.wav)
```

--------------------------------

### Install pipecat-rumik

Source: https://docs.rumik.ai/pipecat

Install the pipecat-rumik library using pip. This is the first step to integrating Rumik TTS into your Pipecat pipeline.

```bash
pip install pipecat-rumik
```

--------------------------------

### Mulberry Model with Named Speaker Example

Source: https://docs.rumik.ai/api-reference

Example of text input for the 'mulberry' model, specifying a named speaker and a voice description.

```JSON
{
  "model": "mulberry",
  "text": "Hello, how are you?",
  "description": "a female 30s hindi voice, smooth timbre, conversational pacing, like a podcast host",
  "speaker": "siya"
}
```

--------------------------------

### Install Rumik TTS Skill

Source: https://docs.rumik.ai/agent-skill

Unzip the skill package into your agent's skills directory to install the rumik-tts skill. This makes the 'rumik-tts/' folder available with its documentation and configuration files.

```bash
unzip rumik-tts-skill.zip -d ~/.claude/skills/
```

--------------------------------

### Create and Use a Speech Session

Source: https://docs.rumik.ai/sdk/synthesis

This snippet demonstrates how to create a speech session, send an initial message, and process incoming audio chunks and events. It includes logic for barge-in when the user starts talking.

```python
from rumikai import Rumik, AudioChunk, UtteranceDone

client = Rumik()
with client.speech.session(
    model="mulberry",
    description="a warm 30s female voice, smooth timbre, conversational pacing",
    speaker="ira",
) as session:
    session.send("Hello! How can I help you today?")
    for event in session:
        if isinstance(event, AudioChunk):
            play(event.data)
            if user_started_talking():        # barge-in
                session.interrupt()
                session.send("Sorry, go ahead.")
        elif isinstance(event, UtteranceDone):
            break
```

--------------------------------

### Time Normalization (24h)

Source: https://docs.rumik.ai/normalization

Provides examples for writing and speaking time in 24-hour format.

```text
18:45 · 07:15
```

--------------------------------

### Prompt Anatomy Example

Source: https://docs.rumik.ai/prompting-muga

Illustrates the three core components of a Muga prompt: tone, event, and the spoken words.

```text
[happy]   <laugh>   Yaar tumne phir wahi joke maara!
   │         │                    │
 tone      event              your words
(the mood) (the sound)     (romanised hinglish)
```

--------------------------------

### Send Voice Request using JavaScript

Source: https://docs.rumik.ai/prompting-mulberry

This JavaScript example demonstrates how to send a text-to-speech request using the fetch API. It writes the received audio data to a file named mulberry.wav. Remember to replace the placeholder API key.

```javascript
const resp = await fetch("https://silk-api.rumik.ai/v1/tts", {
  method: "POST",
  headers: {
    Authorization: "Bearer rk_live_•••••••••",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "mulberry",
    text: "आज का episode थोड़ा अलग है।",
    description:
      "a female 30s hindi voice, smooth timbre, conversational pacing, casual register, like a podcast host",
  }),
});
const fs = require("fs");
fs.writeFileSync("mulberry.wav", Buffer.from(await resp.arrayBuffer()));
```

--------------------------------

### LiveKit Agent with Rumik AI TTS

Source: https://docs.rumik.ai/cookbook/voice-agent-livekit

Defines the agent's instructions, configures STT, LLM, TTS (Rumik AI Muga voice), and VAD, and starts the agent session.

```python
from dotenv import load_dotenv

from livekit.agents import Agent, AgentSession, JobContext, WorkerOptions, cli
from livekit.plugins import deepgram, openai, silero, rumik_ai

load_dotenv()

# muga is steered by a [tone] tag, so we tell the LLM to add one
INSTRUCTIONS = """
You write text spoken by the Silk Muga 1 text-to-speech model.

- Output only the final tagged text, no markdown or notes.
- Romanised Hinglish only (Latin script). Never Devanagari.
- Start every reply with one tone tag, as the first token:
  [happy], [excited], [sad], [angry], [neutral], [whisper].
- Keep replies short: 1 to 2 sentences.
"""


async def entrypoint(ctx: JobContext):
    await ctx.connect()

    session = AgentSession(
        stt=deepgram.STT(),
        llm=openai.LLM(model="gpt-4o-mini"),
        tts=rumik_ai.TTS(model="muga"),   # the rumik voice
        vad=silero.VAD.load(),            # detects when you start/stop talking
    )

    await session.start(
        agent=Agent(instructions=INSTRUCTIONS),
        room=ctx.room,
    )


if __name__ == "__main__":
    cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint))
```

--------------------------------

### Mulberry Model Description Example

Source: https://docs.rumik.ai/normalization

The 'mulberry' model uses the 'description' for voice, as it lacks tone tags. Normalization only affects 'text', ensuring the 'description' is passed to the model as written.

```text
Aapka refund Rs 1,899 process ho gaya. Reference "RFN20915" hai.
```

--------------------------------

### System Prompt for LLM Agent

Source: https://docs.rumik.ai/prompting-mulberry

This system prompt guides an LLM to generate voice descriptions and spoken text for the Mulberry text-to-speech model. It specifies the required JSON output format and the attributes to consider for voice descriptions.

```text
You write voice descriptions and spoken text for the silk mulberry 1.5
text-to-speech model.

- "description" is ONE natural sentence describing the voice. Weave 3 to 5
  attributes together; never list them as separate fields.
- Draw attributes from these only: gender (male/female); age (20s/30s/40s);
  accent (e.g. american, british, indian, hindi, punjabi, bengali, south_indian);
  pitch (low/normal/high); timbre (deep, warm, gravelly, smooth, raspy, ...);
  pacing (slow, conversational, fast, ...); emotion (neutral, energetic, excited,
  sad, ...); register (formal, neutral, casual); and an optional role
  (e.g. podcast_host, customer_support_agent, storyteller).
- "text" is the spoken line: Hindi words in Devanagari, English words in Latin.
- You may add inline tags such as <laugh>, <sigh>, <chuckle> inside "text".

Return JSON: { "description": "...", "text": "..." }
```

--------------------------------

### Podcast Host Voice Sample

Source: https://docs.rumik.ai/prompting-mulberry

Example of a female 30s Hindi voice with normal pitch, smooth timbre, conversational pacing, energetic emotion, and casual register, suitable for a podcast host.

```text
a female 30s hindi voice, normal pitch, smooth timbre, conversational pacing, energetic, casual register, like a podcast host.
```

--------------------------------

### Build Pipecat Pipeline with LiveKit Transport

Source: https://docs.rumik.ai/cookbook/voice-agent-pipecat-livekit

Constructs a Pipecat pipeline using LiveKit as the audio transport, integrating Deepgram for STT, OpenAI for LLM, and Rumik for TTS. The system prompt guides the LLM's output.

```python
import os

from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineTask
from pipecat.transports.livekit.transport import LiveKitParams, LiveKitTransport
from pipecat.services.deepgram.stt import DeepgramSTTService
from pipecat.services.openai.llm import OpenAILLMService
from pipecat_rumik import RumikTTSService

# muga is steered by a [tone] tag, so the LLM must add one. give your LLM this
# system prompt (see /prompting-muga).
SYSTEM_PROMPT = "Start every reply with one tone tag ([happy], [sad], ...). Romanised Hinglish, 1-2 sentences."


async def run_agent(url: str, token: str, room_name: str):
    # livekit is ONLY the transport, pipecat owns the pipeline
    transport = LiveKitTransport(
        url=url,
        token=token,
        room_name=room_name,
        params=LiveKitParams(audio_in_enabled=True, audio_out_enabled=True),
    )

    stt = DeepgramSTTService(api_key=os.environ["DEEPGRAM_API_KEY"])
    llm = OpenAILLMService(api_key=os.environ["OPENAI_API_KEY"], model="gpt-4o-mini")
    tts = RumikTTSService(
        api_key=os.environ["RUMIK_API_KEY"],
        gateway_url=os.environ["RUMIK_GATEWAY_URL"],
        settings=RumikTTSService.Settings(model="muga"),
    )

    # livekit in → stt → llm → rumik tts → livekit out
    pipeline = Pipeline([transport.input(), stt, llm, tts, transport.output()])

    await PipelineRunner().run(PipelineTask(pipeline))
```

--------------------------------

### LLM System Prompt for Silk Muga

Source: https://docs.rumik.ai/cookbook/voice-agent-pipecat

Configure the LLM system prompt to ensure output is in Romanised Hinglish, starts with a tone tag, and remains concise. This prompt guides the Silk Muga text-to-speech model.

```text
You write text spoken by the Silk Muga 1 text-to-speech model.

- Output only the final tagged text, no markdown or notes.
- Romanised Hinglish only (Latin script). Never Devanagari.
- Start every paragraph with one tone tag, as the first token:
  [happy], [excited], [sad], [angry], [neutral], [whisper].
- Keep replies short: 1 to 2 sentences.
```

--------------------------------

### Configure Environment Variables

Source: https://docs.rumik.ai/cookbook/voice-agent-livekit

Sets up the .env file with essential API keys and URLs for LiveKit, Rumik AI, Deepgram, and OpenAI.

```env
LIVEKIT_URL=wss://your-project.livekit.cloud
LIVEKIT_API_KEY=•••••••••
LIVEKIT_API_SECRET=•••••••••
RUMIK_API_KEY=rk_live_•••••••••
DEEPGRAM_API_KEY=•••••••••
OPENAI_API_KEY=sk-•••••••••
```

--------------------------------

### Angry Tone Example

Source: https://docs.rumik.ai/prompting-muga

Example of using the angry tone for frustration or blame.

```text
[angry] Tumne phir wahi kiya. Maine kitni baar bola tha aisa mat karo.
```

--------------------------------

### Initialize Client and Synthesize Speech

Source: https://docs.rumik.ai/sdk/introduction

Demonstrates how to initialize the Rumik client and synthesize speech from text, saving the output to a WAV file. The client automatically reads the RUMIK_API_KEY environment variable.

```python
from rumikai import Rumik

client = Rumik()  # reads RUMIK_API_KEY
audio = client.speech.create(text="[happy] Namaste! Kaise hain aap?", model="muga")
audio.save("hello.wav")
```

--------------------------------

### Excited Tone Example

Source: https://docs.rumik.ai/prompting-muga

Example of using the excited tone for wins and surprises.

```text
[excited] <laugh> Bhai sun, abhi abhi pata chala, wo job mil gayi mujhe!
```

--------------------------------

### Neutral Tone Example

Source: https://docs.rumik.ai/prompting-muga

Example of using the neutral tone for facts and confirmations.

```text
[neutral] Aapka order place ho gaya hai. Confirmation SMS bhej diya gaya hai.
```

--------------------------------

### Configure Environment Variables for Services

Source: https://docs.rumik.ai/cookbook/voice-agent-pipecat-livekit

Sets up essential API keys and URLs for LiveKit, Rumik, Deepgram, and OpenAI. Ensure these are kept secure.

```env
LIVEKIT_URL=wss://your-project.livekit.cloud
RUMIK_API_KEY=rk_live_•••••••••
RUMIK_GATEWAY_URL=https://silk-api.rumik.ai
DEEPGRAM_API_KEY=•••••••••
OPENAI_API_KEY=sk-•••••••••
```

--------------------------------

### Whisper Tone Example

Source: https://docs.rumik.ai/prompting-muga

Example of using the whisper tone for secrets or late-night conversations.

```text
[whisper] Phir achanak, kuch khatka hua. Maine darwaza dekha, koi nahi tha.
```

--------------------------------

### Sad Tone Example

Source: https://docs.rumik.ai/prompting-muga

Example of using the sad tone for expressing loss or disappointment.

```text
[sad] <sigh> Yaar, samajh sakti hoon. Itna kuch hua hai, time lagega.
```

--------------------------------

### Happy Tone Example

Source: https://docs.rumik.ai/prompting-muga

Example of using the happy tone for light, casual chat.

```text
[happy] <chuckle> Arre yaar, kitne din baad baat hui! Sab badhiya chal raha hai?
```

--------------------------------

### createStreamingSession

Source: https://docs.rumik.ai/api-reference/speech/create-a-streaming-session

Mints a one-shot WebSocket session for real-time streaming synthesis. It returns a `ws_url` and a `token`. You can then connect to `ws_url?token=<token>`, send a JSON synthesis frame, and receive raw PCM int16 little-endian @ 24 kHz mono binary frames followed by a terminal `{"type":"done"}` JSON frame.

```APIDOC
## POST /v1/tts/ws-connect

### Description
Mints a one-shot WebSocket session for real-time streaming synthesis. Returns a `ws_url` and a `token`. Connect to `ws_url?token=<token>`, send a JSON synthesis frame, then receive raw PCM int16 little-endian @ 24 kHz mono binary frames followed by a terminal `{"type":"done"}` JSON frame.

### Method
POST

### Endpoint
/v1/tts/ws-connect

### Parameters
#### Request Body
- **model** (string) - Optional - Which model to use. Enum: `muga`, `mulberry`. Defaults to `muga`.
- **text** (string) - Required - Text to synthesize. Sent again in the WebSocket synthesis frame.

### Request Example
```json
{
  "model": "mulberry",
  "text": "Streaming in real time."
}
```

### Response
#### Success Response (200)
- **ws_url** (string) - WebSocket URL to connect to.
- **token** (string) - One-shot token. Pass as `?token=<token>` when connecting.

#### Response Example
```json
{
  "ws_url": "wss://silk-api.rumik.ai/v1/tts/ws/abc123",
  "token": "your_one_shot_token"
}
```

### Error Handling
- **401 Unauthorized**: Bearer token missing, invalid, or expired.
- **403 Forbidden**: Key revoked or account disabled.
- **422 ValidationError**: Validation failed. Check the error field.
- **429 RateLimited**: Rate limit hit. See the `Retry-After` header.
- **503 Unavailable**: Upstream temporarily unavailable. Retry shortly.
```

--------------------------------

### Configure Rumik Client with Options

Source: https://docs.rumik.ai/sdk/errors

Initialize the Rumik client with essential configuration parameters like API key, base URL, timeout, and default headers. These settings can be overridden on a per-request basis.

```python
client = Rumik(
    api_key="rk_live_...",              # or RUMIK_API_KEY
    base_url="https://silk-api.rumik.ai",
    timeout=60.0,
    max_retries=2,
    default_headers={"X-App": "my-app"},
)
audio = client.speech.create(text="Hi", extra_headers={"X-Trace-Id": "abc"})
print(audio.request_id)                  # server x-request-id
```

--------------------------------

### Initialize Rumik Client

Source: https://docs.rumik.ai/sdk/api-reference

Instantiate the synchronous `Rumik` client. It can be used as a context manager and supports custom HTTP clients.

```python
Rumik(api_key=None, base_url=None, timeout=60,
      max_retries=2,
default_headers=None, http_client=None)
```

--------------------------------

### Initialize AsyncRumik Client

Source: https://docs.rumik.ai/sdk/api-reference

Instantiate the asynchronous `AsyncRumik` client. It mirrors the synchronous client's interface and also functions as a context manager.

```python
AsyncRumik(api_key=None, base_url=None, timeout=60,
           max_retries=2,
           default_headers=None, http_client=None)
```

--------------------------------

### Initialize RumikTTSService with 'mulberry' model and custom voice

Source: https://docs.rumik.ai/pipecat

Initialize the RumikTTSService for simpler request/response synthesis using the 'mulberry' model. This configuration allows specifying a voice by name and providing a descriptive text for voice generation.

```python
import os
from pipecat_rumik import RumikTTSService

# mulberry: our faster voice, steered by a description + preset speaker
tts = RumikTTSService(
    api_key=os.environ["RUMIK_API_KEY"],
    gateway_url=os.environ["RUMIK_GATEWAY_URL"],
    settings=RumikTTSService.Settings(
        model="mulberry",
        voice="ira",                # sent to Rumik as "speaker"
        description="a warm 30s indian voice, smooth timbre, conversational pacing, like a friendly narrator",
    ),
)
```

--------------------------------

### Percentage Normalization

Source: https://docs.rumik.ai/normalization

Shows the standard format for percentages and how to pronounce them.

```text
25% · 7.5%
```

--------------------------------

### Initialize AgentSession with Rumik TTS

Source: https://docs.rumik.ai/livekit

Integrate the Rumik AI TTS plugin into a LiveKit AgentSession alongside STT and LLM plugins.

```python
from livekit.agents import AgentSession
from livekit.plugins import rumik_ai

# muga: expressive, tone-tagged hinglish
session = AgentSession(
    stt=...,   # your speech-to-text plugin
    llm=...,   # your llm plugin
    tts=rumik_ai.TTS(model="muga"),
)
```

--------------------------------

### Account Number Normalization

Source: https://docs.rumik.ai/normalization

Provides examples for account numbers and how to speak them, often digit by digit.

```text
"000723145589"
```

--------------------------------

### Foreign Currency Normalization

Source: https://docs.rumik.ai/normalization

Provides examples for writing and speaking amounts in different foreign currencies.

```text
$45 · €60 · £12 · ¥5000
```

--------------------------------

### Coupon / Order ID Normalization

Source: https://docs.rumik.ai/normalization

Provides examples for coupon codes or order IDs and their spoken form.

```text
"FEST50" · "TRK44120983"
```

--------------------------------

### GSTIN Normalization

Source: https://docs.rumik.ai/normalization

Provides examples for Goods and Services Tax Identification Numbers (GSTIN) and their spoken form.

```text
"27FGHIJ5678K1Z3"
```

--------------------------------

### Synthesize Speech with Python (Mulberry Model)

Source: https://docs.rumik.ai/quickstart

This Python script shows how to synthesize speech using the 'mulberry' model. It requires a text and a natural-language description for steering the speech, along with an optional named voice. The output is saved as 'mulberry.wav'.

```python
import requests

API_KEY = "rk_live_•••••••••"
BASE = "https://silk-api.rumik.ai"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

# mulberry: steered by a description (+ optional named voice)
r = requests.post(f"{BASE}/v1/tts", headers=HEADERS, json={
    "model": "mulberry",
    "text": "Hi there, how can I help you today?",
    "description": "a warm 30s female voice, smooth timbre, conversational pacing, like a friendly assistant",
    "speaker": "siya",   # optional named voice: siya, ira, adam, emma, …
})
r.raise_for_status()
open("mulberry.wav", "wb").write(r.content)
```

--------------------------------

### Initialize RumikTTSService with 'muga' model

Source: https://docs.rumik.ai/pipecat

Initialize the RumikTTSService for interactive voice agents using the 'muga' model. This service supports interruption-aware, streaming TTS via WebSocket.

```python
import os
from pipecat_rumik import RumikTTSService

# muga: our more expressive voice
tts = RumikTTSService(
    api_key=os.environ["RUMIK_API_KEY"],
    gateway_url=os.environ["RUMIK_GATEWAY_URL"],
    settings=RumikTTSService.Settings(model="muga"),
)
```

--------------------------------

### Storyteller Voice Sample

Source: https://docs.rumik.ai/prompting-mulberry

Example of a female 30s Hindi voice with low pitch, warm timbre, slow pacing, neutral emotion, and casual register, suitable for a storyteller.

```text
a female 30s hindi voice, low pitch, warm timbre, slow pacing, neutral, casual register, like a storyteller.
```

--------------------------------

### Configure Mulberry TTS with Description

Source: https://docs.rumik.ai/livekit

Configure the 'mulberry' TTS model using a natural-language description for voice characteristics.

```python
# mulberry: description-driven voice
tts = rumik_ai.TTS(
    model="mulberry",
    description="a female 30s hindi voice, warm timbre, conversational pacing, like a podcast host",
)
```

--------------------------------

### Narrator Voice Sample

Source: https://docs.rumik.ai/prompting-mulberry

Example of a male 40s British voice with low pitch, gravelly timbre, slow pacing, neutral emotion, and formal register, suitable for a dramatic narrator.

```text
a male 40s british voice, low pitch, gravelly timbre, slow pacing, neutral, formal register, like a dramatic narrator.
```

--------------------------------

### Environment Variables for API Keys

Source: https://docs.rumik.ai/cookbook/voice-agent-pipecat

Store your API keys and gateway URLs in a .env file. Never hard-code sensitive credentials directly in your script.

```bash
RUMIK_API_KEY=rk_live_•••••••••
RUMIK_GATEWAY_URL=https://silk-api.rumik.ai
DEEPGRAM_API_KEY=•••••••••
OPENAI_API_KEY=sk-•••••••••
```

--------------------------------

### Streamer Voice Sample

Source: https://docs.rumik.ai/prompting-mulberry

Example of a male 20s American voice with high pitch, smooth timbre, very fast pacing, excited emotion, and casual register, suitable for a live streamer.

```text
a male 20s american voice, high pitch, smooth timbre, very fast pacing, excited, casual register, like a streamer reacting live.
```

--------------------------------

### client.speech.create

Source: https://docs.rumik.ai/sdk/api-reference

Creates an audio file from the provided text using a specified model. Optional parameters allow for customization of the speech output.

```APIDOC
## client.speech.create

### Description
Creates an audio file from the provided text using a specified model. Optional parameters allow for customization of the speech output.

### Method
```python
client.speech.create(
    text, model="muga", description=None, speaker=None,
    temperature=None, top_p=None, top_k=None, repetition_penalty=None,
    max_new_tokens=None, timeout=None, extra_headers=None,
)

-> Audio
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (Audio)
- `save(path)`: write the audio to a WAV file.
- `__bytes__`: `bytes(audio)` returns the raw bytes.
- `__len__`: `len(audio)` returns the byte count.
- `.is_wav`: whether the bytes include a WAV header.
- `.content_type`: the response content type.
- `.request_id`: the server request id.

#### Response Example
None
```