short-io-automation
Scannednpx machina-cli add skill ComposioHQ/awesome-claude-skills/short-io-automation --openclawFiles (1)
SKILL.md
2.9 KB
Short IO Automation via Rube MCP
Automate Short IO operations through Composio's Short IO toolkit via Rube MCP.
Toolkit docs: composio.dev/toolkits/short_io
Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Short IO connection via
RUBE_MANAGE_CONNECTIONSwith toolkitshort_io - Always call
RUBE_SEARCH_TOOLSfirst 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_TOOLSresponds - Call
RUBE_MANAGE_CONNECTIONSwith toolkitshort_io - 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: "Short IO 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 Short IO task"}]
session: {id: "existing_session_id"}
Step 2: Check Connection
RUBE_MANAGE_CONNECTIONS
toolkits: ["short_io"]
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_CONNECTIONSshows ACTIVE status before executing tools - Schema compliance: Use exact field names and types from the search results
- Memory parameter: Always include
memoryinRUBE_MULTI_EXECUTE_TOOLcalls, 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 Short IO-specific use case |
| Connect | RUBE_MANAGE_CONNECTIONS with toolkit short_io |
| 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/short-io-automation/SKILL.mdView on GitHub Overview
Automate Short IO operations through Composio's Short IO toolkit using Rube MCP. This approach emphasizes discovering current tool schemas first and ensuring an active Short IO connection before executing workflows.
How This Skill Works
Connect Rube MCP and fetch real-time tool schemas with RUBE_SEARCH_TOOLS, then establish the Short IO connection via RUBE_MANAGE_CONNECTIONS for the short_io toolkit. Finally, run tools with RUBE_MULTI_EXECUTE_TOOL using the discovered tool_slug and schema-compliant arguments, always including memory and reusing sessions as needed.
When to Use It
- You need to automate recurring Short IO tasks and want up-to-date tool schemas.
- You must verify the Short IO connection is ACTIVE before running workflows.
- You want to discover suitable tools before execution to avoid hardcoding slugs.
- You are performing multi-tool or bulk Short IO operations (e.g., via bulk benches).
- You want to reuse a session ID across steps within a single workflow.
Quick Start
- Step 1: Add Rube MCP as an MCP server (e.g., https://rube.app/mcp) in your client.
- Step 2: Run RUBE_SEARCH_TOOLS for the Short IO use case to fetch current tool slugs and schemas.
- Step 3: Run RUBE_MANAGE_CONNECTIONS with toolkits: ["short_io"]; when ACTIVE, execute tools via RUBE_MULTI_EXECUTE_TOOL using the discovered tool_slug and proper memory and session_id.
Best Practices
- Always search for current tool schemas first (RUBE_SEARCH_TOOLS) before execution.
- Check that the Short IO connection is ACTIVE via RUBE_MANAGE_CONNECTIONS before running tools.
- Use exact field names and types from the search results to ensure schema compliance.
- Include the memory parameter in every RUBE_MULTI_EXECUTE_TOOL call, even if empty.
- Reuse session IDs within a workflow and generate new IDs only for new workflows.
Example Use Cases
- Example 1: Day-to-day Short IO automation — discover tools with RUBE_SEARCH_TOOLS, connect, and execute a chosen tool using a session_id; log results for auditing.
- Example 2: Bulk Short IO ops — discover multiple tools, validate ACTIVE connections, and run several tools in a single session using RUBE_MULTI_EXECUTE_TOOL within RUBE_REMOTE_WORKBENCH.
- Example 3: Schema-change resilience — periodically run RUBE_SEARCH_TOOLS to pick up new tool_slugs and adjust your workflow to the latest schemas.
- Example 4: Session-driven workflow — reuse a single session_id across a sequence of Short IO tasks to minimize setup overhead.
- Example 5: Large result handling — fetch results with pagination tokens from tool outputs and continue until complete, following the Known Pitfalls guidance.
Frequently Asked Questions
Add this skill to your agents
