OpenClaw

Pair OpenClaw with Rime TTS to build a Telegram bot that turns text and documents into verbatim readings, spoken summaries, or two-voice podcasts.

Build a Telegram bot that turns pasted text or attached documents into a verbatim reading, spoken summary, or two-voice podcast. OpenClaw handles the assistant workflow and Rime generates the voice note.

The samples compare the same podcast-style reading through the custom Rime skill and OpenClaw’s default TTS:

Rime TTS	Default TTS

The custom skill also presents a selectable Rime voice menu before generating audio.

Prerequisites

To follow this guide, you need:

• OpenClaw
• FFmpeg
• Python 3
• A Rime API key
• A Telegram account

Step 1: Create a Telegram bot and connect it to OpenClaw

This guide uses Telegram as the interface to OpenClaw. You can adapt it to another messaging service.

First, create a new bot using Telegram’s BotFather:

1. Open Telegram and search for @BotFather.
2. Send /newbot and follow the prompts to choose a name and username.
3. BotFather replies with your bot token, which looks like 123456789:ABCdefGHIjklMNOpqrsTUVwxyz.

Add the bot token to ~/.openclaw/.env:

TELEGRAM_BOT_TOKEN=123456789:ABCdefGHIjklMNOpqrsTUVwxyz

Then enable the Telegram plugin in the ~/.openclaw/openclaw.json file:

{
  "plugins": {
    "entries": {
      "telegram": {
        "enabled": true
      }
    }
  }
}

Restart the gateway to pick up the new token:

openclaw gateway restart

Verify the basic text chat functionality by messaging your bot in Telegram. The first time you message the bot, it shows an access not configured message with an access code. Copy the access code and run the following command in your terminal to pair the bot with OpenClaw:

openclaw pairing approve telegram <access-code>

Step 2: Add your Rime API key

OpenClaw reads environment variables from the ~/.openclaw/.env file. Add your Rime API key to it:

RIME_API_KEY=...

Step 3: Disable OpenClaw’s built-in TTS

OpenClaw has a built-in TTS system that the assistant uses by default. Disable it so OpenClaw uses the Rime skill you add in Step 4 instead.

Update your openclaw.json file as follows:

{
  "messages": {
    "tts": {
      "auto": "off",
      "edge": {
        "enabled": false
      }
    }
  },
  "tools": {
    "deny": ["tts"]
  }
}

This configuration:

1. Turns off auto-TTS so the built-in pipeline doesn’t generate audio automatically
2. Disables Edge TTS so it can’t be used as a fallback
3. Denies the built-in tts tool so the LLM can’t call it directly

Step 4: Install the rime-reader skill

The rime-reader skill reads documents aloud in three modes:

• In verbatim mode, it reads the document aloud, word for word, in your chosen voice.
• In summary mode, it summarizes the document’s content in your chosen voice.
• In podcast mode, two AI hosts, each with a different voice, summarize and discuss the content.

Install the rime-reader skill by cloning it from the following repository into your ~/.openclaw/skills/ directory:

git clone https://github.com/rimelabs/rime-reader-openclaw ~/.openclaw/skills/rime-reader

The skill folder contains a single Python script (rime.py) that handles all three modes and a SKILL.md that teaches the LLM how to use it.

~/.openclaw/skills/rime-reader/
├── SKILL.md
└── rime.py

How rime.py works

The script has three modes, driven by the following command-line arguments:

• A file path for document reading
• --text for a single utterance
• --segments for podcast

All three arguments share the same synthesis and encoding pipeline.

Chunking

In verbatim and summary mode, rime.py breaks long text into sentence-aligned chunks of roughly 400 characters so that no single API call is too large.

def chunk_text(text: str, size: int = CHUNK_SIZE) -> list:
    """Split text into sentence-aligned chunks under `size` characters."""
    text = " ".join(text.split())
    sentences = []
    for raw in text.replace("! ", ".\n").replace("? ", ".\n").split(".\n"):
        s = raw.strip()
        if s:
            sentences.append(s if s.endswith((".", "!", "?")) else s + ".")
    chunks, current, current_len = [], [], 0
    for sentence in sentences:
        if current_len + len(sentence) > size and current:
            chunks.append(" ".join(current))
            current, current_len = [sentence], len(sentence)
        else:
            current.append(sentence)
            current_len += len(sentence) + 1
    if current:
        chunks.append(" ".join(current))
    return chunks

Synthesis

The script then sends the chunks to the Rime API, which synthesizes them and returns raw audio bytes.

def synthesize(text, voice, speed, lang, api_key, model="coda"):
    body = {
        "text": text,
        "speaker": voice,
        "modelId": model,
        "samplingRate": SAMPLE_RATE,
        "speedAlpha": speed,
    }
    req = urllib.request.Request(
        "https://users.rime.ai/v1/rime-tts",
        data=json.dumps(body).encode(),
        headers={
            "Authorization": f"Bearer {api_key}",
            "Accept": "audio/L16",
            "Content-Type": "application/json",
        },
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=60) as resp:
        return resp.read()

Stitching

The script concatenates the bytes from each chunk into a single bytearray and generates silence between the chunks.

You can specify a voice for each segment in podcast mode:

silence = generate_silence(args.pause)  # e.g. 0.3s of silent PCM
all_pcm = bytearray()

for seg in segments:
    pcm = synthesize(seg["text"], seg["voice"], ...)
    all_pcm.extend(pcm)
    all_pcm.extend(silence)

Encoding

Then, rime.py encodes the bytearray by making an ffmpeg call that converts the raw audio buffer to OGG Opus, the format that Telegram expects:

def pcm_to_ogg(pcm_data, ogg_path):
    subprocess.run([
        "ffmpeg", "-y",
        "-f", "s16le", "-ar", "48000", "-ac", "1", "-i", pcm_path,
        "-c:a", "libopus", "-b:a", "64k", "-vbr", "on",
        "-application", "voip",
        ogg_path,
    ])

The script prints the output .ogg path to stdout. The LLM reads this and uses it in a MEDIA: directive with [[audio_as_voice]] to deliver it as a Telegram voice note bubble.

Step 5: Register the skill and configure the personality

Enable the skill in ~/.openclaw/openclaw.json:

{
  "skills": {
    "entries": {
      "rime-reader": {
        "enabled": true
      }
    }
  }
}

Personality (SOUL.md)

The ~/.openclaw/workspace/SOUL.md file configures OpenClaw’s agent personality. The LLM reads the file at the start of every session.

Add the Document Reading section below to your SOUL.md file. Without it, the bot skips the rime-reader skill and generates audio using whichever TTS model it finds first. Since you disabled the default TTS model in Step 3, it would fail to generate any audio and fall back to replying in text.

## Document reading

When the user sends a file or pastes text and asks you to read it, you must
follow the `rime-reader` skill workflow exactly. **Do not generate any audio
until both the mode and voice have been confirmed.** There are no exceptions.

**Step 1: ask for the delivery mode.** Only skip if the user's message
contained the exact word "verbatim", "summary", or "podcast":

> How would you like this delivered?
>
> 📖 **Verbatim**: full text
> 📋 **Summary**: concise spoken summary
> 🎙️ **Podcast**: two hosts break it down in a lively conversation

**Step 2: ask for a voice.** For verbatim or summary, ask for one voice. For
podcast, ask for two voices (Host 1 and Host 2). Use exactly this menu:

> Which voice should I use?
>
> 🏛️ **atrium**: steady, polished, confident
> ✨ **lyra**: smooth, expressive, quietly intense
> 🌊 **transom**: deep, resonant, commanding
> 🧊 **parapet**: cool, measured, precise
> 🌿 **fern**: warm, natural, approachable
> 🌑 **thalassa**: rich, textured, distinctive
> 🔩 **truss**: firm, clear, authoritative
> 🔷 **sirius**: crisp, formal, reliable
> 🌒 **eliphas**: smooth, deep, gravitas
> 📐 **lintel**: deliberate, focused, clean
>
> For podcast, reply with two names (e.g. "atrium and fern"), or say "surprise me".

**Step 3: only now** follow the full `rime-reader` skill for normalization,
scripting, and audio generation. Always use `rime.py`; never use another TTS
path.

Step 6: Test the flow

Restart the gateway before testing the document reading flow:

openclaw gateway restart

1. In Telegram, start a fresh session by sending /new to your bot.
2. Send a document or paste text in the chat and ask the bot to read it.
3. The bot asks you to choose a delivery mode: verbatim, summary, or podcast. Choose verbatim.
4. The bot prompts you to pick a voice.
5. After you pick a voice, the bot returns a voice note of your text.

Tuning

SOUL.md drives the bot’s behavior. Edit the file directly, or tell the bot in your Telegram chat to update it for you.

Voice

Set a default voice for your assistant by editing SOUL.md, or by sending the bot a Telegram message: “Use Transom next time.”

You can use any Coda voice: atrium, lyra, transom, parapet, fern, thalassa, truss, sirius, eliphas, lintel, or one of the many others listed on Rime’s Voices page.

Podcast personality

The LLM writes the podcast script before synthesizing it, so you can steer the tone. Try adding a line such as the following to the Document Reading section of your SOUL.md:

For podcast mode, write the script in the style of a late-night talk show:
one host is deadpan and skeptical, the other is wildly enthusiastic. Keep it
punchy: no segment longer than two sentences.

Alternatively, skip editing SOUL.md entirely and tell the bot: “Make the podcast hosts argue like an old married couple.” The LLM will adapt the script on the fly.

Skip the prompts

If you always want the same voice and delivery mode, you can hardcode them in SOUL.md to skip the bot prompts.

For example, you could replace the first two steps with the following instruction:

Default to **summary** mode with the **fern** voice. Only ask if the user
says "let me choose".

Since OpenClaw loads SOUL.md afresh every session, your changes take effect immediately after you send /new in Telegram.