What is Rube MCP in this skill?

Rube MCP is the middleware integration used to orchestrate Callingly tools via Composio; you must connect and verify availability before automation.

Do I need to hardcode tool slugs?

No. Always call RUBE_SEARCH_TOOLS to fetch current tool slugs and schemas to avoid outdated or incompatible inputs.

How should I manage sessions and memory?

Reuse session IDs within a workflow for consistency; generate new IDs for new workflows and always include a memory object in RUBE_MULTI_EXECUTE_TOOL calls, even if empty.

callingly-automation

Scanned

npx machina-cli add skill ComposioHQ/awesome-claude-skills/callingly-automation --openclaw

Files (1)

SKILL.md

2.9 KB

Callingly Automation via Rube MCP

Automate Callingly operations through Composio's Callingly toolkit via Rube MCP.

Toolkit docs: composio.dev/toolkits/callingly

Prerequisites

Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
Active Callingly connection via RUBE_MANAGE_CONNECTIONS with toolkit callingly
Always call RUBE_SEARCH_TOOLS first to get current tool schemas

Setup

Get Rube MCP: Add https://rube.app/mcp as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.

Verify Rube MCP is available by confirming RUBE_SEARCH_TOOLS responds
Call RUBE_MANAGE_CONNECTIONS with toolkit callingly
If connection is not ACTIVE, follow the returned auth link to complete setup
Confirm connection status shows ACTIVE before running any workflows

Tool Discovery

Always discover available tools before executing workflows:

RUBE_SEARCH_TOOLS
queries: [{use_case: "Callingly operations", known_fields: ""}]
session: {generate_id: true}

This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.

Core Workflow Pattern

Step 1: Discover Available Tools

RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Callingly task"}]
session: {id: "existing_session_id"}

Step 2: Check Connection

RUBE_MANAGE_CONNECTIONS
toolkits: ["callingly"]
session_id: "your_session_id"

Step 3: Execute Tools

RUBE_MULTI_EXECUTE_TOOL
tools: [{
  tool_slug: "TOOL_SLUG_FROM_SEARCH",
  arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"

Known Pitfalls

Always search first: Tool schemas change. Never hardcode tool slugs or arguments without calling RUBE_SEARCH_TOOLS
Check connection: Verify RUBE_MANAGE_CONNECTIONS shows ACTIVE status before executing tools
Schema compliance: Use exact field names and types from the search results
Memory parameter: Always include memory in RUBE_MULTI_EXECUTE_TOOL calls, even if empty ({})
Session reuse: Reuse session IDs within a workflow. Generate new ones for new workflows
Pagination: Check responses for pagination tokens and continue fetching until complete

Quick Reference

Operation	Approach
Find tools	`RUBE_SEARCH_TOOLS` with Callingly-specific use case
Connect	`RUBE_MANAGE_CONNECTIONS` with toolkit `callingly`
Execute	`RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs
Bulk ops	`RUBE_REMOTE_WORKBENCH` with `run_composio_tool()`
Full schema	`RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef`

Powered by Composio

Source

git clone https://github.com/ComposioHQ/awesome-claude-skills/blob/master/composio-skills/callingly-automation/SKILL.mdView on GitHub

Overview

Automate Callingly operations through Composio's Callingly toolkit via Rube MCP. The workflow emphasizes discovering tool schemas first (RUBE_SEARCH_TOOLS) to stay aligned with current capabilities and avoid hardcoding tool slugs.

How This Skill Works

The skill uses RUBE_SEARCH_TOOLS to fetch available Callingly tool slugs and their input schemas, then verifies the Callingly connection with RUBE_MANAGE_CONNECTIONS. Once ready, it executes tools using RUBE_MULTI_EXECUTE_TOOL, always including memory and a session_id; reuse sessions within a workflow and generate new ones for new workflows.

When to Use It

When starting a new Callingly automation and you need the latest tool schemas
When verifying a stable connection to the Callingly toolkit before execution
When discovering which Callingly tools are available for a task
When executing a tool, including memory and session management
When dealing with large tool results or pagination to fetch all options

Quick Start

Step 1: Ensure RUBE_SEARCH_TOOLS responds and discover Callingly tools
Step 2: Connect to Callingly with RUBE_MANAGE_CONNECTIONS and confirm ACTIVE
Step 3: Execute a discovered tool with RUBE_MULTI_EXECUTE_TOOL, including memory and a session_id

Best Practices

Always call RUBE_SEARCH_TOOLS first to get current tool schemas
Check that RUBE_MANAGE_CONNECTIONS shows ACTIVE before executing tools
Use exact field names and types from the search results
Include memory in RUBE_MULTI_EXECUTE_TOOL calls, even if empty
Reuse session IDs within a workflow; generate new IDs for new workflows; watch for pagination

Example Use Cases

Discover tools for a Callingly operation and execute the chosen tool slug with required arguments pulled from the search results.
Establish and verify an ACTIVE Callingly connection, then run a scheduling or logging tool within the same session.
Batch-run multiple Callingly tools in one session using RUBE_MULTI_EXECUTE_TOOL and a shared memory payload.
If tool results are paginated, continue fetching with RUBE_SEARCH_TOOLS until all options are retrieved.
Perform bulk operations via RUBE_REMOTE_WORKBENCH with run_composio_tool() after confirming tool schemas

Frequently Asked Questions

Add this skill to your agents