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

# Siren Model Context Protocol (MCP) Server

> Use the Siren MCP server to make Siren accessible to LLMs and AI agents via tool calling.

## What is MCP?

**Model Context Protocol (MCP)** is a framework that allows external systems to pass structured, real-time information to large language models (LLMs) like GPT during each interaction. It bridges the gap between stateless systems such as REST APIs or command-line tools and the varying contextual needs of modern applications. By supplying this additional context, MCP enables the model to produce more accurate, relevant, and consistent responses.
At a technical level, MCP works by attaching a structured JSON payload to the user's prompt at runtime. This payload carries background details such as the user's identity, recent actions, task-specific instructions, or relevant domain knowledge. This is referred to as **runtime context** — data that helps the model understand the situation in which it is being used, without needing to ask for that information in the prompt itself. While invisible in the model's final response, this context directly influences how the model interprets the prompt and generates output.

## What is the Siren MCP server?

When it comes to Siren, the **Model Context Protocol (MCP) Server** serves as the integration layer that enables LLM-powered environments to interact with the Siren platform using standardized function calls. It acts as a communication bridge, allowing language models to trigger messaging workflows and retrieve delivery insights in real time.
Rather than manually composing HTTP requests or managing channel-specific logic, AI agents can call predefined functions like `messaging.send`, `users.add`, or `workflows.schedule`. These are optimized for channels including **Email, Slack, SMS, WhatsApp**, and others, making it easy to embed messaging actions into intelligent, event-driven workflows.
By abstracting the messaging infrastructure behind clean, callable interfaces, the Siren MCP Server allows developers to build smarter, more responsive AI agents that can operate autonomously across user-facing communication channels.
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

## Available Tools in the Siren MCP Server

The Siren MCP server provides a suite of standardized tools that LLM agents can call during runtime. These tools enable seamless integration with Siren's messaging, template, user, workflow, and webhook infrastructure.

### Messaging Tools

| Tool                   | Description                                        |
| ---------------------- | -------------------------------------------------- |
| `messaging.send`       | Send a message to a recipient via a chosen channel |
| `messaging.getStatus`  | Get the status of a sent message                   |
| `messaging.getReplies` | Get replies to a sent message                      |

### Template Management Tools

| Tool                | Description                         |
| ------------------- | ----------------------------------- |
| `templates.list`    | List available message templates    |
| `templates.create`  | Create a new message template       |
| `templates.update`  | Update an existing message template |
| `templates.delete`  | Delete a message template           |
| `templates.publish` | Publish a template for use          |

### User Management Tools

| Tool           | Description                  |
| -------------- | ---------------------------- |
| `users.add`    | Add a new user to the system |
| `users.update` | Update an existing user      |
| `users.delete` | Delete a user                |

### Workflow Tools

| Tool                    | Description                              |
| ----------------------- | ---------------------------------------- |
| `workflows.trigger`     | Trigger a workflow execution             |
| `workflows.triggerBulk` | Trigger multiple workflow executions     |
| `workflows.schedule`    | Schedule a workflow for future execution |

### Webhook Configuration Tools

| Tool                             | Description                     |
| -------------------------------- | ------------------------------- |
| `webhooks.configureNotification` | Configure notification webhooks |
| `webhooks.configureInbound`      | Configure inbound webhooks      |

***

### Tool Categories

To simplify configuration, Siren MCP supports tool categories — predefined groups of related tools that can be referenced using a single flag.

#### Category Mappings

| Category                                                                          | Included Tools                                                                                    | Usage Example           |
| --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | ----------------------- |
| `communication`                                                                   | `messaging.send`, `messaging.getStatus`, `messaging.getReplies`                                   | `--tools=communication` |
| `content`                                                                         | `templates.list`, `templates.create`, `templates.update`, `templates.delete`, `templates.publish` | `--tools=content`       |
| `identity`                                                                        | `users.add`, `users.update`, `users.delete`                                                       | `--tools=identity`      |
| `automation`                                                                      | `workflows.trigger`, `workflows.triggerBulk`, `workflows.schedule`                                | `--tools=automation`    |
| `integration`                                                                     | `webhooks.configureNotification`, `webhooks.configureInbound`                                     | `--tools=integration`   |
| You can also combine multiple categories or individual tools in a single command: |                                                                                                   |                         |

```bash theme={null}
npx @trysiren/mcp --tools=communication,templates.create,automation --api-key=YOUR_API_KEY
```

***

## Getting Started with Siren MCP Server Integrations

To get started with the Siren MCP server, you’ll need an API key to authenticate your access. If you’ve already signed up, you may have received this key during onboarding. Otherwise, you can generate one from the **Siren Dashboard** under `Settings > Configuration > API Keys`.
Once you have the API key, you can configure the Siren MCP server within any AI application that supports the Model Context Protocol (MCP). While we’ve included integration examples for tools like Clause, VS Code, and CLI-based agents, the same approach applies to any MCP-compatible environment.
[Learn more about generating and managing API keys →](#link-to-your-api-key-docs)

<Tabs>
  <Tab title="Claude Desktop">
    Add the following to your `claude_desktop_config.json`. See [Claude MCP documentation](https://modelcontextprotocol.io/quickstart/user) for more details.

    ```json theme={null}
    {
      "mcpServers": {
        "siren": {
          "command": "npx",
          "args": [
            "-y",
            "@trysiren/mcp",
            "--tools=all",
            "--api-key=YOUR_SIREN_API_KEY"
          ]
        }
      }
    }
    ```

    **Or if you are using Docker:**

    ```json theme={null}
    {
      "mcpServers": {
        "siren": {
          "command": "docker",
          "args": [
            "run",
            "--rm",
            "-i",
            "trysiren/mcp",
            "--tools=all",
            "--api-key=YOUR_SIREN_API_KEY"
          ]
        }
      }
    }
    ```
  </Tab>

  <Tab title="VS Code">
    VS Code supports both workspace-specific and user-level MCP configurations.

    #### Workspace Configuration

    Add a `.vscode/mcp.json` file in your workspace:

    ```json theme={null}
    {
      "mcp": {
        "servers": {
          "siren": {
            "command": "npx",
            "args": [
              "-y",
              "@trysiren/mcp",
              "--tools=messaging.send,templates.list,workflows.trigger",
              "--api-key=YOUR_SIREN_API_KEY"
            ]
          }
        }
      }
    }
    ```

    #### User Settings

    Add to your VS Code user settings:

    ```json theme={null}
    {
      "mcp.servers": {
        "siren": {
          "command": "npx",
          "args": [
            "-y",
            "@trysiren/mcp",
            "--tools=all",
            "--api-key=YOUR_SIREN_API_KEY"
          ]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Cursor">
    Cursor uses the same configuration format as VS Code. Add this to your settings:

    ```json theme={null}
    {
      "mcp.servers": {
        "siren": {
          "command": "npx",
          "args": [
            "-y",
            "@trysiren/mcp",
            "--tools=all",
            "--api-key=YOUR_SIREN_API_KEY"
          ]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Amazon Q CLI">
    Configure Amazon Q CLI to use the Siren MCP server:

    ```bash theme={null}
    q configure mcp add-server siren \
      --command "npx" \
      --args "-y,@trysiren/mcp,--tools=all,--api-key=YOUR_SIREN_API_KEY"
    ```
  </Tab>

  <Tab title="Other MCP Clients">
    The Siren MCP server is compatible with any client that supports the Model Context Protocol standard. Here are configuration examples for popular MCP-compatible platforms:

    ### 5ire Desktop

    Configure in 5ire's MCP settings:

    ```json theme={null}
    {
      "servers": {
        "siren": {
          "command": "npx",
          "args": ["-y", "@trysiren/mcp", "--tools=all", "--api-key=YOUR_SIREN_API_KEY"]
        }
      }
    }
    ```

    ### FLUJO

    Add to FLUJO's workflow configuration:

    ```json theme={null}
    {
      "mcp_servers": {
        "siren": {
          "command": "npx -y @trysiren/mcp --tools=all --api-key=YOUR_SIREN_API_KEY"
        }
      }
    }
    ```

    ### Zed Editor

    Configure in Zed's assistant settings:

    ```json theme={null}
    {
      "assistant": {
        "mcp_servers": {
          "siren": {
            "command": "npx",
            "args": ["-y", "@trysiren/mcp", "--tools=all", "--api-key=YOUR_SIREN_API_KEY"]
          }
        }
      }
    }
    ```

    ### Replit

    Add to your Replit project's MCP configuration:

    ```json theme={null}
    {
      "mcp": {
        "servers": {
          "siren": "npx -y @trysiren/mcp --tools=all --api-key=YOUR_SIREN_API_KEY"
        }
      }
    }
    ```

    ### Codeium

    Configure in Codeium's extensions:

    ```json theme={null}
    {
      "mcp.servers.siren": {
        "command": "npx",
        "args": ["-y", "@trysiren/mcp", "--tools=all", "--api-key=YOUR_SIREN_API_KEY"]
      }
    }
    ```
  </Tab>
</Tabs>

***

## **Configuration Options**

### **Command Line Arguments**

| **Argument**  | **Description**                         | **Default**       | **Example**                             |
| :------------ | :-------------------------------------- | :---------------- | :-------------------------------------- |
| `--tools`     | Comma-separated list of tools to enable | none              | `--tools=messaging.send,templates.list` |
| `--api-key`   | Your Siren API key                      | none              | `--api-key=sk_siren_...`                |
| `--workspace` | Siren workspace ID                      | Default workspace | `--workspace=ws_abc123`                 |
| `--port`      | Port for HTTP server mode               | 3000              | `--port=8080`                           |
| `--debug`     | Enable debug logging                    | false             | `--debug`                               |

### **API Key Format**

Siren supports multiple API key formats:

| **Format**     | **Description**            | **Use Case**            |
| :------------- | :------------------------- | :---------------------- |
| `sk_siren_...` | Standard Siren API key     | General purpose         |
| `sk_test_...`  | Test environment key       | Development and testing |
| `sk_live_...`  | Production environment key | Production systems      |

### **Workspace Configuration**

If you are working with multiple Siren workspaces, specify the workspace ID:

```bash theme={null}
npx @trysiren/mcp --tools=all --api-key=YOUR_API_KEY --workspace=ws_your_workspace_id
```

### **Environment Variables**

You can set environment variables instead of passing API keys as arguments:

```bash theme={null}
# API key
export SIREN_API_KEY=sk_siren_your_api_key
# Workspace ID (optional)
export SIREN_WORKSPACE=ws_your_workspace_id
# Run with environment variables
npx @trysiren/mcp --tools=all
```

***

## **Debugging**

### **Debug Mode**

Enable verbose logging with the `--debug` flag:

```bash theme={null}
npx @trysiren/mcp --tools=all --api-key=YOUR_API_KEY --debug
```

### **Using MCP Inspector**

The [**MCP Inspector**](https://modelcontextprotocol.io/docs/tools/inspector) provides a visual interface for debugging your MCP server.

<Steps>
  <Step title="First, build the server:">
    ```bash theme={null}
    npm run build
    ```
  </Step>

  <Step title="Run with the MCP Inspector:">
    ```bash theme={null}
    # Start MCP Inspector and server with all tools
    npx @modelcontextprotocol/inspector node dist/index.js --tools=all --api-key=YOUR_SIREN_API_KEY
    ```
  </Step>

  <Step title="Open the inspector in your browser at `http://localhost:6274`">
    Open the URL in your web browser to access the debugging interface.
  </Step>
</Steps>

### **Docker Debugging**

For Docker-based debugging:

<Steps>
  <Step title="Build the Docker image:">
    ```bash theme={null}
    docker build -t trysiren/mcp .
    ```
  </Step>

  <Step title="Run with MCP Inspector:">
    ```bash theme={null}
    docker run -p 3000:3000 -p 5173:5173 -v /var/run/docker.sock:/var/run/docker.sock \
    mcp/inspector docker run --rm -i trysiren/mcp --tools=all --api-key=YOUR_SIREN_API_KEY
    ```
  </Step>
</Steps>

### **Health Check**

* Verify your configuration with a simple health check:
  ```bash theme={null}
  npx @trysiren/mcp --tools=messaging.send --api-key=YOUR_SIREN_API_KEY
  ```
* If the server starts successfully, you will see:
  ```bash theme={null}
  ✅ Siren MCP Server running on stdio
  ```
* You can also check the version:
  ```bash theme={null}
  npx @trysiren/mcp --version
  ```

## Troubleshooting

Some of the common issues and solutions are stated below.

<AccordionGroup>
  <Accordion title="Invalid API Key">
    **Possible Causes**

    * Incorrect format
    * Expired key
    * Key not set properly
      **Solutions**
    * Ensure key starts with `sk_siren_`, `sk_test_`, or `sk_live_`
    * Check your environment variables or CLI argument
    * Generate a new API key from the Siren dashboard if needed
  </Accordion>

  <Accordion title="Tool Not Found">
    **Possible Causes**

    * Typo in tool name
    * Tool not enabled
    * Outdated MCP package
      **Solutions**
    * Verify tool name (case-sensitive)
    * Add the tool to the `--tools` list in the command
    * Update to the latest MCP version
  </Accordion>

  <Accordion title="Connection Issues">
    **Possible Causes**

    * Network problems
    * Firewall blocking
    * API endpoint down
      **Solutions**
    * Check your internet connection
    * Configure firewall exceptions for outbound calls
    * Verify Siren API availability at [status.trysiren.io](https://status.trysiren.io)
  </Accordion>

  <Accordion title="Permission Denied">
    **Possible Causes**

    * Insufficient API key permissions
    * Workspace-specific access restrictions
      **Solutions**
    * Ensure your API key has required scopes
    * Check your workspace access level
    * Contact [Siren Support](mailto:support@trysiren.io) if the issue persists
  </Accordion>

  <Accordion title="Rate Limiting">
    **Possible Causes**

    * Too many requests in a short time
    * Plan quota exceeded
      **Solutions**
    * Implement retry logic or request throttling
    * Upgrade your Siren plan if you are consistently hitting limits
  </Accordion>
</AccordionGroup>

## Examples

### Basic Messaging

```bash theme={null}
# Configure for basic messaging
npx @siren/mcp --tools=messaging.send,messaging.getStatus --api-key=YOUR_API_KEY
```

### Template Management

```bash theme={null}
# Configure for template operations
npx @siren/mcp --tools=templates.list,templates.create,templates.update --api-key=YOUR_API_KEY
```

### Workflow Automation

```bash theme={null}
# Configure for workflow automation
npx @siren/mcp --tools=workflows.trigger,workflows.schedule --api-key=YOUR_API_KEY
```

### Full Access

```bash theme={null}
# Configure all available tools
npx @siren/mcp --tools=all --api-key=YOUR_API_KEY
```