Pipecat

https://docs.pipecat.ai
Admin
Pipecat is an open-source Python framework for building real-time voice and multimodal AI bots that...
Tokens:586,685
Snippets:6,850
Trust Score:7.5
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Run Server

Source: https://docs.pipecat.ai/pipecat-cloud/guides/telephony/plivo-websocket

Commands to install necessary packages and start the local XML server.

```bash
uv add fastapi uvicorn
python server.py
```

--------------------------------

### Run Proxy Example

Source: https://docs.pipecat.ai/pipecat/learn/proxy-agents

Commands to start the LLM server and the transport client.

```bash
# Terminal 1: Start the LLM server
python assistant.py --port 8765

# Terminal 2: Start the transport client
python main.py --remote-url ws://localhost:8765/ws
```

--------------------------------

### Start the Pipecat client

Source: https://docs.pipecat.ai/client/get-started/quickstart

Commands to install dependencies and launch the client development server.

```bash
cd ../client
npm install
npm run dev
```

--------------------------------

### Initialize a quickstart project

Source: https://docs.pipecat.ai/api-reference/cli/init

Scaffolds a canned quickstart bot with pre-configured services.

```shell
pipecat init quickstart
```

--------------------------------

### Install Quickdial Package

Source: https://docs.pipecat.ai/api-reference/server/services/stt/quickdial

Install the community-maintained package via uv.

```bash
uv add pipecat-quickdial
```

--------------------------------

### Initialize a Pipecat project

Source: https://docs.pipecat.ai/api-reference/cli/init

Demonstrates the standard initialization flow, starting with guide creation and followed by automated bot scaffolding using specific service flags.

```shell
# 1. A developer initializes the project (writes the coding-agent guide):
pipecat init my-bot

# 2. They open ./my-bot in a coding agent and describe the bot they want.
# 3. The agent scaffolds it in place, mapping the requirements to flags:
pipecat init . --bot-type web --transport daily --mode cascade \
  --stt deepgram_stt --llm openai_llm --tts cartesia_tts --eval
```

--------------------------------

### Running the Twilio Bot Example

Source: https://docs.pipecat.ai/pipecat/telephony/twilio-websockets

Commands to expose a local server, install dependencies, and execute the bot with Twilio transport.

```shell
ngrok http 7860
```

```shell
uv sync
```

```shell
uv run bot.py -t twilio
```

--------------------------------

### Install Noveum Trace package

Source: https://docs.pipecat.ai/api-reference/server/services/analytics/noveum-trace

Install the community-maintained package using uv.

```bash
uv add "noveum-trace[pipecat]"
```

--------------------------------

### Install Lokutor package

Source: https://docs.pipecat.ai/api-reference/server/services/tts/lokutor

Install the community-maintained package using uv.

```bash
uv add pipecat-lokutor
```

--------------------------------

### Install Respeecher package

Source: https://docs.pipecat.ai/api-reference/server/services/tts/respeecher

Install the community-maintained package using uv.

```bash
uv add pipecat-respeecher
```

--------------------------------

### Get start timestamp

Source: https://docs.pipecat.ai/api-reference/server/workers/base-worker

Returns the Unix timestamp when the agent became ready, or None if not started.

```python
agent.started_at -> float | None
```

--------------------------------

### Retrieve Organization Properties Example

Source: https://docs.pipecat.ai/api-reference/pipecat-cloud/rest-reference/openapi.json

Example response body for a successful GET request to retrieve current organization properties.

```json
{
  "properties": {
    "defaultRegion": "us-west"
  }
}
```

--------------------------------

### Basic FunASR Service Setup

Source: https://docs.pipecat.ai/api-reference/server/services/stt/funasr

Initialize the FunASRSTTService with default settings.

```python
from pipecat.services.funasr.stt import FunASRSTTService

stt = FunASRSTTService()
```

--------------------------------

### Initialize and connect client

Source: https://docs.pipecat.ai/api-reference/client/android/transports/small-webrtc

Set up the client with callbacks and connect via a server-side start endpoint.

```kotlin
import ai.pipecat.client.PipecatClientOptions
import ai.pipecat.client.PipecatEventCallbacks
import ai.pipecat.client.small_webrtc_transport.PipecatClientSmallWebRTC
import ai.pipecat.client.small_webrtc_transport.SmallWebRTCTransport
import ai.pipecat.client.small_webrtc_transport.SmallWebRTCTransportConnectParams
import ai.pipecat.client.types.APIRequest
import ai.pipecat.client.types.BotReadyData
import ai.pipecat.client.types.Value

val callbacks = object : PipecatEventCallbacks() {
    override fun onBackendError(message: String) {
        Log.e(TAG, "Backend error: $message")
    }

    override fun onBotReady(data: BotReadyData) {
        Log.d(TAG, "Bot is ready")
    }
}

val options = PipecatClientOptions(callbacks = callbacks, enableMic = true)
val client = PipecatClientSmallWebRTC(SmallWebRTCTransport(context), options)

// Connect via your server's /start endpoint (recommended)
client.startBotAndConnect(
    APIRequest(
        endpoint = "https://your-server.com/start",
        // Pipecat Cloud and the Pipecat development runner use these fields
        // to decide how to run the bot; unknown fields are ignored
        requestData = Value.Object(
            "transport" to Value.Str("webrtc"),
            "enableDefaultIceServers" to Value.Bool(true),
        )
    )
).withCallback { result ->
    result.errorOrNull?.let { Log.e(TAG, "Connection failed: $it") }
}

// Or connect with coroutines
// client.startBotAndConnect(...).await()
```

--------------------------------

### context-hub get-example

Source: https://docs.pipecat.ai/api-reference/cli/context-hub

Fetches the full source files of an example by its ID.

```APIDOC
## context-hub get-example

### Description
Fetch the full source files of an example. Use after `search-examples`.

### Usage
`pipecat context-hub get-example [OPTIONS] EXAMPLE_ID`

### Arguments
- **EXAMPLE_ID** (string) - Required - Example ID from a `search-examples` hit.

### Options
- **--no-readme** (flag) - Skip the example's README content.
```

--------------------------------

### Handle Capacity Errors

Source: https://docs.pipecat.ai/pipecat-cloud/fundamentals/active-sessions

Examples of identifying and handling 429 capacity errors when attempting to start an agent session.

```bash
curl --location --request POST 'https://api.pipecat.daily.co/v1/public/{agent_name}/start' \
--header 'Authorization: Bearer PUBLIC_API_KEY' \
--header 'Content-Type: application/json' \
--data-raw '{}'

>> {
>>	"status": 429,
>>	"code": "429",
>>	"message": "Rate limit exceeded. Please try again later"
>> }
```

```python
from pipecatcloud import Session, SessionParams
from pipecatcloud.exception import AgentStartError

try:
    session = Session(
        agent_name="my-first-agent",
        api_key="pk_...",
        params=SessionParams(
            use_daily=False,
            data={}
        )
    )
except AgentStartError as e:
    # This will catch capacity errors and other start failures
    print(f"Error starting agent: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")
```

--------------------------------

### Setup environment variables

Source: https://docs.pipecat.ai/pipecat/deployment/platforms/modal

Commands to initialize the environment configuration file for the server.

```bash
cd server
cp .env.example .env
# Modify .env to provide your service API Keys
```

--------------------------------

### Configure Behavioral Evals in Project Documentation

Source: https://docs.pipecat.ai/pipecat/evals/the-eval-loop

Example instructions for CLAUDE.md or AGENTS.md to guide an assistant on running evaluation scenarios.

```markdown
## Behavioral evals

Evals live in `scenarios/`. To verify any change to the agent's behavior:

1. Start the agent: `uv run bot.py -t eval` (serves ws://localhost:7860)
2. Run the evals: `pipecat eval run scenarios/*.yaml`

The command exits non-zero on failure and prints each failed assertion.
Each scenario writes a decision trace to `<scenario>.eval.log`; read it
to understand a failure before changing code.

When you add or change agent behavior, add or update a scenario in
`scenarios/` to cover it.
```

--------------------------------

### Basic GrokRealtimeLLMService Setup

Source: https://docs.pipecat.ai/api-reference/server/services/s2s/grok

Initializes the service using an API key from environment variables.

```python
import os
from pipecat.services.xai.realtime.llm import GrokRealtimeLLMService

llm = GrokRealtimeLLMService(
    api_key=os.getenv("XAI_API_KEY"),
)
```

--------------------------------

### Start Piper HTTP Server

Source: https://docs.pipecat.ai/api-reference/server/services/tts/piper

Commands to install the necessary dependencies and launch the Piper HTTP server for remote service access.

```bash
uv add "piper-tts[http]"
uv run python -m piper.http_server -m en_US-ryan-high
```

--------------------------------

### Start development server for React and JavaScript

Source: https://docs.pipecat.ai/client/guides/building-a-voice-ui

Launch the local development environment for web-based voice applications.

```bash
npm run dev
```

--------------------------------

### start()

Source: https://docs.pipecat.ai/api-reference/server/utilities/mcp/mcp

Opens a persistent connection to the MCP server and initializes the session.

```APIDOC
### async def start(self) -> None

Opens a persistent connection to the MCP server and initializes the session. The session is reused for all subsequent tool calls until `close()` is called. Can also be used via async context manager.
```

--------------------------------

### List Available Regions API Request

Source: https://docs.pipecat.ai/pipecat-cloud/rest-reference/endpoint/regions-list

Examples of how to perform a GET request to the regions endpoint using various programming languages.

```bash
curl --request GET \
  --url https://api.pipecat.daily.co/v1/regions \
  --header 'Authorization: Bearer <token>'
```

```python
import requests

url = "https://api.pipecat.daily.co/v1/regions"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.text)
```

```javascript
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.pipecat.daily.co/v1/regions', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.pipecat.daily.co/v1/regions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.pipecat.daily.co/v1/regions"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

```java
HttpResponse<String> response = Unirest.get("https://api.pipecat.daily.co/v1/regions")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.pipecat.daily.co/v1/regions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

--------------------------------

### Basic FalImageGenService Setup

Source: https://docs.pipecat.ai/api-reference/server/services/image-generation/fal

Initializes the service using an aiohttp session and the required API key.

```python
import aiohttp
from pipecat.services.fal import FalImageGenService

async with aiohttp.ClientSession() as session:
    image_gen = FalImageGenService(
        aiohttp_session=session,
        key=os.getenv("FAL_KEY"),
        settings=FalImageGenService.Settings(
            image_size="landscape_16_9",
        ),
    )
```

--------------------------------

### OpenAPI Specification for Get Session Details

Source: https://docs.pipecat.ai/api-reference/pipecat-cloud/rest-reference/endpoint/agent-get-session

The OpenAPI definition for the session retrieval endpoint, including request parameters and example response structures.

```yaml
openapi: 3.0.0
info:
  title: Pipecat Cloud
  version: 1.0.0
  description: >-
    REST API for Pipecat Cloud. The public API (`/v1/public`, authenticated with
    a public API key) starts agent sessions and proxies requests to them. The
    private API (`/v1`, authenticated with a private API key) manages agents,
    secrets, builds, regions, and organization settings.
servers:
  - url: https://api.pipecat.daily.co/v1
    description: Private API server
security: []
paths:
  /agents/{agentName}/sessions/{sessionId}:
    get:
      summary: Get session details
      description: >-
        Retrieves detailed information about a specific session, including
        resource metrics and meeting IDs.
      operationId: getSession
      parameters:
        - name: agentName
          in: path
          required: true
          description: Name of the agent
          schema:
            type: string
        - name: sessionId
          in: path
          required: true
          description: UUID of the session to retrieve
          schema:
            type: string
            format: uuid
      responses:
        '200':
          description: Session details retrieved successfully
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SessionResponse'
              example:
                sessionId: 800d444a-e67e-4686-afb3-b0de509cccb3
                serviceId: b900ae4a-f710-4ef1-95d8-c5f5b2789da9
                organizationId: cc71b52d-4271-46c9-87be-cac600fd821a
                deploymentId: 81f4da55-106d-401f-b069-a1f1992f871a
                endedAt: '2025-10-22T08:39:26.000Z'
                botStartSeconds: 2
                coldStart: true
                completionStatus: HTTP_COMPLETED
                createdAt: '2025-10-22T08:39:20.000Z'
                updatedAt: '2025-10-22T08:39:26.000Z'
                resourceMetrics:
                  id: a1b2c3d4-e5f6-7890-abcd-ef1234567890
                  sessionId: 800d444a-e67e-4686-afb3-b0de509cccb3
                  sampleCount: 12
                  cpuMillicoresP50: 150
                  cpuMillicoresP90: 280
                  cpuMillicoresP95: 320
                  cpuMillicoresP99: 450
                  memoryBytesP50: 134217728
                  memoryBytesP90: 201326592
                  memoryBytesP95: 234881024
                  memoryBytesP99: 268435456
                  timeseries:
                    - t: 1729583960
                      c: 150
                      m: 134217728
                    - t: 1729583965
                      c: 280
                      m: 201326592
                  eventTs: '2025-10-22T08:39:25.000Z'
                  createdAt: '2025-10-22T08:39:25.000Z'
                meetingIds:
                  - participantId: d4e5f6a7-b8c9-0123-4567-890abcdef012
                    meetingId: f1e2d3c4-b5a6-9780-1234-567890abcdef
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          description: Agent or session not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error: >-
                  API endpoint not found / agent deployment not found /
                  Organization not found
                code: '404'
        '500':
          description: Internal server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error: >-
                  Internal server error. Please check logs for more information
                  or contact support.
                code: '500'
      security:
        - PrivateKeyAuth: []
components:
  schemas:
    SessionResponse:
      type: object
      properties:
        sessionId:
          type: string
          description: ID of the session
        serviceId:
          type: string
          description: ID of the service for this session
        organizationId:
          type: string
          description: ID of the organization that this session is associated with
        deploymentId:
          type: string
          description: ID of the deployment that this session is associated with
        endedAt:
          type: string
          format: date-time
          description: Timestamp when the session ended
          nullable: true
        botStartSeconds:
          type: integer
          description: Number of seconds between bot start request and bot start
```

--------------------------------

### Dockerfile for Production Bot Image

Source: https://docs.pipecat.ai/pipecat/deployment/running-bots-in-production

A minimal Dockerfile that installs dependencies and pre-caches model weights to ensure fast cold starts for production bot sessions.

```dockerfile
FROM python:3.11-slim-bookworm

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY bot.py .
# Bake model weights (e.g. Silero VAD) into the image so first-run is fast.
RUN python -c "import torch; torch.hub.load('snakers4/silero-vad', 'silero_vad', force_reload=True)"

# Pre-download NLTK data used for sentence aggregation.
RUN python -m nltk.downloader punkt_tab -d /usr/local/share/nltk_data && \
    python -c "import nltk; nltk.data.find('tokenizers/punkt_tab')"
```

--------------------------------

### Discover available options

Source: https://docs.pipecat.ai/api-reference/cli/init

Lists all available configuration options for the init command.

```shell
pipecat init --list-options
```

```json
{
  "bot_type": ["web", "telephony"],
  "transports": {
    "web": ["daily", "smallwebrtc"],
    "telephony": ["twilio", "twilio_daily_sip_dialin", "twilio_daily_sip_dialout", ...]
  },
  "stt": ["deepgram_stt", "mistral_stt", "openai_stt", "xai_stt", ...],
  "llm": ["openai_llm", "anthropic_llm", ...],
  "tts": ["cartesia_tts", "elevenlabs_tts", "soniox_tts", ...],
  "realtime": ["openai_realtime", "gemini_live_realtime", ...],
  "video": ["heygen_video", "tavus_video", "simli_video"]
}
```

```shell
options=$(pipecat init --list-options)
tts=$(echo "$options" | jq -r '.tts[0]')
```

--------------------------------

### Retrieve Session Status via Python and cURL

Source: https://docs.pipecat.ai/pipecat-cloud/guides/session-api

Expose internal bot state through custom HTTP GET endpoints. This example shows how to return tracked session data.

```python
from pipecatcloud_system import app

session_data = {"messages": [], "user_name": None}

@app.get("/status")
async def get_status():
    return {
        "message_count": len(session_data["messages"]),
        "user_name": session_data["user_name"],
    }
```

```bash
curl -X GET \
  'https://api.pipecat.daily.co/v1/public/my-agent/sessions/{session_id}/status' \
  -H 'Authorization: Bearer pk_...'
```

--------------------------------

### Fetch example source files

Source: https://docs.pipecat.ai/api-reference/cli/context-hub

Retrieves the full source files for a specific example identified by its ID.

```shell
pipecat context-hub get-example [OPTIONS] EXAMPLE_ID
```

--------------------------------

### pipecat context-hub install

Source: https://docs.pipecat.ai/api-reference/cli/context-hub

Registers the MCP server with a coding agent and builds the local index. This command configures detected client CLIs or provides the necessary JSON configuration for manual setup.

```APIDOC
## pipecat context-hub install

### Description
Registers the MCP server with a coding agent and builds the index. Configures every detected client CLI unless a specific client is provided.

### Usage
`pipecat context-hub install [OPTIONS]`

### Options
- **--client** (string) - Optional - Client to configure: `claude-code`, `codex`, `cursor`, `vscode`, or `zed`. Repeatable. Defaults to every detected client CLI.
- **--no-refresh** (flag) - Optional - Skip building the index.
- **--print-config** (flag) - Optional - Only print the MCP config and the server command; change nothing.
```

--------------------------------

### setup_tracing()

Source: https://docs.pipecat.ai/api-reference/server/utilities/opentelemetry

Configuration parameters for initializing the OpenTelemetry tracing system.

```APIDOC
## setup_tracing() Parameters

- **service_name** (str) - Default: pipecat - Name of the service for traces
- **exporter** (SpanExporter | None) - Default: None - A pre-configured OpenTelemetry span exporter instance
- **console_export** (bool) - Default: False - Whether to also export traces to console (useful for debugging)
```

--------------------------------

### Session ID Example

Source: https://docs.pipecat.ai/api-reference/pipecat-cloud/rest-reference/endpoint/start

Example of a unique session identifier.

```text
639f91d8-d511-4677-a83b-bd7564d5d92f
```

--------------------------------

### Initialize NvidiaSegmentedSTTService

Source: https://docs.pipecat.ai/api-reference/server/services/stt/nvidia

Example showing how to instantiate the service with an API key and custom language settings.

```python
from pipecat.services.nvidia.stt import NvidiaSegmentedSTTService
from pipecat.transcriptions.language import Language

stt = NvidiaSegmentedSTTService(
    api_key=os.getenv("NVIDIA_API_KEY"),
    settings=NvidiaSegmentedSTTService.Settings(
        language=Language.ES,
        automatic_punctuation=True,
        boosted_lm_words=["Pipecat", "NVIDIA"],
        boosted_lm_score=6.0,
    ),
)
```

--------------------------------

### Refresh guide files

Source: https://docs.pipecat.ai/api-reference/cli/init

Updates the guide files for an existing project.

```shell
pipecat init my-bot --overwrite-guide
```

--------------------------------

### Initialize from a config file

Source: https://docs.pipecat.ai/api-reference/cli/init

Uses a JSON configuration file to scaffold the project.

```shell
pipecat init my-bot --config project-config.json
```

```json
{
  "project_name": "my-bot",
  "bot_type": "web",
  "transports": ["daily"],
  "mode": "cascade",
  "stt_service": "deepgram_stt",
  "llm_service": "openai_llm",
  "tts_service": "cartesia_tts",
  "recording": false,
  "transcription": false,
  "deploy_to_cloud": true,
  "enable_krisp": false,
  "enable_observability": false
}
```

```shell
pipecat init my-bot --config base-config.json --name custom-name --no-deploy-to-cloud
```

--------------------------------

### Install OpenTelemetry dependencies

Source: https://docs.pipecat.ai/api-reference/server/utilities/opentelemetry

Install the necessary tracing packages for Pipecat.

```bash
uv add "pipecat-ai[tracing]"
```

--------------------------------

### Install FireRedVAD package

Source: https://docs.pipecat.ai/api-reference/server/services/vad/fire-vad

Install the community-maintained package via uv.

```bash
uv add pipecat-firered-vad
```

--------------------------------

### Basic Gemini Live Service Setup

Source: https://docs.pipecat.ai/api-reference/server/services/s2s/gemini-live

Initializes the service with a basic system instruction and voice selection.

```python
import os
from pipecat.services.google.gemini_live import GeminiLiveLLMService

llm = GeminiLiveLLMService(
    api_key=os.getenv("GOOGLE_API_KEY"),
    settings=GeminiLiveLLMService.Settings(
        voice="Charon",
        system_instruction="You are a helpful assistant.",
    ),
)
```

--------------------------------

### Install Dependencies and Run Bot

Source: https://docs.pipecat.ai/pipecat/get-started/quickstart

Synchronize the project dependencies and execute the bot script.

```bash
uv sync
```

```bash
uv run bot.py
```

--------------------------------

### Initialize OpenAISTTService

Source: https://docs.pipecat.ai/api-reference/server/services/stt/openai

Example showing how to instantiate the service with an API key and model settings.

```python
from pipecat.services.openai.stt import OpenAISTTService

stt = OpenAISTTService(
    api_key=os.getenv("OPENAI_API_KEY"),
    settings=OpenAISTTService.Settings(
        model="gpt-4o-transcribe",
    ),
)
```

--------------------------------

### Install Deepgram dependencies

Source: https://docs.pipecat.ai/api-reference/server/services/stt/deepgram

Install the base Deepgram package for Pipecat.

```bash
uv add "pipecat-ai[deepgram]"
```

--------------------------------

### Install pipecat-bandwidth

Source: https://docs.pipecat.ai/api-reference/server/services/serializers/bandwidth

Use this command to install the community-maintained Bandwidth package.

```bash
uv add pipecat-bandwidth
```

--------------------------------

### Configure Baseten LLM with Custom Settings

Source: https://docs.pipecat.ai/api-reference/server/services/llm/baseten

Initialize the service with additional parameters like temperature, max tokens, and system instructions.

```python
from pipecat.services.baseten import BasetenLLMService

llm = BasetenLLMService(
    api_key=os.getenv("BASETEN_API_KEY"),
    settings=BasetenLLMService.Settings(
        model="moonshotai/Kimi-K2.6",
        temperature=0.7,
        max_completion_tokens=1024,
        system_instruction="You are a helpful assistant in a voice conversation. Your responses will be spoken aloud, so avoid emojis, bullet points, or other formatting that can't be spoken. Respond to what the user said in a creative, helpful, and brief way.",
    ),
)
```

--------------------------------

### Install AwaazAI Package

Source: https://docs.pipecat.ai/api-reference/server/services/serializers/awaazai

Install the community-maintained package using uv.

```bash
uv add pipecat-awaazai
```

--------------------------------

### Install MCP server configuration

Source: https://docs.pipecat.ai/api-reference/context-hub

Use the CLI to automatically detect clients or print configuration for manual registration.

```bash
pipecat context-hub install                     # every detected client, then build the index
pipecat context-hub install --client cursor     # print the config for one client
pipecat context-hub install --print-config      # show what would be registered, change nothing
```

--------------------------------

### Create Initial Node Configuration

Source: https://docs.pipecat.ai/pipecat-flows/guides/state-management

Define the starting node with role instructions, task messages, and available functions.

```python
def create_initial_node() -> NodeConfig:
    """Create the initial node of the flow.

    Define the bot's role and task for the node, plus the function it can call.
    The function provides its result to Pipecat and transitions to the next node.
    """
    return NodeConfig(
        name="initial",
        role_message="You are an inquisitive child. Use very simple language. Ask simple questions. You must ALWAYS use one of the available functions to progress the conversation. Your responses will be converted to audio. Avoid outputting special characters and emojis.",
        task_messages=[
            {
                "role": "developer",
                "content": "Say 'Hello world' and ask what is the user's favorite color.",
            }
        ],
        functions=[record_favorite_color],
    )
```

--------------------------------

### Install Grok dependencies

Source: https://docs.pipecat.ai/api-reference/server/services/llm/grok

Install the necessary package using uv.

```bash
uv add "pipecat-ai[grok]"
```

--------------------------------

### Install DeepSeek dependency

Source: https://docs.pipecat.ai/api-reference/server/services/llm/deepseek

Install the necessary package using uv.

```bash
uv add "pipecat-ai[deepseek]"
```

--------------------------------

### Example Configuration File

Source: https://docs.pipecat.ai/api-reference/cli/cloud/auth

Shows the structure of the local configuration file stored in ~/.config/pipecatcloud/pipecatcloud.toml.

```toml
  token = "..."
    org = "user-namespace"

    [another-user-org]
    default_public_key = "pk_..."
    default_public_key_name = "Test Key"

    [futher-user-org]
    default_public_key = "pk_..."
    default_public_key_name = "Pipecat Cloud Public Key"
```

--------------------------------

### Basic OpenAI Realtime Service Setup

Source: https://docs.pipecat.ai/api-reference/server/services/s2s/openai

Initializes the service with an API key and model identifier.

```python
import os
from pipecat.services.openai.realtime import OpenAIRealtimeLLMService

llm = OpenAIRealtimeLLMService(
    api_key=os.getenv("OPENAI_API_KEY"),
    model="gpt-realtime-2",
)
```

--------------------------------

### Verify CLI Installation

Source: https://docs.pipecat.ai/api-reference/cli/overview

Checks the installed version of the Pipecat CLI.

```bash
pipecat --version
```

--------------------------------

### Daily Room URL Example

Source: https://docs.pipecat.ai/api-reference/pipecat-cloud/rest-reference/endpoint/start

Example of a URL for a created Daily room.

```text
https://cloud-354b1860310a444ba0f528b6a2f467c4.daily.co/qZbK9nyXCDCmQ0zDDZta
```

--------------------------------

### Configure Daily Room Properties

Source: https://docs.pipecat.ai/api-reference/server/utilities/daily/rest-helper

Example demonstrating how to instantiate DailyRoomProperties with various settings including expiration, recording, and SIP configuration.

```python
import time
from pipecat.transports.daily.utils import (
    DailyRoomProperties,
    DailyRoomSipParams,
    RecordingsBucketConfig,
)

properties = DailyRoomProperties(
    exp=time.time() + 3600,  # 1 hour from now
    enable_chat=True,
    enable_emoji_reactions=True,
    enable_recording="cloud-audio-only",
    geo="us-west",
    max_participants=50,
    sip=DailyRoomSipParams(display_name="conference"),
    recordings_bucket=RecordingsBucketConfig(
        bucket_name="my-bucket",
        bucket_region="us-west-2",
        assume_role_arn="arn:aws:iam::123456789012:role/DailyRole"
    )
)

# Access SIP endpoint if available
if properties.sip_endpoint:
    print(f"SIP endpoint: {properties.sip_endpoint}")
```

--------------------------------

### Initialize and connect the Gemini client

Source: https://docs.pipecat.ai/api-reference/client/android/transports/gemini-websocket

Set up event callbacks and establish a connection to the Gemini Live service.

```kotlin
import ai.pipecat.client.PipecatClientOptions
import ai.pipecat.client.PipecatEventCallbacks
import ai.pipecat.client.gemini_live_websocket.GeminiLiveWebsocketTransport
import ai.pipecat.client.gemini_live_websocket.GeminiServiceOptions
import ai.pipecat.client.gemini_live_websocket.PipecatClientGeminiLiveWebsocket
import ai.pipecat.client.types.BotReadyData

val callbacks = object : PipecatEventCallbacks() {
    override fun onBackendError(message: String) {
        Log.e(TAG, "Backend error: $message")
    }

    override fun onBotReady(data: BotReadyData) {
        Log.d(TAG, "Bot is ready")
    }
}

val options = PipecatClientOptions(callbacks = callbacks, enableMic = true)
val client = PipecatClientGeminiLiveWebsocket(GeminiLiveWebsocketTransport(context), options)

client.connect(
    GeminiServiceOptions.withDefaults(
        apiKey = "your-gemini-api-key",
        voice = "Puck",
        initialUserMessage = "How tall is the Eiffel Tower?"
    )
).withCallback { result ->
    result.errorOrNull?.let { Log.e(TAG, "Connection failed: $it") }
}
```

--------------------------------

### Install pipecat-ai

Source: https://docs.pipecat.ai/api-reference/server/utilities/turn-detection/smart-turn-overview

Install the core package to access Smart Turn functionality.

```bash
uv add pipecat-ai
```

--------------------------------

### Install XTTS-vLLM package

Source: https://docs.pipecat.ai/api-reference/server/services/tts/xtts-vllm

Use this command to install the community-maintained XTTS-vLLM package.

```bash
uv add pipecat-xtts-vllm
```

--------------------------------

### Basic MiniMax TTS Setup

Source: https://docs.pipecat.ai/api-reference/server/services/tts/minimax

Initializes the MiniMax service using an aiohttp session and required environment variables.

```python
import aiohttp
from pipecat.services.minimax import MiniMaxHttpTTSService

async with aiohttp.ClientSession() as session:
    tts = MiniMaxHttpTTSService(
        api_key=os.getenv("MINIMAX_API_KEY"),
        group_id=os.getenv("MINIMAX_GROUP_ID"),
        aiohttp_session=session,
    )
```

--------------------------------

### Initialize with custom settings

Source: https://docs.pipecat.ai/api-reference/server/services/tts/groq

Configure the service with specific model, language, and speed parameters.

```python
from pipecat.transcriptions.language import Language

tts = GroqTTSService(
    api_key=os.getenv("GROQ_API_KEY"),
    settings=GroqTTSService.Settings(
        model="canopylabs/orpheus-v1-english",
        voice="autumn",
        language=Language.EN,
        speed=1.2,
    ),
)
```

--------------------------------

### Install FunASR dependencies

Source: https://docs.pipecat.ai/api-reference/server/services/stt/funasr

Install the necessary package dependencies for the FunASR service.

```bash
uv add "pipecat-ai[funasr]"
```

--------------------------------

### Start an Agent Session

Source: https://docs.pipecat.ai/api-reference/pipecat-cloud/sdk-reference/examples

Demonstrates initializing a session with custom parameters and handling the response to retrieve a Daily room URL.

```python
import asyncio

from pipecatcloud.exception import AgentStartError
from pipecatcloud.session import Session, SessionParams


async def main():
    try:
        # Create session object
        session = Session(
            agent_name="my-first-agent",
            api_key=API_KEY,  # Replace with your actual API key
            params=SessionParams(
                use_daily=True,  # Optional: Creates a Daily room
                daily_room_properties={"start_video_off": False},
                data={"key": "value"},
            ),
        )

        # Start the session
        response = await session.start()

        # Get Daily room URL
        daily_url = f"{response['dailyRoom']}?t={response['dailyToken']}"
        print(f"Join Daily room: {daily_url}")

    except AgentStartError as e:
        print(f"Error starting agent: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")


# Run the async function
if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Install Ultravox dependencies

Source: https://docs.pipecat.ai/api-reference/server/services/s2s/ultravox

Install the necessary Pipecat package for Ultravox support.

```bash
uv add "pipecat-ai[ultravox]"
```

--------------------------------

### Install Pipecat

Source: https://docs.pipecat.ai/api-reference/server/services/serializers/exotel

Install the core Pipecat library to access the Exotel serializer.

```bash
uv add "pipecat-ai"
```

--------------------------------

### Configure Language Hints and Context

Source: https://docs.pipecat.ai/api-reference/server/services/stt/soniox

Initialize the service with specific language hints and identification settings.

```python
from pipecat.services.soniox.stt import SonioxSTTService
from pipecat.transcriptions.language import Language

stt = SonioxSTTService(
    api_key=os.getenv("SONIOX_API_KEY"),
    settings=SonioxSTTService.Settings(
        model="stt-rt-v5",
        language_hints=[Language.EN, Language.ES],
        language_hints_strict=True,
        enable_language_identification=True,
    ),
)
```

--------------------------------

### Install Mistral Service Dependency

Source: https://docs.pipecat.ai/api-reference/server/services/llm/mistral

Install the required package using uv.

```bash
uv add "pipecat-ai[mistral]"
```

--------------------------------

### Local Development Server Setup

Source: https://docs.pipecat.ai/pipecat/telephony/exotel-websockets

Run your local Python server for Exotel integration and expose it using ngrok for testing. Use 'server.py' for dial-out and 'bot.py' for dial-in scenarios.

```shell
python server.py  # For dial-out
# OR
python bot.py     # For dial-in

ngrok http 8000
# Use the ngrok URL in your App Bazaar Voicebot applet
```

--------------------------------

### Install Qwen dependencies

Source: https://docs.pipecat.ai/api-reference/server/services/llm/qwen

Install the necessary Pipecat package for Qwen integration.

```bash
uv add "pipecat-ai[qwen]"
```

--------------------------------

### Install Anannas Pipecat Package

Source: https://docs.pipecat.ai/api-reference/server/services/llm/anannas

Install the community-maintained package using uv.

```bash
uv add pipecat-anannas
```

--------------------------------

### Configure Groq STT with Prompt and Temperature

Source: https://docs.pipecat.ai/api-reference/server/services/stt/groq

Initialize the service with a custom prompt for context and a temperature setting for output variability.

```python
from pipecat.services.groq.stt import GroqSTTService

stt = GroqSTTService(
    api_key=os.getenv("GROQ_API_KEY"),
    settings=GroqSTTService.Settings(
        prompt="This is a conversation about artificial intelligence and machine learning.",
        temperature=0.0,
    ),
)
```

--------------------------------

### Install Floe package

Source: https://docs.pipecat.ai/api-reference/server/services/llm/floe

Install the community-maintained pipecat-floe package using uv.

```bash
uv add pipecat-floe
```

--------------------------------

### Initialize GroqTTSService

Source: https://docs.pipecat.ai/api-reference/server/services/tts/groq

Basic instantiation of the service using an API key and voice setting.

```python
from pipecat.services.groq import GroqTTSService

tts = GroqTTSService(
    api_key=os.getenv("GROQ_API_KEY"),
    settings=GroqTTSService.Settings(
        voice="autumn",
    ),
)
```

--------------------------------

### warmup()

Source: https://docs.pipecat.ai/api-reference/server/services/tts/supertonic

Initializes the service and prepares the model for synthesis.

```APIDOC
## warmup()

### Description
Call `warmup()` during application startup before the service is used in a live Pipecat pipeline. This prevents first-request cold-start delays and ensures stable TTS frame ordering.
```

--------------------------------

### Install Fireworks AI dependency

Source: https://docs.pipecat.ai/api-reference/server/services/llm/fireworks

Install the required package using uv.

```bash
uv add "pipecat-ai[fireworks]"
```

--------------------------------

### Install RNNoise dependencies

Source: https://docs.pipecat.ai/api-reference/server/services/audio-filters/rnnoise-filter

Install the necessary package to use the RNNoise filter.

```bash
uv add "pipecat-ai[rnnoise]"
```

--------------------------------

### Build the SDK on Windows

Source: https://docs.pipecat.ai/api-reference/client/cpp/overview

Configure and build the SDK on Windows using the Visual Studio environment and vcpkg presets.

```bash
# Initialize Visual Studio environment
"C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvarsall.bat" amd64
# Configure and build
cmake . -Bbuild --preset vcpkg
cmake --buildbuild --config Release
```

--------------------------------

### Basic Kokoro Service Setup

Source: https://docs.pipecat.ai/api-reference/server/services/tts/kokoro

Initializes the Kokoro service with a default voice setting.

```python
from pipecat.services.kokoro import KokoroTTSService

tts = KokoroTTSService(
    settings=KokoroTTSService.Settings(
        voice="af_heart",
    ),
)
```

--------------------------------

### Install Pipecat CLI

Source: https://docs.pipecat.ai/api-reference/cli/overview

Installs the Pipecat CLI globally using uv.

```bash
uv tool install "pipecat-ai[cli]"
```
Tokens:
Raw