Skip to main content
Deepslate provides official Python and Node.js/TypeScript SDKs for connecting your voice AI application to the Deepslate Realtime API. All SDKs live in a single open-source monorepo and share a common core within each language, giving you a consistent configuration model and feature set regardless of which agent framework or language you use.

​
What Deepslate provides

Every SDK gives your application access to Deepslate’s unified voice AI stack over a single WebSocket connection:

Speech-to-Speech Streaming

Send raw PCM audio in, receive synthesized PCM audio out — all in real time

Server-side VAD

Voice Activity Detection runs on the server, so you don’t need a client-side VAD pipeline

LLM Inference

Deepslate manages the inference lifecycle, including tool calling, context management, and interruption handling

ElevenLabs TTS

Optional server-side text-to-speech with configurable voice, model, and regional endpoint

Deepslate Hosted TTS

Server-side text-to-speech using Deepslate-hosted cloned voices — no external TTS provider credentials required.

​
Packages

The monorepo publishes framework plugins for two languages. The LiveKit plugin is available in both Python and Node.js/TypeScript; the Pipecat plugin is Python-only. Each plugin pulls in its language’s core package automatically — install only the plugin you need.

deepslate-livekit (Python)

RealtimeModel plugin for LiveKit Agents. Drop into any Python LiveKit Agents project with a one-line model swap.

@deepslate-labs/livekit (Node.js)

RealtimeModel plugin for the LiveKit Agents Node framework. Same configuration model, written against the TypeScript API.

deepslate-pipecat (Python)

LLMService plugin for Pipecat. Integrates with any Pipecat transport and the full frame-based pipeline architecture.
pip install deepslate-livekit

npm install @deepslate-labs/livekit

pip install deepslate-pipecat
View source on GitHub: livekit (Python) · livekit (Node.js) · pipecat (Python)

​
Credentials

All packages read credentials from the same three environment variables: 
DEEPSLATE_VENDOR_ID=your_vendor_id
DEEPSLATE_ORGANIZATION_ID=your_organization_id
DEEPSLATE_API_KEY=your_api_key
Each configuration class (DeepslateOptions, RealtimeModel, etc.) accepts these as constructor arguments too, but environment variables are the recommended approach for keeping secrets out of your code.
Never expose these credentials to clients. All SDK packages are designed for server-side use only.

​
Core packages

Each language has a shared foundation that its plugins are built on — deepslate-core (Python) and @deepslate-labs/core (Node.js). It handles WebSocket connectivity, protobuf framing, session lifecycle, and exponential-backoff reconnection.
You don’t need to install the core package directly when using the LiveKit or Pipecat plugins — they include it as a dependency. Install it only if you’re building a custom integration outside of these frameworks.
pip install deepslate-core

npm install @deepslate-labs/core
The central building block is DeepslateSession, which manages the full protocol lifecycle. In Python it delivers events to a DeepslateSessionListener you subclass; in Node.js it is an event emitter you subscribe to with session.on(...). The Python version: 
from deepslate.core import (
    DeepslateOptions,
    DeepslateSession,
    DeepslateSessionListener,
)

class MyListener(DeepslateSessionListener):
    async def on_text_fragment(self, text: str) -> None:
        print(text, end="", flush=True)

    async def on_audio_chunk(
        self, pcm_bytes: bytes, sample_rate: int, channels: int, transcript: str | None
    ) -> None:
        # Forward audio to your output device or transport
        ...

    async def on_tool_call(self, call_id: str, name: str, params: dict) -> None:
        result = await dispatch_tool(name, params)
        await self.session.send_tool_response(call_id, result)

listener = MyListener()
session = DeepslateSession.create(
    DeepslateOptions.from_env(),
    listener=listener,
)
listener.session = session
session.start()
For the full DeepslateSession API — including all send methods and event callbacks — see the core source: Python · Node.js.

​
Repository

All packages are maintained in a single polyglot monorepo, split by language. The Python workspace is managed with uv; the Node.js workspace with pnpm: 
deepslate-sdks/
├── python/
│   ├── packages/
│   │   ├── core/      # deepslate-core — shared WebSocket client and session logic
│   │   ├── livekit/   # deepslate-livekit — LiveKit Agents plugin
│   │   └── pipecat/   # deepslate-pipecat — Pipecat plugin
│   └── pyproject.toml # uv workspace root
└── node/
    ├── packages/
    │   ├── core/      # @deepslate-labs/core — shared WebSocket client and session logic
    │   └── livekit/   # @deepslate-labs/livekit — LiveKit Agents plugin
    └── pnpm-workspace.yaml
Contributions are welcome. Before setting up a local development environment, make sure you have:
  • Git
  • uv for the Python workspace
  • pnpm and Node.js 18+ for the Node.js workspace
Then clone the repository and install dependencies for the workspace you want: 
git clone https://github.com/deepslate-labs/deepslate-sdks.git
cd deepslate-sdks/python
uv sync --all-packages

git clone https://github.com/deepslate-labs/deepslate-sdks.git
cd deepslate-sdks/node
pnpm install

LiveKit Plugin (Python)

Full configuration reference, features, and examples

LiveKit Plugin (Node.js)

TypeScript configuration reference, features, and examples

Pipecat Plugin (Python)

Full configuration reference, features, and frame reference

GitHub Repository

Source code, issues, and contributions

API Reference

WebSocket message schemas and protocol documentation