> ## Documentation Index
> Fetch the complete documentation index at: https://praison.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Bot vs Gateway

> Choose the right deployment model for your AI agents

Two ways to deploy AI agents for real-time communication: **Bot** for messaging platforms, **Gateway** for custom applications.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph TB
    subgraph "Bot Mode"
        U1[👤 User] -->|Message| P[📱 Platform]
        P -->|Webhook| B[🤖 Bot]
        B -->|Response| P
        P -->|Reply| U1
    end
    
    subgraph "Gateway Mode"
        U2[👤 User] -->|WebSocket| G[🗼 Gateway]
        G -->|Route| A1[🤖 Agent 1]
        G -->|Route| A2[🤖 Agent 2]
        A1 -->|Response| G
        G -->|Deliver| U2
    end
    
    classDef user fill:#8B0000,color:#fff
    classDef platform fill:#189AB4,color:#fff
    classDef bot fill:#8B0000,color:#fff
    classDef gateway fill:#F59E0B,color:#fff
    classDef agent fill:#8B0000,color:#fff
    
    class U1,U2 user
    class P platform
    class B bot
    class G gateway
    class A1,A2 agent
```

***

## Quick Comparison

| Feature | Bot | Gateway |
| - | - | - |
| **Use Case** | Messaging platforms | Custom applications |
| **Platforms** | Telegram, Discord, Slack | Any WebSocket client |
| **Users** | Single-user conversations | Multi-user, multi-agent |
| **Protocol** | Platform-specific | WebSocket |
| **CLI** | `praisonai bot <platform>` | `praisonai serve gateway` |

***

## When to Use Bot

<CardGroup cols={2}>
  <Card title="Team Communication" icon="comments">
    Deploy to Slack/Discord for team assistants
  </Card>

  <Card title="Customer Support" icon="headset">
    Telegram bots for customer interactions
  </Card>

  <Card title="Personal Assistant" icon="user">
    Single-user conversational AI
  </Card>

  <Card title="Quick Deployment" icon="rocket">
    One command to production
  </Card>
</CardGroup>

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Deploy to Telegram in one command
praisonai bot telegram --token $TELEGRAM_BOT_TOKEN --memory --web
```

***

## When to Use Gateway

<CardGroup cols={2}>
  <Card title="Web Applications" icon="globe">
    Custom chat interfaces and dashboards
  </Card>

  <Card title="Multi-Agent Systems" icon="users">
    Coordinate multiple specialized agents
  </Card>

  <Card title="Real-time Dashboards" icon="chart-line">
    Live updates and streaming responses
  </Card>

  <Card title="Custom Protocols" icon="code">
    Full control over communication
  </Card>
</CardGroup>

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Start gateway for custom applications
praisonai serve gateway --port 8765
```

***

## Architecture Deep Dive

<Tabs>
  <Tab title="Bot Architecture">
    ```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    sequenceDiagram
        participant User
        participant Platform as Telegram/Discord/Slack
        participant Bot as PraisonAI Bot
        participant Agent
        
        User->>Platform: Send message
        Platform->>Bot: Webhook/Polling
        Bot->>Agent: Process with tools
        Agent-->>Bot: Response
        Bot->>Platform: Send reply
        Platform-->>User: Display message
    ```

    **Key Points:**

    * Platform handles user authentication
    * Bot receives messages via webhook or polling
    * Multi-agent routing per bot (dm → agent A, group → agent B)
    * Platform-specific features (reactions, threads, etc.)
  </Tab>

  <Tab title="Gateway Architecture">
    ```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    sequenceDiagram
        participant Client as Web Client
        participant Gateway
        participant Session
        participant Agent1 as Agent 1
        participant Agent2 as Agent 2
        
        Client->>Gateway: Connect (WebSocket)
        Gateway->>Session: Create session
        Gateway-->>Client: Session ID
        Client->>Gateway: Join agent-1
        Gateway->>Agent1: Route message
        Agent1->>Agent2: Handoff (if needed)
        Agent2-->>Gateway: Response
        Gateway-->>Client: Deliver response
    ```

    **Key Points:**

    * Direct WebSocket connection
    * Multiple agents per gateway
    * Session-based state management
    * Agent-to-agent communication
  </Tab>
</Tabs>

***

## Feature Comparison

### Capabilities Support

| Capability | Bot | Gateway |
| - | - | - |
| Memory | ✅ `--memory` | ✅ Session state |
| Knowledge/RAG | ✅ `--knowledge` | ✅ Per-agent |
| Tools | ✅ `--tools` | ✅ Per-agent |
| Web Search | ✅ `--web` | ✅ Per-agent |
| Browser | ✅ `--browser` | ✅ Per-agent |
| Thinking Mode | ✅ `--thinking` | ✅ Per-agent |
| Multi-Agent | ✅ Context-based routing | ✅ Multiple agents with routing |
| Multi-Platform | ✅ All 4 platforms concurrently | ✅ WebSocket + bots |
| Custom UI | ❌ Platform UI | ✅ Full control |

### Deployment

| Aspect | Bot | Gateway |
| - | - | - |
| Setup | Platform token required | No external deps |
| Scaling | Multiple bots per platform via `platform:` field | Multiple clients per gateway |
| Auth | Platform handles | You implement |
| SSL | Platform handles | You configure |

***

## Code Examples

<Tabs>
  <Tab title="Bot (Telegram)">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai.bots import TelegramBot
    from praisonaiagents import Agent

    # Create agent with capabilities
    agent = Agent(
        name="assistant",
        instructions="You are a helpful assistant.",
        memory=True,
        knowledge=["./docs/"]
    )

    # Deploy to Telegram
    bot = TelegramBot(
        token="YOUR_BOT_TOKEN",
        agent=agent
    )

    # Start bot
    await bot.start()
    ```

    **CLI equivalent:**

    ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    praisonai bot telegram --token $TOKEN --memory --knowledge
    ```
  </Tab>

  <Tab title="Gateway (WebSocket)">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai.gateway import WebSocketGateway
    from praisonaiagents import Agent, GatewayConfig

    # Create gateway
    config = GatewayConfig(host="0.0.0.0", port=8765)
    gateway = WebSocketGateway(config=config)

    # Register multiple agents
    researcher = Agent(name="researcher", instructions="Research topics")
    writer = Agent(name="writer", instructions="Write content")

    gateway.register_agent(researcher)
    gateway.register_agent(writer)

    # Start gateway
    await gateway.start()
    ```

    **CLI equivalent:**

    ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    praisonai serve gateway --port 8765 --agents agents.yaml
    ```
  </Tab>
</Tabs>

***

## Migration Guide

### Bot to Gateway

Moving from bot to gateway for more control:

<Steps>
  <Step title="Extract Agent Configuration">
    ```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # agents.yaml
    agents:
      - name: assistant
        instructions: Your current bot instructions
        memory: true
        tools:
          - search_web
    ```
  </Step>

  <Step title="Start Gateway">
    ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    praisonai serve gateway --port 8765 --agents agents.yaml
    ```
  </Step>

  <Step title="Connect Your Client">
    ```javascript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    const ws = new WebSocket('ws://localhost:8765/ws');

    ws.onopen = () => {
      ws.send(JSON.stringify({
        type: 'join',
        agent_id: 'assistant'
      }));
    };

    ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      console.log('Response:', data.content);
    };
    ```
  </Step>
</Steps>

***

## Decision Tree

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph TD
    A[Need real-time AI?] -->|Yes| B{Platform?}
    B -->|Telegram/Discord/Slack| C[Use Bot]
    B -->|Custom App| D{Multi-agent?}
    D -->|Yes| E[Use Gateway]
    D -->|No| F{Need custom UI?}
    F -->|Yes| E
    F -->|No| G[Consider Bot or Gateway]
    
    classDef decision fill:#F59E0B,color:#fff
    classDef result fill:#8B0000,color:#fff
    
    class A,B,D,F decision
    class C,E,G result
```

***

## Related

<CardGroup cols={2}>
  <Card title="Bot CLI" icon="robot" href="/docs/cli/bot">
    Full bot CLI reference
  </Card>

  <Card title="Gateway Feature" icon="tower-broadcast" href="/docs/features/gateway">
    Gateway configuration guide
  </Card>

  <Card title="Multi-Agent" icon="users" href="/docs/features/multi-agent">
    Multi-agent coordination
  </Card>

  <Card title="Serve CLI" icon="server" href="/docs/cli/serve">
    All serve commands
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.