Pipecat integration guide

Keep your Pipecat bot where it runs and route its speech to text and text to speech through SLNG. You can also route the language model through the SLNG Context Router. Your transport, VAD, turn-taking, prompts, tools, and pipeline order stay as they are. The SLNG Pipecat services stream STT and TTS over WebSocket. Use them for interactive agents that need low latency and mid-utterance interruption. There are two ways to make the change. Copy the prompt the dashboard builds for your coding agent, or make the edits yourself.

Prerequisites

A running Pipecat bot with Python 3.11 or later, on pipecat-ai>=1.12.0 and pipecat-slng 0.7.
A project created under Improve my agent > Pipecat, and an API key from its Project Vault. Set up a project for your own code walks through it, including which of the four configurations to pick.
The project’s region code, such as eu-north. The key works in that region only.

Starting fresh, or want a known-good reference? The Pipecat templates are complete bots for each LLM option below, with a smoke.py that runs one spoken turn without a microphone.

Choose your LLM option

Speech runs the same way in every option. Only the language model changes:

Option	The LLM	Key	Template
Your LLM	Pipecat’s `OpenAILLMService` on your provider key, with no router	Any SLNG key	`speech.py`
Context Router, project model	The model chosen in the project’s Think section	Project key	`speech_router.py`
Context Router, inline BYOK	Your model and provider key, sent in `slng_config`	Project key	`speech_router_byok.py`

Use a coding agent

The project builds a migration prompt from your Listen, Think, and Speak choices.

Copy the prompt

Click Integrate in the top right, then Copy prompt in the modal. Hand it to your coding agent. It installs the pipecat-migration skill and applies the changes to your bot.

The Integrate button in the top right of the project — Click Integrate in the top right.

The shared Integrate modal with a Copy prompt button — Copy the generated prompt.

The screenshots show the shared dashboard controls. The prompt content is generated for the platform you selected.

Example prompt

Your model IDs, voice, language, and region come from what you picked.

# Migrate this Pipecat bot to SLNG-hosted STT/TTS and the SLNG Context Router

Use the SLNG `pipecat-migration` skill to replace speech to text and text
to speech with `SlngSTTService` and `SlngTTSService` from `pipecat-slng`.
Replace the LLM with Pipecat's `OpenAILLMService` pointed at the SLNG Context
Router using `bedrock-mantle/nvidia.nemotron-nano-3-30b:latest`.

## Install the skill
```bash
npx skills add slng-ai/skills pipecat-migration
```

## Selected stack
- STT: `soniox/speech-ai:rt-v5`
- TTS: `slng/fish/tts:s2.1-pro`
- Voice: `1258154bb41540c7b9dc0d10cd6704bf`
- Language: English (`en`)
- Region: Germany, via `world_part="eu-west"`
- LLM: SLNG Context Router, model `bedrock-mantle/nvidia.nemotron-nano-3-30b:latest` at `https://eu-west.context-router.slng.ai/v1`

## Instructions for the coding agent
1. Discover the entrypoint, package manager, environment loading, and
   current STT, TTS, and LLM wiring before editing. Do not assume file
   names.
2. Establish a rollback point with a clean git tree.
3. Validate `SLNG_API_KEY` without printing it.
4. Install `pipecat-slng` and import-probe
   `from pipecat_slng import SlngSTTService, SlngTTSService`.
5. Replace only the STT and TTS constructors that feed `Pipeline([...])`.
   Keep the transport, VAD, context aggregators, and pipeline order
   intact.
6. Point `OpenAILLMService` at the SLNG Context Router endpoint.
7. Never inline API keys. Use stable agent and session identifiers in
   request headers, then verify one spoken turn from STT through the LLM
   to TTS.

Model routes and regions

Model IDs use the provider/model:variant format, and the slng/ prefix selects an SLNG-hosted model. Models differ by region, so check models by region before you pick one. For model identifiers, BYOK with provider_key, and region routing, see the Pipecat plugin reference.

Edit the code yourself

The removed lines below depend on your current providers, so match them to your code.

Install the plugin

Use your project’s package manager.

uv add "pipecat-ai[openai,runner,silero,webrtc]~=1.12.0" "pipecat-slng>=0.7.0,<0.8"

Set the environment

Set the project key and region, and a stable agent ID. OPENAI_API_KEY is for the Your LLM and inline BYOK options.

.env

SLNG_API_KEY=slng_...
SLNG_REGION=eu-north
SLNG_AGENT_ID=wayne-concierge-v1
OPENAI_API_KEY=sk-...

Point STT and TTS at SLNG

Import the SLNG services and swap only the two constructors that feed Pipeline([...]). world_part pins the region, and the two external_* IDs tie each call’s speech usage to your agent and call.

+ import os
- from pipecat.services.deepgram.stt import DeepgramSTTService
- from pipecat.services.cartesia.tts import CartesiaTTSService
+ from pipecat_slng import SlngSTTService, SlngTTSService

- stt = DeepgramSTTService(
-     api_key=os.environ["DEEPGRAM_API_KEY"],
-     settings=DeepgramSTTService.Settings(model="nova-3"),
- )
- tts = CartesiaTTSService(
-     api_key=os.environ["CARTESIA_API_KEY"],
-     settings=CartesiaTTSService.Settings(voice="<your voice>"),
- )
+ stt = SlngSTTService(
+     api_key=os.environ["SLNG_API_KEY"],
+     world_part=REGION,  # the project's region, such as "eu-north"
+     model="soniox/speech-ai:rt-v5",
+     language=Language.EN,
+     external_agent_id=AGENT_ID,
+     external_session_id=session_id,
+ )
+ tts = SlngTTSService(
+     api_key=os.environ["SLNG_API_KEY"],
+     world_part=REGION,
+     model="slng/fish/tts:s2.1-pro",
+     voice="9a9cf47702da476aa4629e2506d4a857",  # Fish Audio reference_id
+     language=Language.EN,
+     external_agent_id=AGENT_ID,
+     external_session_id=session_id,
+ )

Each service takes its own world_part. Keep both on the project’s region.

Set up the LLM

Pick the tab for your option. Both router options send the agent and session IDs in default_headers. Pipecat passes settings.extra to the OpenAI client’s create(), so the router’s own body fields go inside extra_body, with this call’s template variables. The next step builds INSTRUCTIONS and variables.

Your LLM
Context Router
Context Router, inline BYOK

Keep Pipecat’s OpenAI service on your own key. The LLM step skips the Context Router.

from pipecat.services.openai.llm import OpenAILLMService

llm = OpenAILLMService(
    api_key=os.environ["OPENAI_API_KEY"],
    settings=OpenAILLMService.Settings(
        model="gpt-5.6-luna",
        system_instruction="You are the front desk of Wayne Enterprises.",
    ),
)

The router answers with the model chosen in the project’s Think section. slng/auto selects it.

from pipecat.services.openai.llm import OpenAILLMService

llm = OpenAILLMService(
    api_key=os.environ["SLNG_API_KEY"],
    base_url=f"https://{REGION}.context-router.slng.ai/v1",
    default_headers={
        "X-Slng-Agent-Id": AGENT_ID,  # cache scope
        "X-Slng-Session-Id": session_id,  # one per call
    },
    settings=OpenAILLMService.Settings(
        model="slng/auto",
        system_instruction=INSTRUCTIONS,
        extra={"extra_body": {"template_variables": variables}},  # this call's values
    ),
)

Every request carries your model and provider key in slng_config. Nothing to set in Think. The model is named once, in slng_config: the request asks for slng/auto, and the router picks from the config it carries.

from pipecat.services.openai.llm import OpenAILLMService

MODEL = "gpt-5.6-luna"


def router_config() -> dict:
    """Return the router config each request carries: one model, on your OpenAI key."""
    endpoint = {
        "provider": "openai-compat",
        "url": "https://api.openai.com/v1",
        "api_key": os.environ["OPENAI_API_KEY"],  # your provider key
    }
    entry = {
        "model": MODEL,  # the only place the model is named
        "weight": 100,
        "endpoint": endpoint,
        # Request settings for this model. Drop it for a model without reasoning.
        "kwargs": {"reasoning_effort": "none"},
    }
    return {"tiers": {"1": [entry]}}


llm = OpenAILLMService(
    api_key=os.environ["SLNG_API_KEY"],
    base_url=f"https://{REGION}.context-router.slng.ai/v1",
    default_headers={
        "X-Slng-Agent-Id": AGENT_ID,  # cache scope
        "X-Slng-Session-Id": session_id,  # one per call
    },
    settings=OpenAILLMService.Settings(
        model="slng/auto",  # picks from slng_config below
        system_instruction=INSTRUCTIONS,
        extra={
            "extra_body": {
                "slng_config": router_config(),
                "template_variables": variables,  # this call's values
            }
        },
    ),
)

pipecat-slng provides STT and TTS services. The router uses Pipecat’s OpenAILLMService.

Fill per-call values with template variables

Write values that change per call, such as the caller’s name, as {{name}} placeholders in the prompt. Send their values in the request body as template_variables, and the router fills them in before the model sees the prompt. The cached answer keeps the placeholders, so callers with different names can share it. Building the string yourself puts each caller’s name into the prompt, so no answer can be shared.

INSTRUCTIONS = (
    "You are the front desk of {{company_name}}, speaking with {{caller_name}}. "
    "Keep replies short: they are spoken aloud."
)


def call_variables(caller_name: str) -> dict[str, str]:
    """Return this call's values for the placeholders in INSTRUCTIONS."""
    return {"company_name": "Wayne Enterprises", "caller_name": caller_name}

Send values that are spoken or echoed: names, a company, an appointment time.
Keep steering values in the prompt itself. A value that changes what the answer says, such as the reply language, is not a template variable.
Give every placeholder a value. A {{name}} with no value returns 422 missing_template_variables.
Only the router fills them. With the Your LLM option, write the values into the prompt yourself.

For the syntax, limits, and more examples, see Per-call values.

Build it once per call

Build the services inside bot(), which the Pipecat runner calls once per call, so each call gets its own session ID and template variables. Keep your existing pipeline order.

bot.py

import uuid

from pipecat.pipeline.pipeline import Pipeline
from pipecat.runner.types import RunnerArguments


async def bot(runner_args: RunnerArguments) -> None:
    session_id = str(uuid.uuid4())  # one per call; your call or room ID works too
    variables = call_variables("Bruce")  # the caller's name, from your CRM or dispatch
    stt, llm, tts = ...  # the constructors from the steps above
    pipeline = Pipeline([
        transport.input(),
        stt,
        context_aggregator.user(),
        llm,
        tts,
        transport.output(),
        context_aggregator.assistant(),
    ])
    ...

Verify

Run one spoken turn through your bot’s transport and confirm that the pipeline completes speech to text, the LLM, and text to speech. With the templates, uv run python smoke.py speech_router runs one turn with no transport, and uv run python speech_router.py -t webrtc serves a page at http://localhost:7860 to talk to.

Next steps

Which models are available for other speech models and voices you can route through SLNG.
Integration guide for the Context Router’s caching, smart routing, and response headers.

Get started

Regions

Execution layer

Agent Builder

Models

Integrate

Prerequisites

Choose your LLM option

Use a coding agent

Model routes and regions

Edit the code yourself

Next steps

​Prerequisites

​Choose your LLM option

​Use a coding agent

​Model routes and regions

​Edit the code yourself

​Next steps

Prerequisites

Choose your LLM option

Use a coding agent

Model routes and regions

Edit the code yourself

Next steps