Update Modal App: (#1755)

* Update Modal App:

Updated Modal App to include:

1. Latest Modal API usage
2. Ability to launch different Pipecat pipelines, much like the
   simple chatbot example
3. Ability to choose which pipeline is launched via the
   /connect endpoint
4. Added a pipeline option for connecting to a self-hosted LLM
   on Modal
5. Improved READMEs
6. Added a web client for interacting with the Modal deployment

tmp

* Update README

examples/deployment/modal-example/server/app.py

@@ -0,0 +1,307 @@
+"""modal_example.
+
+This module shows a simple example of how to deploy a bot using Modal and FastAPI.
+
+It includes:
+- FastAPI endpoints for starting agents and checking bot statuses.
+- Dynamic loading of bot implementations.
+- Use of a Daily transport for bot communication.
+"""
+
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import importlib
+import os
+from contextlib import asynccontextmanager
+from typing import Any, Dict, Literal
+
+import aiohttp
+import modal
+from fastapi import APIRouter, FastAPI, HTTPException
+from fastapi.responses import JSONResponse, RedirectResponse
+from pydantic import BaseModel
+
+# container specifications for the FastAPI web server
+web_image = (
+    modal.Image.debian_slim(python_version="3.13")
+    .pip_install_from_requirements("requirements.txt")
+    .pip_install("pipecat-ai[daily]")
+    .add_local_dir("src", remote_path="/root/src")
+)
+
+# container specifications for the Pipecat pipeline
+bot_image = (
+    modal.Image.debian_slim(python_version="3.13")
+    .apt_install("ffmpeg")
+    .pip_install_from_requirements("requirements.txt")
+    .pip_install("pipecat-ai[daily,elevenlabs,openai,silero,google]")
+    .add_local_dir("src", remote_path="/root/src")
+)
+
+app = modal.App("pipecat-modal", secrets=[modal.Secret.from_dotenv()])
+
+router = APIRouter()
+
+bot_jobs = {}
+daily_helpers = {}
+
+# Names of all supported bot implementations
+# These correspond to the bot files in the src directory
+BotName = Literal["openai", "gemini", "vllm"]
+
+
+def cleanup():
+    """Cleanup function to terminate all bot processes.
+
+    Called during server shutdown.
+    """
+    for entry in bot_jobs.values():
+        func = modal.FunctionCall.from_id(entry[0])
+        if func:
+            func.cancel()
+
+
+def get_bot_file(bot_name: BotName) -> str:
+    """Retrieve the bot file name corresponding to the provided bot_name.
+
+    Args:
+        bot_name (BotName): The name of the bot (e.g., 'openai', 'gemini', 'vllm').
+
+    Returns:
+        str: The file name corresponding to the bot implementation.
+
+    Raises:
+        ValueError: If the bot name is invalid or not supported.
+    """
+    # bot_implementation = os.getenv("BOT_IMPLEMENTATION", "openai").lower().strip()
+    bot_implementation = bot_name.lower().strip()
+    if not bot_implementation:
+        bot_implementation = "openai"
+    if bot_implementation not in ["openai", "gemini", "vllm"]:
+        raise ValueError(
+            f"Invalid BOT_IMPLEMENTATION: {bot_implementation}. Must be 'openai' or 'gemini' or 'vllm'"
+        )
+
+    return f"bot_{bot_implementation}"
+
+
+def get_runner(path: str, bot_file: str) -> callable:
+    """Dynamically import the run_bot function based on the bot name.
+
+    Args:
+        path (str): The path to the bot files (e.g., 'src').
+        bot_file (str): The file name of the bot implementation (e.g., 'openai', 'gemini', 'vllm').
+
+    Returns:
+        function: The run_bot function from the specified bot module.
+
+    Raises:
+        ImportError: If the specified bot module or run_bot function is not found.
+    """
+    try:
+        # Dynamically construct the module name
+        module_name = f"{path}.{bot_file}"
+        # Import the module
+        module = importlib.import_module(module_name)
+        # Get the run_bot function from the module
+        return getattr(module, "run_bot")
+    except (ImportError, AttributeError) as e:
+        raise ImportError(f"Failed to import run_bot from {module_name}: {e}")
+
+
+async def create_room_and_token() -> tuple[str, str]:
+    """Create a Daily room and generate an authentication token.
+
+    This function checks for existing room URL and token in the environment variables.
+    If not found, it creates a new room using the Daily API and generates a token for it.
+
+    Returns:
+        tuple[str, str]: A tuple containing the room URL and the authentication token.
+
+    Raises:
+        HTTPException: If room creation or token generation fails.
+    """
+    from pipecat.transports.services.helpers.daily_rest import DailyRoomParams
+
+    room_url = os.getenv("DAILY_SAMPLE_ROOM_URL", None)
+    token = os.getenv("DAILY_SAMPLE_ROOM_TOKEN", None)
+    if not room_url:
+        room = await daily_helpers["rest"].create_room(DailyRoomParams())
+        if not room.url:
+            raise HTTPException(status_code=500, detail="Failed to create room")
+        room_url = room.url
+
+        token = await daily_helpers["rest"].get_token(room_url)
+        if not token:
+            raise HTTPException(status_code=500, detail=f"Failed to get token for room: {room_url}")
+
+    return room_url, token
+
+
+@app.function(image=bot_image, min_containers=1)
+async def bot_runner(room_url, token, bot_name: BotName = "openai"):
+    """Launch the provided bot process, providing the given room URL and token for the bot to join.
+
+    Args:
+        room_url (str): The URL of the Daily room where the bot and client will communicate.
+        token (str): The authentication token for the room.
+        bot_name (BotName): The name of the bot implementation to use. Defaults to "openai".
+
+    Raises:
+        HTTPException: If the bot pipeline fails to start.
+    """
+    try:
+        path = "src"
+        bot_file = get_bot_file(bot_name)
+        run_bot = get_runner(path, bot_file)
+
+        print(f"Starting bot process: {bot_file} -u {room_url} -t {token}")
+        await run_bot(room_url, token)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to start bot pipeline: {e}")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """FastAPI lifespan manager that handles startup and shutdown tasks.
+
+    - Creates aiohttp session
+    - Initializes Daily API helper
+    - Cleans up resources on shutdown
+    """
+    from pipecat.transports.services.helpers.daily_rest import DailyRESTHelper
+
+    aiohttp_session = aiohttp.ClientSession()
+    daily_helpers["rest"] = DailyRESTHelper(
+        daily_api_key=os.getenv("DAILY_API_KEY", ""),
+        daily_api_url=os.getenv("DAILY_API_URL", "https://api.daily.co/v1"),
+        aiohttp_session=aiohttp_session,
+    )
+    yield
+    await aiohttp_session.close()
+    cleanup()
+
+
+class ConnectData(BaseModel):
+    """Data provided by client to specify the bot pipeline.
+
+    Attributes:
+        bot_name (BotName): The name of the bot to connect to. Defaults to "openai".
+    """
+
+    bot_name: BotName = "openai"
+
+
+async def start(data: ConnectData):
+    """Internal method to start a bot agent and return the room URL and token.
+
+    Args:
+        data (ConnectData): The data containing the bot name to use.
+
+    Returns:
+        tuple[str, str]: A tuple containing the room URL and token.
+    """
+    room_url, token = await create_room_and_token()
+    launch_bot_func = modal.Function.from_name("pipecat-modal", "bot_runner")
+    function_id = launch_bot_func.spawn(room_url, token, data.bot_name)
+    bot_jobs[function_id] = (function_id, room_url)
+
+    return room_url, token
+
+
+@router.get("/")
+async def start_agent():
+    """A user endpoint for launching a bot agent and redirecting to the created room URL.
+
+    This function retrieves the bot implementation from the environment,
+    starts the bot agent, and redirects the user to the room URL to
+    interact with the bot through a Daily Prebuilt Interface.
+
+    Returns:
+        RedirectResponse: A response that redirects to the room URL.
+    """
+    bot_name = os.getenv("BOT_IMPLEMENTATION", "openai").lower().strip()
+    print(f"Starting bot: {bot_name}")
+    room_url, token = await start(ConnectData(bot_name=bot_name))
+
+    return RedirectResponse(room_url)
+
+
+@router.post("/connect")
+async def rtvi_connect(data: ConnectData) -> Dict[Any, Any]:
+    """A user endpoint for launching a bot agent and retrieving the room/token credentials.
+
+    This function retrieves the bot implementation from the request, if provided,
+    starts the bot agent, and returns the room URL and token for the bot. This allows the
+    client to then connect to the bot using their own RTVI interface.
+
+    Args:
+        data (ConnectData): Optional. The data containing the bot name to use.
+
+    Returns:
+        Dict[Any, Any]: A dictionary containing the room URL and token.
+    """
+    print(f"Starting bot: {data.bot_name}")
+    if data is None or not data.bot_name:
+        data.bot_name = os.getenv("BOT_IMPLEMENTATION", "openai").lower().strip()
+    room_url, token = await start(data)
+
+    return {"room_url": room_url, "token": token}
+
+
+@router.get("/status/{fid}")
+def get_status(fid: str):
+    """Retrieve the status of a bot process by its function ID.
+
+    Args:
+        fid (str): The function ID of the bot process.
+
+    Returns:
+        JSONResponse: A JSON response containing the bot's status and result code.
+
+    Raises:
+        HTTPException: If the bot process with the given ID is not found.
+    """
+    func = modal.FunctionCall.from_id(fid)
+    if not func:
+        raise HTTPException(status_code=404, detail=f"Bot with process id: {fid} not found")
+
+    try:
+        result = func.get(timeout=0)
+        return JSONResponse({"bot_id": fid, "status": "finished", "code": result})
+    except modal.exception.OutputExpiredError:
+        return JSONResponse({"bot_id": fid, "status": "finished", "code": 404})
+    except TimeoutError:
+        return JSONResponse({"bot_id": fid, "status": "running", "code": 202})
+
+
+@app.function(image=web_image, min_containers=1)
+@modal.concurrent(max_inputs=1)
+@modal.asgi_app()
+def fastapi_app():
+    """Create and configure the FastAPI application.
+
+    This function initializes the FastAPI app with middleware, routes, and lifespan management.
+    It is decorated to be used as a Modal ASGI app.
+    """
+    from fastapi.middleware.cors import CORSMiddleware
+
+    # Initialize FastAPI app
+    web_app = FastAPI(lifespan=lifespan)
+
+    web_app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include the endpoints from endpoints.py
+    web_app.include_router(router)
+
+    return web_app

examples/deployment/modal-example/server/env.example

@@ -0,0 +1,14 @@
+DAILY_API_KEY=
+
+# determines which bot file to default to: 'openai', 'gemini', or 'vllm'
+BOT_IMPLEMENTATION=openai
+
+# needed for the openai bot pipeline
+OPENAI_API_KEY=
+ELEVENLABS_API_KEY=
+
+# needed for the gemini live bot pipeline
+GOOGLE_API_KEY=
+
+# needed if you modified the API Key for your self-hosted LLM
+VLLM_API_KEY=

examples/deployment/modal-example/server/requirements.txt

@@ -0,0 +1,2 @@
+python-dotenv==1.0.1
+modal==0.71.3

examples/deployment/modal-example/server/src/bot_gemini.py

@@ -0,0 +1,198 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Gemini Bot Implementation.
+
+This module implements a chatbot using Google's Gemini Multimodal Live model.
+It includes:
+- Real-time audio/video interaction through Daily
+- Animated robot avatar
+- Speech-to-speech model
+
+The bot runs as part of a pipeline that processes audio/video frames and manages
+the conversation flow using Gemini's streaming capabilities.
+"""
+
+import os
+import sys
+
+from dotenv import load_dotenv
+from loguru import logger
+from PIL import Image
+
+from pipecat.audio.vad.silero import SileroVADAnalyzer
+from pipecat.audio.vad.vad_analyzer import VADParams
+from pipecat.frames.frames import (
+    BotStartedSpeakingFrame,
+    BotStoppedSpeakingFrame,
+    Frame,
+    OutputImageRawFrame,
+    SpriteFrame,
+)
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.processors.frameworks.rtvi import RTVIConfig, RTVIObserver, RTVIProcessor
+from pipecat.services.gemini_multimodal_live.gemini import GeminiMultimodalLiveLLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+
+load_dotenv(override=True)
+
+try:
+    logger.remove(0)
+    logger.add(sys.stderr, level="DEBUG")
+except ValueError:
+    # Handle the case where logger is already initialized
+    pass
+
+sprites = []
+script_dir = os.path.dirname(__file__)
+
+for i in range(1, 26):
+    # Build the full path to the image file
+    full_path = os.path.join(script_dir, f"assets/robot0{i}.png")
+    # Get the filename without the extension to use as the dictionary key
+    # Open the image and convert it to bytes
+    with Image.open(full_path) as img:
+        sprites.append(OutputImageRawFrame(image=img.tobytes(), size=img.size, format=img.format))
+
+# Create a smooth animation by adding reversed frames
+flipped = sprites[::-1]
+sprites.extend(flipped)
+
+# Define static and animated states
+quiet_frame = sprites[0]  # Static frame for when bot is listening
+talking_frame = SpriteFrame(images=sprites)  # Animation sequence for when bot is talking
+
+
+class TalkingAnimation(FrameProcessor):
+    """Manages the bot's visual animation states.
+
+    Switches between static (listening) and animated (talking) states based on
+    the bot's current speaking status.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._is_talking = False
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        """Process incoming frames and update animation state.
+
+        Args:
+            frame: The incoming frame to process
+            direction: The direction of frame flow in the pipeline
+        """
+        await super().process_frame(frame, direction)
+
+        # Switch to talking animation when bot starts speaking
+        if isinstance(frame, BotStartedSpeakingFrame):
+            if not self._is_talking:
+                await self.push_frame(talking_frame)
+                self._is_talking = True
+        # Return to static frame when bot stops speaking
+        elif isinstance(frame, BotStoppedSpeakingFrame):
+            await self.push_frame(quiet_frame)
+            self._is_talking = False
+
+        await self.push_frame(frame, direction)
+
+
+async def run_bot(room_url: str, token: str):
+    """Main bot execution function.
+
+    Sets up and runs the bot pipeline including:
+    - Daily video transport with specific audio parameters
+    - Gemini Live multimodal model integration
+    - Voice activity detection
+    - Animation processing
+    - RTVI event handling
+    """
+    # Set up Daily transport with specific audio/video parameters for Gemini
+    transport = DailyTransport(
+        room_url,
+        token,
+        "Chatbot",
+        DailyParams(
+            audio_out_enabled=True,
+            camera_out_enabled=True,
+            camera_out_width=1024,
+            camera_out_height=576,
+            vad_enabled=True,
+            vad_audio_passthrough=True,
+            vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.5)),
+        ),
+    )
+
+    # Initialize the Gemini Multimodal Live model
+    llm = GeminiMultimodalLiveLLMService(
+        api_key=os.getenv("GOOGLE_API_KEY"),
+        voice_id="Puck",  # Aoede, Charon, Fenrir, Kore, Puck
+        transcribe_user_audio=True,
+    )
+
+    messages = [
+        {
+            "role": "user",
+            "content": "You are Chatbot, a friendly, helpful robot. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative and helpful way, but keep your responses brief. Start by introducing yourself.",
+        },
+    ]
+
+    # Set up conversation context and management
+    # The context_aggregator will automatically collect conversation context
+    context = OpenAILLMContext(messages)
+    context_aggregator = llm.create_context_aggregator(context)
+
+    ta = TalkingAnimation()
+
+    #
+    # RTVI events for Pipecat client UI
+    #
+    rtvi = RTVIProcessor(config=RTVIConfig(config=[]))
+
+    pipeline = Pipeline(
+        [
+            transport.input(),
+            rtvi,
+            context_aggregator.user(),
+            llm,
+            ta,
+            transport.output(),
+            context_aggregator.assistant(),
+        ]
+    )
+
+    task = PipelineTask(
+        pipeline,
+        params=PipelineParams(
+            allow_interruptions=True,
+            enable_metrics=True,
+            enable_usage_metrics=True,
+        ),
+        observers=[RTVIObserver(rtvi)],
+    )
+    await task.queue_frame(quiet_frame)
+
+    @rtvi.event_handler("on_client_ready")
+    async def on_client_ready(rtvi):
+        await rtvi.set_bot_ready()
+        # Kick off the conversation
+        await task.queue_frames([context_aggregator.user().get_context_frame()])
+
+    @transport.event_handler("on_first_participant_joined")
+    async def on_first_participant_joined(transport, participant):
+        await transport.capture_participant_transcription(participant["id"])
+
+    @transport.event_handler("on_participant_left")
+    async def on_participant_left(transport, participant, reason):
+        print(f"Participant left: {participant}")
+        await task.cancel()
+
+    runner = PipelineRunner()
+
+    await runner.run(task)

examples/deployment/modal-example/server/src/bot_openai.py

@@ -0,0 +1,226 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""OpenAI Bot Implementation.
+
+This module implements a chatbot using OpenAI's GPT-4 model for natural language
+processing. It includes:
+- Real-time audio/video interaction through Daily
+- Animated robot avatar
+- Text-to-speech using ElevenLabs
+- Support for both English and Spanish
+
+The bot runs as part of a pipeline that processes audio/video frames and manages
+the conversation flow.
+"""
+
+import os
+import sys
+
+from dotenv import load_dotenv
+from loguru import logger
+from PIL import Image
+
+from pipecat.audio.vad.silero import SileroVADAnalyzer
+from pipecat.frames.frames import (
+    BotStartedSpeakingFrame,
+    BotStoppedSpeakingFrame,
+    Frame,
+    OutputImageRawFrame,
+    SpriteFrame,
+)
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.processors.frameworks.rtvi import RTVIConfig, RTVIObserver, RTVIProcessor
+from pipecat.services.elevenlabs.tts import ElevenLabsTTSService
+from pipecat.services.openai.llm import OpenAILLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+
+load_dotenv(override=True)
+
+try:
+    logger.remove(0)
+    logger.add(sys.stderr, level="DEBUG")
+except ValueError:
+    # Handle the case where logger is already initialized
+    pass
+
+sprites = []
+script_dir = os.path.dirname(__file__)
+
+# Load sequential animation frames
+for i in range(1, 26):
+    # Build the full path to the image file
+    full_path = os.path.join(script_dir, f"assets/robot0{i}.png")
+    # Get the filename without the extension to use as the dictionary key
+    # Open the image and convert it to bytes
+    with Image.open(full_path) as img:
+        sprites.append(OutputImageRawFrame(image=img.tobytes(), size=img.size, format=img.format))
+
+# Create a smooth animation by adding reversed frames
+flipped = sprites[::-1]
+sprites.extend(flipped)
+
+# Define static and animated states
+quiet_frame = sprites[0]  # Static frame for when bot is listening
+talking_frame = SpriteFrame(images=sprites)  # Animation sequence for when bot is talking
+
+
+class TalkingAnimation(FrameProcessor):
+    """Manages the bot's visual animation states.
+
+    Switches between static (listening) and animated (talking) states based on
+    the bot's current speaking status.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._is_talking = False
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        """Process incoming frames and update animation state.
+
+        Args:
+            frame: The incoming frame to process
+            direction: The direction of frame flow in the pipeline
+        """
+        await super().process_frame(frame, direction)
+
+        # Switch to talking animation when bot starts speaking
+        if isinstance(frame, BotStartedSpeakingFrame):
+            if not self._is_talking:
+                await self.push_frame(talking_frame)
+                self._is_talking = True
+        # Return to static frame when bot stops speaking
+        elif isinstance(frame, BotStoppedSpeakingFrame):
+            await self.push_frame(quiet_frame)
+            self._is_talking = False
+
+        await self.push_frame(frame, direction)
+
+
+async def run_bot(room_url: str, token: str):
+    """Main bot execution function.
+
+    Sets up and runs the bot pipeline including:
+    - Daily video transport
+    - Speech-to-text and text-to-speech services
+    - Language model integration
+    - Animation processing
+    - RTVI event handling
+    """
+    # Set up Daily transport with video/audio parameters
+    transport = DailyTransport(
+        room_url,
+        token,
+        "Chatbot",
+        DailyParams(
+            audio_out_enabled=True,
+            camera_out_enabled=True,
+            camera_out_width=1024,
+            camera_out_height=576,
+            vad_enabled=True,
+            vad_analyzer=SileroVADAnalyzer(),
+            transcription_enabled=True,
+            #
+            # Spanish
+            #
+            # transcription_settings=DailyTranscriptionSettings(
+            #     language="es",
+            #     tier="nova",
+            #     model="2-general"
+            # )
+        ),
+    )
+
+    # Initialize text-to-speech service
+    tts = ElevenLabsTTSService(
+        api_key=os.getenv("ELEVENLABS_API_KEY"),
+        #
+        # English
+        #
+        voice_id="SAz9YHcvj6GT2YYXdXww",
+        #
+        # Spanish
+        #
+        # model="eleven_multilingual_v2",
+        # voice_id="gD1IexrzCvsXPHUuT0s3",
+    )
+
+    # Initialize LLM service
+    llm = OpenAILLMService(api_key=os.getenv("OPENAI_API_KEY"))
+
+    messages = [
+        {
+            "role": "system",
+            #
+            # English
+            #
+            "content": "You are an incessant one-upper. Start by asking the user how their day is going.",
+            #
+            # Spanish
+            #
+            # "content": "Eres Chatbot, un amigable y útil robot. Tu objetivo es demostrar tus capacidades de una manera breve. Tus respuestas se convertiran a audio así que nunca no debes incluir caracteres especiales. Contesta a lo que el usuario pregunte de una manera creativa, útil y breve. Empieza por presentarte a ti mismo.",
+        },
+    ]
+
+    # Set up conversation context and management
+    # The context_aggregator will automatically collect conversation context
+    context = OpenAILLMContext(messages)
+    context_aggregator = llm.create_context_aggregator(context)
+
+    ta = TalkingAnimation()
+
+    #
+    # RTVI events for Pipecat client UI
+    #
+    rtvi = RTVIProcessor(config=RTVIConfig(config=[]))
+
+    pipeline = Pipeline(
+        [
+            transport.input(),
+            rtvi,
+            context_aggregator.user(),
+            llm,
+            tts,
+            ta,
+            transport.output(),
+            context_aggregator.assistant(),
+        ]
+    )
+
+    task = PipelineTask(
+        pipeline,
+        params=PipelineParams(
+            allow_interruptions=True,
+            enable_metrics=True,
+            enable_usage_metrics=True,
+        ),
+        observers=[RTVIObserver(rtvi)],
+    )
+    await task.queue_frame(quiet_frame)
+
+    @rtvi.event_handler("on_client_ready")
+    async def on_client_ready(rtvi):
+        await rtvi.set_bot_ready()
+        # Kick off the conversation
+        await task.queue_frames([context_aggregator.user().get_context_frame()])
+
+    @transport.event_handler("on_first_participant_joined")
+    async def on_first_participant_joined(transport, participant):
+        await transport.capture_participant_transcription(participant["id"])
+
+    @transport.event_handler("on_participant_left")
+    async def on_participant_left(transport, participant, reason):
+        print(f"Participant left: {participant}")
+        await task.cancel()
+
+    runner = PipelineRunner()
+
+    await runner.run(task)

examples/deployment/modal-example/server/src/bot_vllm.py

@@ -0,0 +1,239 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""OpenAI Bot Implementation.
+
+This module implements a chatbot using OpenAI's GPT-4 model for natural language
+processing. It includes:
+- Real-time audio/video interaction through Daily
+- Animated robot avatar
+- Text-to-speech using ElevenLabs
+- Support for both English and Spanish
+
+The bot runs as part of a pipeline that processes audio/video frames and manages
+the conversation flow.
+"""
+
+import os
+import sys
+from typing import List
+
+from dotenv import load_dotenv
+from loguru import logger
+from openai.types.chat import ChatCompletionMessageParam
+from PIL import Image
+
+from pipecat.audio.vad.silero import SileroVADAnalyzer
+from pipecat.frames.frames import (
+    BotStartedSpeakingFrame,
+    BotStoppedSpeakingFrame,
+    Frame,
+    OutputImageRawFrame,
+    SpriteFrame,
+)
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.processors.frameworks.rtvi import RTVIConfig, RTVIObserver, RTVIProcessor
+from pipecat.services.elevenlabs.tts import ElevenLabsTTSService
+from pipecat.services.openai.llm import OpenAILLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+
+load_dotenv(override=True)
+
+try:
+    logger.remove(0)
+    logger.add(sys.stderr, level="DEBUG")
+except ValueError:
+    # Handle the case where logger is already initialized
+    pass
+
+# REPLACE WITH YOUR MODAL URL ENDPOINT
+modal_url = "https://<Modal workspace>--example-vllm-openai-compatible-serve.modal.run"
+api_key = os.getenv("VLLM_API_KEY", "super-secret-key")
+
+
+sprites = []
+script_dir = os.path.dirname(__file__)
+
+# Load sequential animation frames
+for i in range(1, 26):
+    # Build the full path to the image file
+    full_path = os.path.join(script_dir, f"assets/robot0{i}.png")
+    # Get the filename without the extension to use as the dictionary key
+    # Open the image and convert it to bytes
+    with Image.open(full_path) as img:
+        sprites.append(OutputImageRawFrame(image=img.tobytes(), size=img.size, format=img.format))
+
+# Create a smooth animation by adding reversed frames
+flipped = sprites[::-1]
+sprites.extend(flipped)
+
+# Define static and animated states
+quiet_frame = sprites[0]  # Static frame for when bot is listening
+talking_frame = SpriteFrame(images=sprites)  # Animation sequence for when bot is talking
+
+
+class TalkingAnimation(FrameProcessor):
+    """Manages the bot's visual animation states.
+
+    Switches between static (listening) and animated (talking) states based on
+    the bot's current speaking status.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._is_talking = False
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        """Process incoming frames and update animation state.
+
+        Args:
+            frame: The incoming frame to process
+            direction: The direction of frame flow in the pipeline
+        """
+        await super().process_frame(frame, direction)
+
+        # Switch to talking animation when bot starts speaking
+        if isinstance(frame, BotStartedSpeakingFrame):
+            if not self._is_talking:
+                await self.push_frame(talking_frame)
+                self._is_talking = True
+        # Return to static frame when bot stops speaking
+        elif isinstance(frame, BotStoppedSpeakingFrame):
+            await self.push_frame(quiet_frame)
+            self._is_talking = False
+
+        await self.push_frame(frame, direction)
+
+
+async def run_bot(room_url: str, token: str):
+    """Main bot execution function.
+
+    Sets up and runs the bot pipeline including:
+    - Daily video transport
+    - Speech-to-text and text-to-speech services
+    - Language model integration
+    - Animation processing
+    - RTVI event handling
+    """
+    # Set up Daily transport with video/audio parameters
+    transport = DailyTransport(
+        room_url,
+        token,
+        "Chatbot",
+        DailyParams(
+            audio_out_enabled=True,
+            camera_out_enabled=True,
+            camera_out_width=1024,
+            camera_out_height=576,
+            vad_enabled=True,
+            vad_analyzer=SileroVADAnalyzer(),
+            transcription_enabled=True,
+            #
+            # Spanish
+            #
+            # transcription_settings=DailyTranscriptionSettings(
+            #     language="es",
+            #     tier="nova",
+            #     model="2-general"
+            # )
+        ),
+    )
+
+    # Initialize text-to-speech service
+    tts = ElevenLabsTTSService(
+        api_key=os.getenv("ELEVENLABS_API_KEY"),
+        #
+        # English
+        #
+        voice_id="D38z5RcWu1voky8WS1ja",
+        #
+        # Spanish
+        #
+        # model="eleven_multilingual_v2",
+        # voice_id="gD1IexrzCvsXPHUuT0s3",
+    )
+
+    # Initialize LLM service
+    llm = OpenAILLMService(
+        # To use OpenAI
+        api_key=api_key,
+        # Or, to use a local vLLM (or similar) api server
+        model="neuralmagic/Meta-Llama-3.1-8B-Instruct-quantized.w4a16",
+        base_url=f"{modal_url}/v1",
+    )
+
+    messages = [
+        {
+            "role": "system",
+            #
+            # English
+            #
+            "content": "You are a salesman for Modal, the cloud-native serverless Python computing platform.",
+            #
+            # Spanish
+            #
+            # "content": "Eres Chatbot, un amigable y útil robot. Tu objetivo es demostrar tus capacidades de una manera breve. Tus respuestas se convertiran a audio así que nunca no debes incluir caracteres especiales. Contesta a lo que el usuario pregunte de una manera creativa, útil y breve. Empieza por presentarte a ti mismo.",
+        },
+    ]
+
+    # Set up conversation context and management
+    # The context_aggregator will automatically collect conversation context
+    context = OpenAILLMContext(messages)
+    context_aggregator = llm.create_context_aggregator(context)
+
+    ta = TalkingAnimation()
+
+    #
+    # RTVI events for Pipecat client UI
+    #
+    rtvi = RTVIProcessor(config=RTVIConfig(config=[]))
+
+    pipeline = Pipeline(
+        [
+            transport.input(),
+            rtvi,
+            context_aggregator.user(),
+            llm,
+            tts,
+            ta,
+            transport.output(),
+            context_aggregator.assistant(),
+        ]
+    )
+
+    task = PipelineTask(
+        pipeline,
+        params=PipelineParams(
+            allow_interruptions=True,
+            enable_metrics=True,
+            enable_usage_metrics=True,
+        ),
+        observers=[RTVIObserver(rtvi)],
+    )
+    await task.queue_frame(quiet_frame)
+
+    @rtvi.event_handler("on_client_ready")
+    async def on_client_ready(rtvi):
+        await rtvi.set_bot_ready()
+        # Kick off the conversation
+        await task.queue_frames([context_aggregator.user().get_context_frame()])
+
+    @transport.event_handler("on_first_participant_joined")
+    async def on_first_participant_joined(transport, participant):
+        await transport.capture_participant_transcription(participant["id"])
+
+    @transport.event_handler("on_participant_left")
+    async def on_participant_left(transport, participant, reason):
+        print(f"Participant left: {participant}")
+        await task.cancel()
+
+    runner = PipelineRunner()
+
+    await runner.run(task)

examples/deployment/modal-example/server/src/runner.py

@@ -0,0 +1,84 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import argparse
+import asyncio
+import importlib
+import os
+
+
+def get_bot_file(arg_bot: str | None) -> str:
+    bot_implementation = arg_bot or os.getenv("BOT_IMPLEMENTATION", "openai").lower().strip()
+    if not bot_implementation:
+        bot_implementation = "openai"
+    if bot_implementation not in ["openai", "gemini", "vllm"]:
+        raise ValueError(
+            f"Invalid BOT_IMPLEMENTATION: {bot_implementation}. Must be 'openai' or 'gemini'"
+        )
+    return f"bot_{bot_implementation}"
+
+
+def get_runner(bot_file: str):
+    """Dynamically import the run_bot function based on the bot name.
+
+    Args:
+        bot_name (str): The name of the bot implementation (e.g., 'openai', 'gemini').
+
+    Returns:
+        function: The run_bot function from the specified bot module.
+
+    Raises:
+        ImportError: If the specified bot module or run_bot function is not found.
+    """
+    try:
+        # Dynamically construct the module name
+        module_name = f"{bot_file}"
+        # Import the module
+        module = importlib.import_module(module_name)
+        # Get the run_bot function from the module
+        return getattr(module, "run_bot")
+    except (ImportError, AttributeError) as e:
+        raise ImportError(f"Failed to import run_bot from {module_name}: {e}")
+
+
+def main():
+    """Parse the args to launch the appropriate bot using the given room/token."""
+    parser = argparse.ArgumentParser(description="Daily AI SDK Bot Sample")
+    parser.add_argument(
+        "-u", "--url", type=str, required=False, help="URL of the Daily room to join"
+    )
+    parser.add_argument(
+        "-t",
+        "--token",
+        type=str,
+        required=False,
+        help="Daily room token",
+    )
+    parser.add_argument(
+        "-b",
+        "--bot",
+        type=str,
+        required=False,
+        help="Bot runner to use (e.g., openai, gemini)",
+    )
+
+    args, unknown = parser.parse_known_args()
+
+    url = args.url or os.getenv("DAILY_SAMPLE_ROOM_URL")
+    token = args.token or os.getenv("DAILY_SAMPLE_ROOM_TOKEN")
+    bot_file = get_bot_file(args.bot)
+
+    if not url:
+        raise Exception(
+            "No Daily room specified. use the -u/--url option from the command line, or set DAILY_SAMPLE_ROOM_URL in your environment to specify a Daily room URL."
+        )
+
+    run_bot = get_runner(bot_file)
+    asyncio.run(run_bot(url, token))
+
+
+if __name__ == "__main__":
+    main()