Tasker MCP
An MCP server for Android's Tasker automation app.
dceluis
README
Tasker MCP
This document will guide you through setting up and running the Tasker MCP integration, including instructions for installing dependencies, preparing servers, and updating tasks.
Usage Guide
Step 1: Import the Tasker Profile
- Import
dist/mcp_server.prj.xmlinto your Tasker app. - After importing, run the
MCP generate_api_keytask to generate an API key for secure access.
Step 2: Select and Run Your Server
CLI Server:
- From the
dist/folder, select the correct CLI server binary for your device's architecture, such astasker-mcp-server-cli-aarch64. - Copy both the binary and the
toolDescriptions.jsonfile to your device (phone or PC). - Rename the binary to
mcp-serverafter copying.
Example:
Using scp:
scp dist/tasker-mcp-server-cli-aarch64 user@phone_ip:/data/data/com.termux/files/home/mcp-server
Using adb push:
adb push dist/tasker-mcp-server-cli-aarch64 /data/data/com.termux/files/home/mcp-server
- Run the server in SSE mode with:
./mcp-server --tools /path/to/toolDescriptions.json --tasker-api-key=tk_... --mode sse
- Or call it through the stdio transport:
payload='{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": "tasker_flash_text", "arguments": { "text": "Hi" } } }'
echo $payload | ./mcp-server --tools /path/to/toolDescriptions.json --tasker-api-key=tk_...
Command-Line Flags
The tasker-mcp-server-cli application accepts the following flags:
--tools: Path to JSON file with Tasker tool definitions.--host: Host address to listen on for SSE server (default:0.0.0.0).--port: Port to listen on for SSE server (default:8000).--mode: Transport mode:sse, orstdio(default:stdio).--tasker-host: Tasker server host (default:0.0.0.0).--tasker-port: Tasker server port (default:1821).--tasker-api-key: The Tasker API Key.
Step 3: Connect Your MCP-enabled App
- Connect your MCP-enabled application by pointing it to the running server.
Example Configuration for Claude Desktop with stdio transport
{
"mcpServers": {
"tasker": {
"command": "/home/luis/tasker-mcp/dist/tasker-mcp-server-cli-x86_64",
"args": [
"--tools",
"/home/luis/tasker-mcp/dist/toolDescriptions.json",
"--tasker-host",
"192.168.1.123",
"--tasker-api-key",
"tk_...",
"--mode",
"stdio"
]
}
}
}
Building the CLI Server Yourself
Unix/Linux:
- Install Go using your package manager:
sudo apt-get install golang-go
- Build the CLI server (cross-compiling example for ARM64):
cd cli
GOOS=linux GOARCH=arm64 go build -o dist/tasker-mcp-server-cli-aarch64 main.go
Updating the MCP Profile with Additional Tasks
Due to limitations in Tasker's argument handling, follow these steps carefully to mark tasks as MCP-enabled:
Step 1: Set Task Comment
- Add a comment directly in the task settings. This comment becomes the tool description.
Step 2: Configure Tool Arguments Using Task Variables
Tasker supports only two positional arguments (par1, par2). To work around this, we'll use Task Variables:
- A TaskVariable becomes an MCP argument if:
- Configure on Import: unchecked
- Immutable: true
- Value: empty
After setting the above values you can also set some additional metadata:
- Metadata mapping:
- Type: Derived from Task Variable's type (
number,string,onoff, etc). - Description: Set via the variable's
Promptfield. - Required: If the
Same as Valuefield is checked.
- Type: Derived from Task Variable's type (
Note: Temporarily enable "Configure on Import" to set the Prompt description if hidden, then disable it again. The prompt will survive.\
These steps will make sure valid tool descriptions can be generated when we export our custom project later.
Task Variables cannot be pass-through from other tasks, though, so we need to do one last thing in order to get all the variables from the MCP request properly set.
Step 3: Copy the special action
Copy the action MCP#parse_args to the top of your MCP task to enable argument parsing. You can get this from any of the default tasks. But do not modify this action!
Step 4: Exporting and Generating Updated Tool Descriptions
Now your custom tasks are ready:
- Export your
mcp-serverproject and save it on your PC. - Ensure Node.js is installed, then run:
cd utils
npm install
node xml-to-tools.js /path/to/your/exported/mcp_server.prj.xml > toolDescriptions.json
Use this toolDescriptions.json file with your server.
Happy automation!
Recommended Servers
@kazuph/mcp-taskmanager
Model Context Protocol server for Task Management. This allows Claude Desktop (or any MCP client) to manage and execute tasks in a queue-based system.
Claude Code MCP
An implementation of Claude Code as a Model Context Protocol server that enables using Claude's software engineering capabilities (code generation, editing, reviewing, and file operations) through the standardized MCP interface.
Beamlit MCP Server
An MCP server implementation that enables seamless integration between Beamlit CLI and AI models using the Model Context Protocol standard.
ThingsPanel MCP
An integration server that connects AI models with ThingsPanel IoT platform, allowing AI assistants to interact with IoT devices through natural language for device control, data retrieval, and management operations.
systemd-coredump MCP Server
Enables MCP-capable applications to access, manage, and analyze system core dumps through integration with systemd-coredump functionality.
Terminal Controller for MCP
An MCP server that enables secure terminal command execution, directory navigation, and file system operations through a standardized interface for LLMs.
Shell MCP Server
A Model Context Protocol server that allows LLMs to execute shell commands and receive their output in a controlled manner.
iTerm MCP Server
This MCP server enables users to execute shell commands in the current iTerm2 session through integration with Claude Desktop, facilitating seamless command execution via the Model Context Protocol.
MCP Command Server
A secure server that allows LLM applications like Claude to execute whitelisted system commands with user confirmation and comprehensive security features.
WinTerm MCP
A Model Context Protocol server that provides programmatic access to the Windows terminal, enabling AI models to interact with the Windows command line through standardized tools for writing commands, reading output, and sending control signals.