> ## Documentation Index
> Fetch the complete documentation index at: https://daily-docs-source-analytics-user-turn-strategies.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Ringg AI

> Streaming Speech-to-Text service implementation using Ringg AI

export const CommunityMaintained = ({maintainer, maintainerUrl, repo}) => <Note>
    <strong>Community-maintained integration.</strong> This service is built and
    maintained by{" "}
    <a href={maintainerUrl} target="_blank" rel="noreferrer">
      {maintainer}
    </a>
    . Pipecat does not test or officially support it. Please report issues and
    request changes on the{" "}
    <a href={repo} target="_blank" rel="noreferrer">
      source repository
    </a>
    . Learn more about{" "}
    <a href="/api-reference/server/services/community-integrations">
      community integrations
    </a>
    .
  </Note>;

<CommunityMaintained maintainer="Stonkr" maintainerUrl="https://github.com/Stonkr" repo="https://github.com/Stonkr/pipecat-ringg" />

## Overview

`RinggSTTService` is a streaming Speech-to-Text integration that delegates the
WebSocket connection, handshake, and event parsing to the official
[`ringglabs`](https://pypi.org/project/ringglabs/) Python SDK. It supports
streaming interim and final transcripts, server-side capitalization and
punctuation, and client-driven VAD endpointing by forwarding Pipecat's VAD
frames to the server as `start_speaking` / `stop_speaking` cues.

<CardGroup cols={2}>
  <Card title="Source Repository" icon="github" href="https://github.com/Stonkr/pipecat-ringg">
    Source code, examples, and issues for the Ringg AI integration
  </Card>

  <Card title="Ringg AI" icon="globe" href="https://ringg.ai">
    Learn more about Ringg AI and sign up for an API key
  </Card>

  <Card title="Ringg SDK" icon="cube" href="https://pypi.org/project/ringglabs/">
    The `ringglabs` SDK that powers the integration
  </Card>
</CardGroup>

## Installation

This is a community-maintained package distributed separately from `pipecat-ai`.
It is not yet published to PyPI, so install it directly from GitHub:

```bash theme={null}
# With uv (recommended)
uv pip install git+https://github.com/Stonkr/pipecat-ringg.git

# With pip
pip install git+https://github.com/Stonkr/pipecat-ringg.git
```

<Note>
  A PyPI package (`pip install pipecat-ringg`) will be published after community
  review. See the [source repository](https://github.com/Stonkr/pipecat-ringg)
  for the latest install instructions.
</Note>

## Prerequisites

### Ringg AI Account Setup

Before using the Ringg AI STT service, you need:

1. **Ringg AI Account**: Sign up at [ringg.ai](https://ringg.ai)
2. **API Key**: Get a Ringg AI API key from your account

### Required Environment Variables

* `RINGG_API_KEY`: Your Ringg AI API key for authentication
* `RINGG_BASE_URL` (optional): Override the Ringg API base URL. Leave unset to
  use the SDK default.

## Configuration

### Constructor parameters

<ParamField path="base_url" type="str" default="None">
  Optional override for the Ringg API base URL. Passed through to the SDK; leave
  as `None` to use the SDK default.
</ParamField>

<ParamField path="sample_rate" type="int" default="None">
  Sample rate (Hz) of the audio to be streamed. If not provided, the value is
  taken from the `StartFrame`.
</ParamField>

<ParamField path="params" type="RinggSTTParams" default="None">
  Service configuration parameters. See [Params](#params) below. Defaults are
  used if omitted.
</ParamField>

### Params

Configuration passed via the `params` constructor argument using
`RinggSTTParams(...)`.

| Parameter                  | Type    | Default    | Description                                                                                     |
| -------------------------- | ------- | ---------- | ----------------------------------------------------------------------------------------------- |
| `api_key`                  | `str`   | `""`       | Ringg API key for authentication.                                                               |
| `encoding`                 | `str`   | `"int16"`  | Audio encoding (signed 16-bit PCM).                                                             |
| `language`                 | `str`   | `"hi"`     | Transcription language code.                                                                    |
| `mode`                     | `str`   | `"stream"` | `"on_final"` emits a final transcript on `stop_speaking`; `"stream"` emits interim transcripts. |
| `vad_tail_sil_ms`          | `int`   | `200`      | Trailing silence (ms) for server VAD.                                                           |
| `vad_confidence`           | `float` | `0.55`     | Server VAD confidence threshold (0.0–1.0).                                                      |
| `enable_cap_punc`          | `bool`  | `True`     | Enable server-side capitalization/punctuation.                                                  |
| `accept_client_vad_events` | `bool`  | `True`     | Use client-sent VAD events for endpointing.                                                     |

<Note>
  See the [source repository](https://github.com/Stonkr/pipecat-ringg) for the
  authoritative, up-to-date list of parameters and defaults.
</Note>

## Usage

```python theme={null}
import os

from pipecat.pipeline.pipeline import Pipeline
from pipecat.audio.vad.silero import SileroVADAnalyzer
from pipecat.audio.vad.vad_analyzer import VADParams
from pipecat.processors.audio.vad_processor import VADProcessor

from pipecat_ringg import RinggSTTParams, RinggSTTService

stt = RinggSTTService(
    base_url=os.environ.get("RINGG_BASE_URL"),  # optional
    params=RinggSTTParams(
        api_key=os.environ["RINGG_API_KEY"],
        language="hi",
        mode="on_final",  # "stream" for interim transcripts
    ),
)

# A VADProcessor upstream of the STT service produces the VAD frames the
# service forwards to the server for endpointing.
pipeline = Pipeline([
    transport.input(),
    VADProcessor(vad_analyzer=SileroVADAnalyzer(params=VADParams(confidence=0.55))),
    stt,
    context_aggregator.user(),
    llm,
    tts,
    transport.output(),
    context_aggregator.assistant(),
])
```

See [`example.py`](https://github.com/Stonkr/pipecat-ringg/blob/main/example.py)
in the source repository for a complete, runnable example.

## Compatibility

Tested with Pipecat v1.2.1. Check the [source
repository](https://github.com/Stonkr/pipecat-ringg) for the latest tested
version and changelog.