Pipecat integration

Pipecat is a framework for building real-time voice agents. The pipecat-blynt plugin lets you use Blynt as the speech-to-text (STT) service in a Pipecat pipeline, so transcription runs through the Blynt API while the rest of your agent (LLM, TTS, transport) stays unchanged.

Under the hood the plugin opens a deployment-scoped, Bearer-authenticated WebSocket to the Blynt API and drives manual turn-taking from the pipeline's VAD speaking frames.

Install

# Using uv
uv add pipecat-blynt

# Using pip
pip install pipecat-blynt

Configure the STT service

The plugin connects to a Blynt deployment, so you must supply a deployment_id and an api_key. Both can be passed directly or read from the BLYNT_DEPLOYMENT_ID and BLYNT_API_KEY environment variables.

from pipecat_blynt import BlyntSTTService, BlyntSTTOptions

# Pass credentials directly...
stt = BlyntSTTService(
    options=BlyntSTTOptions(
        deployment_id="680989...",  # or set BLYNT_DEPLOYMENT_ID
        api_key="sk-...",           # or set BLYNT_API_KEY
    ),
)

# ...or read both from the environment
stt = BlyntSTTService(options=BlyntSTTOptions())

See Connection and Authentication for more on deployments and API keys.

Set up turn-taking

The Blynt API runs in manual turn-taking mode: the plugin sends start_turn when the user starts speaking and end_turn when they stop. The plugin itself is turn-taking-agnostic and simply reacts to Pipecat's VADUserStartedSpeakingFrame and VADUserStoppedSpeakingFrame. How those frames are produced is up to your pipeline, so Blynt works with any Pipecat turn-taking approach. If nothing produces those frames, no turns are ever sent and you get no transcripts.

At a minimum you need a Voice Activity Detector (VAD). You can optionally layer Pipecat's end-of-utterance (EOU) "Smart Turn" detection on top for more natural turn boundaries. EOU still relies on the VAD underneath, so a VAD/EOU combination is required for the time being.

Voice Activity Detection (Silero)

Use Pipecat's SileroVADAnalyzer and set the end-of-turn delay with VADParams.stop_secs (how long the speaker must stay silent before a turn is considered finished):

from pipecat.audio.vad.silero import SileroVADAnalyzer
from pipecat.audio.vad.vad_analyzer import VADParams
from pipecat.transports.base_transport import TransportParams

transport_params = TransportParams(
    audio_in_enabled=True,
    audio_out_enabled=True,
    # stop_secs=0.75 -> wait 750 ms of silence before ending the turn.
    vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.75)),
)

The VAD requires the silero extra (pipecat-ai[silero]). A shorter stop_secs makes the bot more responsive but risks cutting the speaker off mid-sentence; a longer value is more forgiving but adds latency.

End-of-utterance detection (Smart Turn)

Instead of ending a turn on a fixed silence window, Pipecat's Smart Turn model analyzes the audio to detect when the user has actually finished their thought. It runs alongside the VAD (the VAD detects pauses and Smart Turn decides whether the turn is truly complete), so keep the VAD enabled and add a turn analyzer.

Note: given the ASR processes audio in between VADUserStartedSpeakingFrame and VADUserStoppedSpeakingFrame, it is recommended to use a VAD with a stop_secs of at least 0.5s to avoid splitting the utterance into multiple Blynt decodes.

For instance, it can be used like this:

stt = BlyntSTTService(options=BlyntSTTOptions(language=STTLanguages.FR))

context = LLMContext(messages)  # type: ignore
context_aggregator = LLMContextAggregatorPair(
    context,
    user_params=LLMUserAggregatorParams(
        user_turn_strategies=UserTurnStrategies(
            start=[VADUserTurnStartStrategy()],
            stop=[
                TurnAnalyzerUserTurnStopStrategy(
                    turn_analyzer=LocalSmartTurnAnalyzerV3()
                )
            ],
        ),
        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.7)),
    ),
)

Add it to a pipeline

BlyntSTTService extends Pipecat's WebsocketSTTService, so it drops into any pipeline where an STT service is expected:

from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.task import PipelineTask
from pipecat_blynt import BlyntSTTService, BlyntSTTOptions

stt = BlyntSTTService(
    options=BlyntSTTOptions(
        deployment_id="645...",
        api_key="sk-...",
    )
)

pipeline = Pipeline([
    transport.input(),   # your audio transport (with the VAD configured above)
    stt,                 # Blynt speech-to-text
    # ... LLM, TTS, and other processors
    transport.output(),
])

task = PipelineTask(pipeline)
# run the task with your Pipecat runner

The service emits Pipecat InterimTranscriptionFrames from Blynt's turn_partial events and a TranscriptionFrame from each turn_ended event.

Configuration options

BlyntSTTOptions accepts:

• deployment_id (optional): Blynt deployment id to run the session against. Falls back to the BLYNT_DEPLOYMENT_ID environment variable.
• api_key (optional): Blynt API key for Bearer auth. Falls back to the BLYNT_API_KEY environment variable.

Requirements

• Python >= 3.12
• pipecat-ai >= 0.0.96 (with the silero extra for the VAD)
• websockets >= 14.0
• loguru >= 0.7.0