LiveKit integration guide

Keep your LiveKit agent where it runs and swap its speech to text and text to speech for SLNG-hosted models. You can also route the language model through the SLNG Context Router. The rest of your pipeline stays as it is. 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 LiveKit agent in Python 3.10+ on livekit-agents>=1.8.8.
A project created under Improve my agent > LiveKit, 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 LiveKit templates are complete agents 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	LiveKit’s OpenAI plugin 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, which installs the livekit-migration skill and applies the change.

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

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

Example prompt

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

# Migrate this LiveKit agent to SLNG-hosted STT/TTS and the SLNG Context Router

Use the SLNG `livekit-migration` skill to replace speech to text and
text to speech with `slng.STT` and `slng.TTS`. Replace the LLM with
LiveKit's OpenAI-compatible plugin 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 livekit-migration
```

## Selected stack
- STT: `slng/deepgram/nova:3-en`
- TTS: `slng/fish/tts:s2.1-pro`
- Voice: the voice you picked
- Language: English (`en`)
- Region: Germany, via the `eu-west.api.slng.ai` base URL
- 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, env loading, and current
   STT/TTS/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 `livekit-plugins-slng` and import-probe
   `from livekit.plugins import slng`.
5. Replace the STT and TTS constructors with `slng.STT(...)` and
   `slng.TTS(...)`.
6. Point the LLM at the SLNG Context Router endpoint.
7. Never inline API keys. Verify one spoken turn that completes STT to
   LLM to TTS.

Edit the code yourself

The removed lines below depend on your current providers, so match them to your code. For every constructor parameter, see the LiveKit plugin reference.

Install the plugins

Use your project’s package manager.

uv add "livekit-agents[openai,silero]~=1.8.8" "livekit-plugins-slng~=1.8.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

Swap the two constructors that feed your session. slng_base_url pins the region, and the two external_* IDs tie each call’s speech usage to your agent and call.

- from livekit.plugins import deepgram, cartesia
+ from livekit.plugins import slng

- stt = deepgram.STT(model="nova-3")
- tts = cartesia.TTS(voice="<your voice>")
+ stt = slng.STT(
+     api_key=os.environ["SLNG_API_KEY"],
+     slng_base_url=f"{REGION}.api.slng.ai",  # the project's region
+     model="soniox/speech-ai:rt-v5",
+     language="en",
+     external_agent_id=AGENT_ID,
+     external_session_id=session_id,
+ )
+ tts = slng.TTS(
+     api_key=os.environ["SLNG_API_KEY"],
+     slng_base_url=f"{REGION}.api.slng.ai",
+     model="slng/fish/tts:s2.1-pro",
+     voice="9a9cf47702da476aa4629e2506d4a857",  # Fish Audio reference_id
+     language="en",
+     external_agent_id=AGENT_ID,
+     external_session_id=session_id,
+ )

The parameter is slng_base_url, not base_url. The plugins pass an unknown keyword on as a model option, so base_url= leaves the plugin on the default api.slng.ai host without an error.

After you build the session, call stt.attach_to_session(session). It lets the STT finalize the caller’s turn as soon as LiveKit detects its end.

Set up the LLM

Pick the tab for your option. Both router options send the agent and session IDs as headers, and this call’s template variables in the body. The next step builds variables.

Your LLM
Context Router
Context Router, inline BYOK

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

from livekit.plugins import openai

llm = openai.LLM(model="gpt-5.6-luna", api_key=os.environ["OPENAI_API_KEY"])

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

from livekit.plugins import openai
from openai import AsyncOpenAI

router = AsyncOpenAI(
    base_url=f"https://{REGION}.context-router.slng.ai/v1",
    api_key=os.environ["SLNG_API_KEY"],
    max_retries=0,  # the router fails over between models itself
)
llm = openai.LLM(
    client=router,
    model="slng/auto",
    extra_headers={
        "X-Slng-Agent-Id": AGENT_ID,  # cache scope
        "X-Slng-Session-Id": session_id,  # one per call
    },
    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 livekit.plugins import openai
from openai import AsyncOpenAI

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]}}


router = AsyncOpenAI(
    base_url=f"https://{REGION}.context-router.slng.ai/v1",
    api_key=os.environ["SLNG_API_KEY"],
    max_retries=0,  # the router fails over between models itself
)
llm = openai.LLM(
    client=router,
    model="slng/auto",  # picks from slng_config below
    extra_headers={
        "X-Slng-Agent-Id": AGENT_ID,  # cache scope
        "X-Slng-Session-Id": session_id,  # one per call
    },
    extra_body={
        "slng_config": router_config(),
        "template_variables": variables,  # this call's values
    },
)

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 STT, LLM, and TTS inside the entrypoint, so each call gets its own session ID and template variables. A module-level ID would reuse one session across every call.

agent.py

import os
import uuid

from livekit.agents import Agent, AgentServer, AgentSession, JobContext, cli
from livekit.plugins import silero

REGION = os.getenv("SLNG_REGION", "eu-north")
AGENT_ID = os.getenv("SLNG_AGENT_ID", "wayne-concierge-v1")

server = AgentServer()


@server.rtc_session()
async def entrypoint(ctx: JobContext) -> None:
    session_id = str(uuid.uuid4())  # one per call; your room or call 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
    session = AgentSession(stt=stt, llm=llm, tts=tts, vad=silero.VAD.load())
    stt.attach_to_session(session)
    await session.start(agent=Agent(instructions=INSTRUCTIONS), room=ctx.room)
    session.say("Hi, how can I help you today?")  # a fixed greeting skips the LLM


if __name__ == "__main__":
    cli.run_app(server)

Verify

Run one spoken turn and confirm it 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 room, and uv run python speech_router.py console talks to your microphone.

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

Edit the code yourself

Next steps

​Prerequisites

​Choose your LLM option

​Use a coding agent

​Edit the code yourself

​Next steps

Prerequisites

Choose your LLM option

Use a coding agent

Edit the code yourself

Next steps