Rime SDK for Python

Stream speech from a string or async text source with Rime.

Install

Requires Python 3.11 or later. This package is in alpha.

uv add --prerelease=allow rimelabs-sdk
export RIME_API_KEY="your-api-key"

Quick start

Save this as speech.py and run uv run speech.py:

import asyncio
from rimelabs_sdk import Rime

async def main():
    async with Rime() as client:
        async with client.tts.stream("Hello. This is Rime.") as audio:
            with open("speech.pcm", "wb") as output:
                async for chunk in audio:
                    output.write(chunk)
            print(audio.request_id)

asyncio.run(main())

Output is raw mono 24 kHz signed 16-bit little-endian PCM. Configure your player for this format; there is no WAV header.

Stream incoming text

Add this async text source before main() in the quick start:

async def text():
    yield "Hello. "
    yield "This text arrives in separate chunks."

Use client.tts.stream(text()) in the same audio loop. The SDK handles sentence boundaries. Do not await tts.stream(); entering its async context or reading the first chunk starts work.

Configuration

Select Mist v3 with Rime(model="mistv3"). Mist v1 and v2 are not supported.

Client options

Authentication uses bearer tokens over TLS. The SDK does not load .env files.

Custom deployments use Rime(model="coda", endpoint="host:8443"). Omit the scheme and path. TLS is required; the default port is 443. Model defaults still apply.

Synthesis options

Pass these options to client.tts.stream(text, ...):

Audio formats

Both profiles return raw audio without a file header.

Chunks contain complete sample frames, but their sizes vary. Inspect the read-only audio.format.encoding, audio.format.sample_rate, and audio.format.channels.

Timeouts

An overall deadline includes pauses between reads. Disabling it leaves internal connection and progress limits active. Discovery allows at most 10 seconds; a shorter supplied timeout takes precedence.

Discover voices and languages

List voices and languages inside main():

async with Rime(model="mistv3") as client:
    voices = await client.voices.list(language="en")
    languages = await client.languages.list()
    print(voices, languages)

Both return string lists and accept timeout. Omit language to disable filtering.

Errors and cancellation

Replace the quick start's final asyncio.run(main()) to report SDK errors and request IDs:

from rimelabs_sdk import RimeError

try:
    asyncio.run(main())
except RimeError as error:
    print(f"Speech failed: {error}; request_id={error.request_id}")
    raise

Each SDK error inherits from RimeError:

Partial audio can arrive before an error. Output is complete only after successful iteration. Synthesis is not retried automatically.

Keep the stream's async with block to cancel unfinished work on exit. await audio.cancel() stops one operation; await client.close() stops all client work. Both are safe to repeat. A client belongs to one process and event loop. Python task cancellation remains asyncio.CancelledError.

License

The SDK uses the MIT License.