Bridge a Pipecat Agent

You have a Pipecat bot: a frame pipeline connected to ASR, an LLM, and TTS. You want it to answer real calls over ClutchCall’s QUIC/MoQT transport. Pipecat’s transport seam maps cleanly onto the audio bridge. Caller audio arrives on an uplink track. Agent audio goes back on a downlink track. The bridge is real and shipping. This cookbook connects it to Pipecat by hand.

A packaged adapter now ships. Most readers want that instead. pipecat-telequick provides a first-class Pipecat transport (TeleQuickTransport) over the external-agent QUIC plane, with one pipeline per routed call. See Pipecat + ClutchCall Transport. This cookbook remains the raw MoQT audio-bridge path. Build the glue yourself when you need custom framing, custom mixing, or a runtime that the adapter does not cover.

Skip agents.attach and run the bridge yourself. Ask for pcm16 so that Pipecat gets raw audio. The bridge transcodes the PSTN (G.711) leg for you. This is stock SDK.

TypeScript
Python

import { Voice } from "@clutchcall/sdk/voice";

const v = new Voice({
  baseUrl: "https://engine.clutchcall.dev",
  apiKey:  process.env.CLUTCHCALL_CREDENTIALS!,
  orgId:   "org_abc",
});

const call = await v.calls.originate({
  to: "+15551234567",
  from: "+15558675309",
  trunkId: "trunk_main",
});

// pcm16 @ 16 kHz — the shape most frame pipelines expect.
const bridge = await v.audioBridge.attach(call.sid, {
  codec: "pcm16",
  sampleRate: 16000,
  onUplink: (pcm, tsUs) => pipeline.pushAudio(pcm),   // caller -> your bot
});

pipeline.onAudioOut((pcm) => bridge.publishDownlink(pcm)); // your bot -> caller

import os
from clutchcall.voice import Voice

v = Voice(
    base_url="https://engine.clutchcall.dev",
    api_key=os.environ["CLUTCHCALL_CREDENTIALS"],
    org_id="org_abc",
)

call = v.calls.originate(to="+15551234567", from_="+15558675309", trunk_id="trunk_main")

# pcm16 @ 16 kHz — the shape most frame pipelines expect.
bridge = v.audio_bridge.attach(
    call.sid,
    codec="pcm16",
    sample_rate=16000,
    on_uplink=lambda pcm, ts_us: pipeline.push_audio(pcm),  # caller -> your bot
)

pipeline.on_audio_out(lambda pcm: bridge.publish_downlink(pcm))  # your bot -> caller

Keep the bridge reference alive for the full duration of the call. If the garbage collector removes it, both tracks drop. Always call bridge.close() before call.hangup() so that the tracks close cleanly.

Wrapping the bridge as a Pipecat transport

The bridge above already gives you the two hooks that a Pipecat Transport needs. onUplink produces input frames. publishDownlink consumes output frames. A dedicated transport would wrap those into Pipecat’s input() / output() processors so that the pipeline runs unchanged.

Illustrative — this transport is not shipped. MoqtBridgeTransport below does not exist as a package. It shows the design shape only: what a first-class adapter would wrap around the real audio bridge. Do not pip install it.

# ILLUSTRATIVE — design sketch, not an installable package.
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineTask

# A transport that would wrap ClutchCall's audio bridge:
#   input():  bridge.on_uplink   -> AudioRawFrame (PCM16 @ 16 kHz)
#   output(): AudioRawFrame      -> bridge.publish_downlink
transport = MoqtBridgeTransport(bridge, sample_rate=16000)

pipeline = Pipeline([
    transport.input(),   # caller audio in
    stt,                 # your ASR frame processor
    llm,                 # your LLM context
    tts,                 # your TTS frame processor
    transport.output(),  # agent audio back to the caller
])

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

The adapter’s only real work is the seam that our own runtime already handles:

Resample between Pipecat’s frame rate and the runtime’s 8 kHz PCM16 audio bus.
Keep the room-scoped MoQT namespaces valid.
Carry Opus rather than PCM on browser legs.

None of this work is exotic. It is only not packaged. Today you own the onUplink/publishDownlink glue directly.

What ships today instead of an adapter

WebSocket audio on-ramp
Raw MoQT primitives
VENDOR_BRIDGE (LiveKit/Vapi/Twilio)

Pipecat already speaks WebSocket audio, and ClutchCall accepts a bespoke WebSocket audio sender as a media leg. To use this path:

Point Pipecat’s WebSocket server transport at that on-ramp.
Route the trunk’s inbound rule to your endpoint.
Let the SIP gateway terminate the carrier while Pipecat drives the conversation.

The bot needs no ClutchCall code. This is the same path as migrating a custom WebSocket audio sender.

To use QUIC/MoQT directly rather than a WebSocket leg, treat Pipecat as a custom runtime. The native SDK exposes MoQT publish/subscribe over the QUIC transport. You bind Pipecat’s input()/output() to those primitives. This is the manual version of the sketch above.

Native SDK bindings speak QUIC/MoQT only. They do not carry the browser’s WebSocket/WebRTC fallback leg. Plan for a QUIC-reachable network.

You can want Pipecat only for the pipeline: cascaded ASR → LLM → TTS, turn-taking, and tools. ClutchCall’s runtime already ships that as a configured DAG with transport, telephony, and barge-in built in. To bring only your models via provider credentials is often less work than to port a Pipecat pipeline onto an adapter that does not exist yet.

Pipecat + Transport

The full conceptual framing and the on-ramps that ship today.

Bridge a LiveKit Agent

The vendor-bridge sibling for a LiveKit backend.

Stream to your own ASR

The uplink-subscribe half of the bridge, on its own.

Keep Your Existing Runtime

Adopt only the transport and keep your own agent loop. This is the Pipecat pattern.

Overview

Quickstart

Core Concepts

Build Guides

Agent Runtime

Transport to Web & Apps

Transport to Telephony

CTI (CSTA)

High Availability

Comparison & Benchmarks

Migration

Integrations

Observability

SDK Reference

API Reference

Troubleshooting

Cookbooks

Recipes

Bridge a Pipecat Agent

Wrapping the bridge as a Pipecat transport

What ships today instead of an adapter

Pipecat + Transport

Bridge a LiveKit Agent

Stream to your own ASR

Keep Your Existing Runtime

​The real seam: subscribe uplink, publish downlink

​Wrapping the bridge as a Pipecat transport

​What ships today instead of an adapter

​Related

Pipecat + Transport

Bridge a LiveKit Agent

Stream to your own ASR

Keep Your Existing Runtime

The real seam: subscribe uplink, publish downlink

Wrapping the bridge as a Pipecat transport

What ships today instead of an adapter

Related