Siren Model Context Protocol (MCP) Server

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’s 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:

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 →

Add the following to your claude_desktop_config.json. See Claude MCP documentation for more details.

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

Or if you’re using Docker:

{
  "mcpServers": {
    "siren": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "trysiren/mcp",
        "--tools=all",
        "--api-key=YOUR_SIREN_API_KEY"
      ]
    }
  }
}

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’re working with multiple Siren workspaces, specify the workspace ID:

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:

# 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:

npx @trysiren/mcp --tools=all --api-key=YOUR_API_KEY --debug

Using MCP Inspector

The MCP Inspector provides a visual interface for debugging your MCP server.

First, build the server:

npm run build

Run with the MCP Inspector:

# Start MCP Inspector and server with all tools
npx @modelcontextprotocol/inspector node dist/index.js --tools=all --api-key=YOUR_SIREN_API_KEY

Open the inspector in your browser at `http://localhost:6274`

Docker Debugging

For Docker-based debugging:

Build the Docker image:

docker build -t trysiren/mcp .

Run with MCP Inspector:

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

Health Check

Verify your configuration with a simple health check:

npx @trysiren/mcp --tools=messaging.send --api-key=YOUR_SIREN_API_KEY

If the server starts successfully, you’ll see:
```
✅ Siren MCP Server running on stdio
```
You can also check the version:
```
npx @trysiren/mcp --version
```

Troubleshooting

Some of the common issues and solutions are stated below.

Invalid API Key

Tool Not Found

Connection Issues

Permission Denied

Rate Limiting

Examples

Basic Messaging

# Configure for basic messaging
npx @siren/mcp --tools=messaging.send,messaging.getStatus --api-key=YOUR_API_KEY

Template Management

# Configure for template operations
npx @siren/mcp --tools=templates.list,templates.create,templates.update --api-key=YOUR_API_KEY

Workflow Automation

# Configure for workflow automation
npx @siren/mcp --tools=workflows.trigger,workflows.schedule --api-key=YOUR_API_KEY

Full Access

# Configure all available tools
npx @siren/mcp --tools=all --api-key=YOUR_API_KEY

MCP Server

​What is MCP?

​What is the Siren MCP server?

​Available Tools in the Siren MCP Server

​Messaging Tools

​Template Management Tools

​User Management Tools

​Workflow Tools

​Webhook Configuration Tools

​Tool Categories

​Category Mappings

​Getting Started with Siren MCP Server Integrations

​Configuration Options

​Command Line Arguments

​API Key Format

​Workspace Configuration

​Environment Variables

​Debugging

​Debug Mode

​Using MCP Inspector

​Docker Debugging

​Health Check

​Troubleshooting

​Examples

​Basic Messaging

​Template Management

​Workflow Automation

​Full Access