### Start React Client

Source: https://docs.pipecat.ai/guides/features/gemini-live

Commands to install dependencies and start the React client for Pipecat. Navigate to the example's React directory, install packages using npm, and then run the development server.

```bash
cd examples/react
npm install
npm run dev
```

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

### Client SDKs - Introduction

Source: https://docs.pipecat.ai/deployment/pipecat-cloud/rest-reference/endpoint/agent-create

Guides for getting started with Pipecat client SDKs, including general introductions and migration information.

```APIDOC
## Client SDKs - Introduction

### Description
This section covers the introductory guides for all Pipecat client SDKs, including general introductions, the RTVI standard, and migration guides.

### Pages

- **client/introduction**: General introduction to Pipecat client SDKs.
- **client/rtvi-standard**: Details on the RTVI standard used by the SDKs.
- **client/migration-guide**: Guides for migrating to newer versions of the SDKs.
```

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

### Bot Local Server Output (Text)

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

This is an example of the output seen when the bot's local server starts successfully. It provides the URL to access the bot's interface and confirms the server is running.

```text
🚀 WebRTC server starting at http://localhost:7860/client
 Open this URL in your browser to connect!
 
```

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

### Run Bot Locally (Shell Script)

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

This command executes the bot locally. It requires the 'uv' tool to be installed. The output indicates the server is starting and provides a URL to access the bot in a browser.

```shellscript
uv run bot.py
```

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

### Install Dependencies with UV

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

Synchronizes project dependencies using the 'uv' package manager. This ensures all required libraries are installed in the virtual environment.

```shellscript
uv sync
```

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

### Run Plivo Chatbot Example (Python)

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

This snippet shows how to start the Python server for the Plivo chatbot example and use ngrok to expose it locally. Ensure Python is installed and ngrok is configured to forward traffic to port 8000.

```bash
# Start your server
python server.py

# In another terminal, start ngrok
ngrok http 8000

# Use the ngrok URL in your Plivo XML Application
```

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

### Examples & Recipes

Source: https://docs.pipecat.ai/daily-pstn

Complete applications and quickstart demos to accelerate your Pipecat development.

```APIDOC
## Examples & Recipes

### Description
Explore a collection of complete applications and quickstart demos designed to accelerate your development with Pipecat. This section also includes recipes for specific techniques and code snippets to enhance your Pipecat applications.

### Resources
- **Complete Applications**: Full-fledged examples showcasing various use cases.
- **Quickstart Demos**: Minimal examples to get you started quickly.
- **Code Snippets**: Reusable code for common tasks and advanced features.

### Accessing Examples
Visit the [Examples](https://pipecat.ai/examples) and [Recipes](https://pipecat.ai/recipes) sections on the Pipecat website for the latest resources.

```

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

### Example Pipecat Pipeline Setup in Python

Source: https://context7_llms

Shows a comprehensive example of setting up a Pipecat pipeline, including configuring transport, speech-to-text, LLM, and text-to-speech services, along with context and aggregators.

```python
from pipecat.audio.vad.silero import SileroVADAnalyzer
from pipecat.pipeline import Pipeline
from pipecat.processors.aggregators.llm_context import LLMContext
from pipecat.processors.aggregators.llm_response_universal import LLMContextAggregatorPair
from pipecat.services.cartesia.tts import CartesiaTTSService
from pipecat.services.deepgram.stt import DeepgramSTTService
from pipecat.services.openai.llm import OpenAILLMService
from pipecat.transports.daily.transport import DailyParams, DailyTransport

transport = DailyTransport(
    room_url,
    token,
    "Respond bot",
    DailyParams(
        audio_in_enabled=True,
        audio_out_enabled=True,
        vad_analyzer=SileroVADAnalyzer(),
    ),
)

# Configure services
stt = DeepgramSTTService(api_key=KEY)
llm = OpenAILLMService(api_key=KEY, model="gpt-4o")
tts = CartesiaTTSService(api_key=KEY, voice_id=ID)

# Create context and aggregators
context = LLMContext(
    messages=[{"role": "system", "content": "You are a helpful assistant."}]
)
user_aggregator, assistant_aggregator = LLMContextAggregatorPair(context)
```

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

### Create Environment File

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

Copies the example environment file to create a new environment file. This file will store sensitive API keys.

```shellscript
cp env.example .env
```

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

### Python SDK Overview

Source: https://docs.pipecat.ai/client/js/migration-guide

Provides an introduction to the Pipecat Cloud Python SDK, guiding users on how to get started with its features.

```python
# Placeholder for Python SDK Overview code example
# Refer to /deployment/pipecat-cloud/sdk-reference/overview for details.
```

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

### Pipecat Client with Daily Transport Example (TypeScript React)

Source: https://docs.pipecat.ai/client/react/introduction

Demonstrates a basic setup for using the PipecatClient with the Daily transport layer in a TypeScript React application. This example requires the '@pipecat-ai/client-js', '@pipecat-ai/client-react', and '@pipecat-ai/daily-transport' packages to be installed.

```tsx
import { PipecatClient } from "@pipecat-ai/client-js";
import { PipecatClientProvider, PipecatClientAudio, usePipecatClient } from "@pipecat-ai/client-react";

// Example usage within a React component
function MyComponent() {
  const { client, error, isLoading } = usePipecatClient({
    transport: "daily", // Specify Daily as the transport layer
    // Add other PipecatClient options here, e.g., apiKey, model, etc.
  });

  if (isLoading) {
    return <div>Loading Pipecat client...</div>;
  }

  if (error) {
    return <div>Error initializing Pipecat client: {error.message}</div>;
  }

  // Now you can use the 'client' object to interact with Pipecat
  // For example, to send a message:
  // client.sendMessage("Hello, Pipecat!");

  return (
    <div>
      <h1>Pipecat Client Ready</h1>
      {/* Render your UI elements here */}
      <PipecatClientAudio client={client} />
    </div>
  );
}

// Wrap your application with PipecatClientProvider if needed
// function App() {
//   return (
//     <PipecatClientProvider transport="daily" /* other options */ >
//       <MyComponent />
//     </PipecatClientProvider>
//   );
// }
```

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

### Starting the Pipecat Client Application

Source: https://context7_llms

Commands to set up and run the React client application. This involves navigating to the example directory, installing dependencies using npm, and starting the development server. The client will then be accessible via http://localhost:5173.

```bash
cd examples/react
npm install
npm run dev
```

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

### Run Bot Locally (Shellscript)

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

This command initiates the execution of your bot locally. After setting up your environment and dependencies, this is the final step to start your application. Ensure your .env file is correctly configured before running this command.

```shellscript
uv run
```

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

### React Example: Pipecat Client with Daily Transport

Source: https://docs.pipecat.ai/client/react/introduction

Demonstrates a basic React application setup using the Pipecat React SDK with Daily as the transport layer. It includes client initialization, provider setup, and a component to start a conversation.

```javascript
import { PipecatClient } from "@pipecat-ai/client-js";
import {
  PipecatClientProvider,
  PipecatClientAudio,
  usePipecatClient,
} from "@pipecat-ai/client-react";
import { DailyTransport } from "@pipecat-ai/daily-transport";

// Create the client instance
const client = new PipecatClient({
  transport: new DailyTransport(),
  enableMic: true,
});

// Root component wraps the app with the provider
function App() {
  return (
    <PipecatClientProvider client={client}>
      <VoiceBot />
      <PipecatClientAudio />
    </PipecatClientProvider>
  );
}

// Component using the client
function VoiceBot() {
  const client = usePipecatClient();

  const handleClick = async () => {
    await client.startBotAndConnect({
      endpoint: `${process.env.PIPECAT_API_URL || "/api"}/connect`
    });
  };

  return (
    <button onClick={handleClick}>Start Conversation</button>;
  );
}
```

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

### Running Pipecat Twilio Chatbot Example

Source: https://context7_llms

These shell commands demonstrate how to run the Pipecat Twilio chatbot example. It involves starting ngrok to expose the local server, installing Python dependencies using 'uv sync', and then running the bot script.

```shell
ngrok http 7860
```

```shell
uv sync
```

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

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

### Python: Initiate Bot Greeting and Task on Client Connection

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

This Python code snippet demonstrates how to prompt a bot to start talking by adding a greeting instruction and queuing a context frame when a client connects. It utilizes the `LLMRunFrame` for this purpose.

```python
await task.queue_frames([LLMRunFrame()])
```

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

### Start Pipecat Tail App (Shell Script)

Source: https://docs.pipecat.ai/cli/tail

This code snippet demonstrates how to start the Pipecat Tail app. It includes examples for connecting to a local session and a remote session using a WebSocket URL. Ensure the Pipecat CLI is installed and accessible in your environment.

```shellscript
# Connect to local session (default)
pipecat tail

# Connect to remote session
pipecat tail --url wss://my-bot.example.com
```

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

### Clone Pipecat Quickstart Repository (Shell)

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

This snippet shows how to clone the Pipecat quickstart repository using git. It's a prerequisite for setting up the local development environment. No specific inputs or outputs are detailed, but it requires a git-enabled environment.

```shellscript
git clone https://github.com/pipecat-ai/pipecat-llms.git
cd pipecat-llms
```

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

### Configure Pipeline Processors in Python

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

This Python code snippet demonstrates how to create a pipeline by chaining various processors. It includes input/output transport, speech-to-text, user aggregation, language model interaction, text-to-speech, and assistant aggregation. This setup is crucial for defining the data flow and functionality of an AI-powered application.

```python
# Create the pipeline with the processors
pipeline = Pipeline([
    transport.input(), # Receive audio from browser
    rtvi, # Protocol for client/server messaging and events
    stt, # Speech-to-text (Deepgram)
    user_aggregator, # Add user message to context
    llm, # Language model (OpenAI)
    tts, # Text-to-speech (Cartesia)
    transport.output(), # Send audio back to browser
    assistant_aggregator # Add bot response to context
])
```

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

### Set up and Run Pipecat AI LLMs Bot

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

This snippet demonstrates how to create a WebRTC transport and run the Pipecat AI LLMs bot. It includes asynchronous operations for transport creation and bot execution, along with a standard Python main execution block.

```python
transport = await create_transport(runner_args, transport_params)
await run_bot(transport, runner_args)

if __name__ == "__main__":
  from pipecat.runner.run import main
  main()
```

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

### Install and Use Pipecat CLI (Bash)

Source: https://context7_llms

This section details how to install the Pipecat CLI using uv or pipx and how to use it to scaffold new Pipecat projects. The CLI simplifies project setup by guiding users through platform, transport, AI services, and deployment target selections.

```bash
uv tool install pipecat-ai-cli
# or
pipx install pipecat-ai-cli
```

```bash
pipecat --version
```

```bash
pipecat init
```

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

### Configure Environment Variables

Source: https://docs.pipecat.ai/guides/features/gemini-live

This shows how to copy an example environment file and then configure essential API keys and settings for the application. It involves setting Daily and Gemini API keys and specifying the bot implementation.

```bash
# Remove the hard-coded example room URL
DAILY_SAMPLE_ROOM_URL=

# Add your Daily and Gemini API keys
DAILY_API_KEY=[your key here]
GEMINI_API_KEY=[your key here]

# Use Gemini implementation
BOT_IMPLEMENTATION=gemini
```

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

### Run Pipeline Task with PipelineRunner in Python

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

Illustrates how to execute a defined task using the initialized PipelineRunner. This starts the processing pipeline.

```python
# Finally, run the task using the runner
# This will start the pipeline and begin processing frames
await runner.run(task)
```

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

### Initialize PipecatClient in a React Component (JSX)

Source: https://docs.pipecat.ai/client/introduction

This example demonstrates how to import and initialize the PipecatClient within a React component using JSX. It includes basic setup for the client. Ensure the '@pipecat-ai/client-js' package is installed.

```jsx
// Example: Using PipecatClient in a React component
import { PipecatClient } from "@pipecat-ai/client-js";
```

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

### Define LLM Prompt and Task Execution in Python

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

This snippet demonstrates how to define a system prompt for an LLM and queue a task to execute it. It uses Python's async/await syntax and a hypothetical `LLMRunFrame` for task execution. Dependencies include `_components`, `task`, and `LLMRunFrame`.

```python
jsx(_components.span, {
 style: {
 color: "#0A3069",
 "--shiki-dark": "#CE9178"
 },
 children: "\"system\""
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: ", "
 }), 
jsx(_components.span, {
 style: {
 color: "#0A3069",
 "--shiki-dark": "#CE9178"
 },
 children: "\"content\""
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: ": "
 }), 
jsx(_components.span, {
 style: {
 color: "#0A3069",
 "--shiki-dark": "#CE9178"
 },
 children: "\"Say hello and briefly introduce yourself.\""
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: "})"
 }), 
"\n", 
jsx(_components.span, {
 className: "line",
 children: 
jsx(_components.span, {
 style: {
 color: "#6E7781",
 "--shiki-dark": "#6A9955"
 },
 children: " # Prompt the bot to start talking when the client connects"
 })
 }), 
"\n", 
_jsxs(_components.span, {
 className: "line",
 children: [
jsx(_components.span, {
 style: {
 color: "#CF222E",
 "--shiki-dark": "#C586C0"
 },
 children: " await"
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: " task.queue_frames([LLMRunFrame()])"
 })
 ]
 }), 
"\n", 
jsx(_components.span, {
 className: "line"
 }), 
"\n", 
jsx(_components.span, {
 className: "line",
 children: 
jsx(_components.span, {
 style: {
 color: "#6E7781",
 "--shiki-dark": "#6A9955"
 },
 children: "# Event handler for when a client disconnects"
 })
 }), 
"\n", 
_jsxs(_components.span, {
 className: "line",
 children: [
jsx(_components.span, {
 style: {
 color: "#8250DF",
 "--shiki-dark": "#DCDCAA"
 },
 children: "@transport.event_handler"
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: "("
 }), 
jsx(_components.span, {
 style: {
 color: "#0A3069",
 "--shiki-dark": "#CE9178"
 },
 children: "\"on_client_disconnected\""
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: ")"
 })
 ]
 }), 
"\n", 
_jsxs(_components.span, {
 className: "line",
 children: [
jsx(_components.span, {
 style: {
 color: "#CF222E",
 "--shiki-dark": "#569CD6"
 },
 children: "async"
 }), 
jsx(_components.span, {
 style: {
 color: "#CF222E",
 "--shiki-dark": "#569CD6"
 },
 children: " def"
 }), 
jsx(_components.span, {
 style: {
 color: "#8250DF",
 "--shiki-dark": "#DCDCAA"
 },
 children: " on_client_disconnected"
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: "("
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#9CDCFE"
 },
 children: "transport"
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: ", "
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#9CDCFE"
 },
 children: "client"
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: "):"
 })
 ]
 }), 
"\n", 
_jsxs(_components.span, {
 className: "line",
 children: [
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: " logger.info("
 }), 
jsx(_components.span, {
 style: {
 color: "#CF222E",
 "--shiki-dark": "#569CD6"
 },
 children: "f"
 }), 
jsx(_components.span, {
 style: {
 color: "#0A3069",
 "--shiki-dark": "#CE9178"
 },
 children: "\"Client disconnected\""
 }), 
jsx(_components.span, {
 style: {
 color: "#1F2328",
 "--shiki-dark": "#D4D4D4"
 },
 children: ")"
 })
 ]
 }), 
"\n", 
jsx(_components.span, {
 className: "line",
 children: 
jsx(_components.span, {
 style: {
 color: "#6E7781",
 "--shiki-dark": "#6A9955"
 },
 children: " # Cancel the task when the client disconnects"
 })
 }), 
"\n", 
jsx(_components.span, {
 className: "line",
 children: 
jsx(_components.span, {
 style: {
 color: "#6E7781",
 "--shiki-dark": "#6A9955"
 },
 children: " # This stops the pipeli"
 })
 })
]
```

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

### GET /agents/{agentName}/sessions

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

Get sessions for an agent with filtering and pagination options.

```APIDOC
## GET /agents/{agentName}/sessions

### Description
Get sessions for an agent with filtering and pagination options.

### Method
GET

### Endpoint
/agents/{agentName}/sessions

### Parameters
#### Path Parameters
- **agentName** (string) - Required - The name of the agent whose sessions are to be retrieved.

#### Query Parameters
- **limit** (integer) - Optional - The maximum number of sessions to return.
- **offset** (integer) - Optional - The number of sessions to skip.
- **status** (string) - Optional - Filter sessions by status (e.g., running, stopped).

### Response
#### Success Response (200 OK)
- **sessions** (array) - An array of session objects.
  - **sessionId** (string) - The ID of the session.
  - **startTime** (string) - The time the session started.
  - **endTime** (string) - The time the session ended (if applicable).
  - **status** (string) - The current status of the session.

#### Response Example
```json
{
  "sessions": [
    {
      "sessionId": "session-xyz789",
      "startTime": "2023-10-27T10:00:00Z",
      "endTime": null,
      "status": "running"
    },
    {
      "sessionId": "session-abc123",
      "startTime": "2023-10-26T15:30:00Z",
      "endTime": "2023-10-26T16:00:00Z",
      "status": "stopped"
    }
  ]
}
```
```

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

### Get Session Status Example

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

This example shows how to retrieve the current status of a Pipecat session. It utilizes an HTTP GET request to a specific session endpoint. This is useful for monitoring the state of your AI agents.

```javascript
async function getSessionStatus(sessionId) {
  try {
    const status = await sendHttpRequestToPipecatSession(sessionId, 'status', 'GET');
    console.log(`Session ${sessionId} status:`, status);
    return status;
  } catch (error) {
    console.error('Failed to get session status:', error);
  }
}

// Example usage:
// getSessionStatus('your-session-id');
```

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

### Log in to Pipecat Cloud CLI (Shell)

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

This command logs you into Pipecat Cloud using the Pipecat CLI. Ensure the CLI is installed. Upon execution, you will be provided with a link to authenticate your client.

```shellscript
uv run pipecat cloud auth login
```

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

### GET /agents/{agentName}/logs

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

Get execution logs for an agent with filtering and pagination options.

```APIDOC
## GET /agents/{agentName}/logs

### Description
Get execution logs for an agent with filtering and pagination options.

### Method
GET

### Endpoint
/agents/{agentName}/logs

### Parameters
#### Path Parameters
- **agentName** (string) - Required - The name of the agent whose logs are to be retrieved.

#### Query Parameters
- **limit** (integer) - Optional - The maximum number of log entries to return.
- **offset** (integer) - Optional - The number of log entries to skip.
- **filter** (string) - Optional - A filter string to apply to the logs.

### Response
#### Success Response (200 OK)
- **logs** (array) - An array of log objects.
  - **timestamp** (string) - The timestamp of the log entry.
  - **level** (string) - The log level (e.g., INFO, ERROR).
  - **message** (string) - The log message.

#### Response Example
```json
{
  "logs": [
    {
      "timestamp": "2023-10-27T10:00:00Z",
      "level": "INFO",
      "message": "Agent started successfully."
    },
    {
      "timestamp": "2023-10-27T10:05:15Z",
      "level": "WARN",
      "message": "High memory usage detected."
    }
  ]
}
```
```

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

### Configure and Execute a Pipecat Pipeline (Python)

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

This code defines and configures a Pipecat Pipeline, which processes data through a series of processors including input/output transport, RTVI, speech-to-text, LLM, and text-to-speech. It also sets up a PipelineTask to manage the pipeline's execution, enable metrics, and handle RTVI events using observers. The order of processors is critical for correct data flow.

```python
# Create the pipeline with the processors
pipeline = Pipeline([
    transport.input(),     # Receive audio from browser
    rtvi,                  # Protocol for client/server messaging and events
    stt,                   # Speech-to-text (Deepgram)
    user_aggregator,       # Add user message to context
    llm,                   # Language model (OpenAI)
    tts,                   # Text-to-speech (Cartesia)
    transport.output(),    # Send audio back to browser
    assistant_aggregator,  # Add bot response to context
])

# Create a PipelineTask to manage the pipeline execution
task = PipelineTask(
    pipeline,
    params=PipelineParams(
        enable_metrics=True,
        enable_usage_metrics=True,
    ),
    observers=[RTVIObserver(rtvi)],
)
```

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

### Get Session Status Endpoint Example (Python)

Source: https://context7_llms

Example Python code defining a GET endpoint to retrieve session status information. This endpoint can be called via the Session API to check the state of a running agent session.

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

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

### Clone Pipecat Quickstart Repository

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

Clones the pipecat-quickstart repository from GitHub. This is the initial step to obtain the project files.

```shellscript
git clone https://github.com/pipecat-ai/pipecat-quickstart.git
cd pipecat-quickstart
```

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

### Bot Entry Point and Transport Configuration (Python)

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

Defines the main bot entry point using Pipecat's runner system. It configures transport parameters for different environments like Daily and WebRTC, enabling audio input/output and VAD analysis.

```python
async def bot(runner_args: RunnerArguments):
    """Main bot entry point."""

    # Configure transport parameters for different environments
    transport_params = {
        "daily": lambda: DailyParams(
            audio_in_enabled=True,
            audio_out_enabled=True,
            vad_analyzer=SileroVADAnalyzer(),
        ),
        "webrtc": lambda: TransportParams(
            audio_in_enabled=True,
            audio_out_enabled=True,
            vad_analyzer=SileroVADAnalyzer(),
        ),
    }

    transport = await create_transport(runner_args, transport_params)
    await run_bot(transport, runner_args)

if __name__ == "__main__":
    from pipecat.runner.run import main
    main()
```

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

### Deployment - Overview and Hosting Platforms

Source: https://docs.pipecat.ai/deployment/pipecat-cloud/rest-reference/endpoint/agent-create

Guides on deploying your bot, including general patterns and specific hosting platform instructions.

```APIDOC
## Deployment - Overview and Hosting Platforms

### Description
This section covers the general process of deploying your bot, common deployment patterns, and instructions for various hosting platforms.

### Deploying Your Bot

- **deployment/overview**: General overview of the bot deployment process.
- **deployment/pattern**: Describes common deployment patterns.

#### Hosting Platforms

- **deployment/platforms/pipecat-cloud**: Deployment instructions for Pipecat Cloud.
- **deployment/platforms/fly**: Deployment instructions for Fly.io.
- **deployment/platforms/cerebrium**: Deployment instructions for Cerebrium.
- **deployment/platforms/modal**: Deployment instructions for Modal.
```

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

### Run Pipecat AI LLM Example (Shell)

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

This shell script demonstrates how to run the Pipecat AI LLM bot directly. It includes commands for starting the bot and using ngrok to expose the WebSocket for local development. Ensure ngrok is installed and configured to forward traffic to your bot's port.

```shellscript
# Start your bot directly
python bot.py

# For local development, use ngrok to expose your WebSocket
ngrok http 8000
# Use the ngrok WebSocket URL (wss://abc123.ngrok.io/ws) in your App Bazaar flow
```

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

### Run the Example (Inbound Calls)

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

Instructions for running the Plivo chatbot example locally, including setting up your server and using ngrok to expose your local server.

```APIDOC
## Run the Example

### Description
For local development, use ngrok to expose your local server and then configure your Plivo XML application to use the ngrok URL.

### Steps
1. Start your server:
   ```bash
   python server.py
   ```
2. In another terminal, start ngrok:
   ```bash
   ngrok http 8000
   ```
3. Use the ngrok URL provided by ngrok in your Plivo XML Application's webhook configuration.
```

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

### Deploy to Pipecat Cloud

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

Deploys the application to Pipecat Cloud. This command assumes the Docker image has already been built and pushed.

```shellscript
uv run pipecat cloud deploy
```

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

### Install Pipecat with Provider Dependencies

Source: https://context7_llms

Installs Pipecat along with specific dependencies for Transport, STT, LLM, and TTS providers. This example shows installation for Daily, OpenAI, Deepgram, Cartesia, and Silero.

```bash
pip install "pipecat-ai[daily,openai,deepgram,cartesia,silero]"
```

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

### Get Organization Properties - REST API

Source: https://docs.pipecat.ai/client/js/migration-guide

Retrieves the current values of configurable properties for your organization. This is a GET request to the /properties endpoint.

```openapi
GET /properties
```