Merge pull request #183 from sohamganatra/add-all-874-composio-toolkit-skills

Add automation skills for all 874 Composio toolkits

-21risk-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: -21risk-automation
+description: "Automate 21risk tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# 21risk Automation via Rube MCP
+
+Automate 21risk operations through Composio's 21risk toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/_21risk](https://composio.dev/toolkits/_21risk)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active 21risk connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `_21risk`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `_21risk`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "21risk 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 21risk task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["_21risk"]
+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 21risk-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `_21risk` |
+| 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](https://composio.dev)*

-2chat-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: -2chat-automation
+description: "Automate 2chat tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# 2chat Automation via Rube MCP
+
+Automate 2chat operations through Composio's 2chat toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/_2chat](https://composio.dev/toolkits/_2chat)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active 2chat connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `_2chat`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `_2chat`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "2chat 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 2chat task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["_2chat"]
+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 2chat-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `_2chat` |
+| 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](https://composio.dev)*

ably-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ably-automation
+description: "Automate Ably tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ably Automation via Rube MCP
+
+Automate Ably operations through Composio's Ably toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ably](https://composio.dev/toolkits/ably)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ably connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ably`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ably`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ably 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 Ably task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ably"]
+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 Ably-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ably` |
+| 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](https://composio.dev)*

abstract-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: abstract-automation
+description: "Automate Abstract tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Abstract Automation via Rube MCP
+
+Automate Abstract operations through Composio's Abstract toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/abstract](https://composio.dev/toolkits/abstract)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Abstract connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `abstract`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `abstract`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Abstract 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 Abstract task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["abstract"]
+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 Abstract-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `abstract` |
+| 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](https://composio.dev)*

abuselpdb-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: abuselpdb-automation
+description: "Automate Abuselpdb tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Abuselpdb Automation via Rube MCP
+
+Automate Abuselpdb operations through Composio's Abuselpdb toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/abuselpdb](https://composio.dev/toolkits/abuselpdb)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Abuselpdb connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `abuselpdb`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `abuselpdb`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Abuselpdb 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 Abuselpdb task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["abuselpdb"]
+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 Abuselpdb-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `abuselpdb` |
+| 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](https://composio.dev)*

abyssale-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: abyssale-automation
+description: "Automate Abyssale tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Abyssale Automation via Rube MCP
+
+Automate Abyssale operations through Composio's Abyssale toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/abyssale](https://composio.dev/toolkits/abyssale)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Abyssale connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `abyssale`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `abyssale`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Abyssale 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 Abyssale task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["abyssale"]
+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 Abyssale-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `abyssale` |
+| 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](https://composio.dev)*

accelo-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: accelo-automation
+description: "Automate Accelo tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Accelo Automation via Rube MCP
+
+Automate Accelo operations through Composio's Accelo toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/accelo](https://composio.dev/toolkits/accelo)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Accelo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `accelo`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `accelo`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Accelo 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 Accelo task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["accelo"]
+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 Accelo-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `accelo` |
+| 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](https://composio.dev)*

accredible-certificates-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: accredible-certificates-automation
+description: "Automate Accredible Certificates tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Accredible Certificates Automation via Rube MCP
+
+Automate Accredible Certificates operations through Composio's Accredible Certificates toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/accredible_certificates](https://composio.dev/toolkits/accredible_certificates)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Accredible Certificates connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `accredible_certificates`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `accredible_certificates`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Accredible Certificates 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 Accredible Certificates task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["accredible_certificates"]
+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 Accredible Certificates-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `accredible_certificates` |
+| 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](https://composio.dev)*

acculynx-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: acculynx-automation
+description: "Automate Acculynx tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Acculynx Automation via Rube MCP
+
+Automate Acculynx operations through Composio's Acculynx toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/acculynx](https://composio.dev/toolkits/acculynx)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Acculynx connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `acculynx`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `acculynx`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Acculynx 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 Acculynx task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["acculynx"]
+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 Acculynx-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `acculynx` |
+| 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](https://composio.dev)*

active-campaign-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: active-campaign-automation
+description: "Automate ActiveCampaign tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# ActiveCampaign Automation via Rube MCP
+
+Automate ActiveCampaign operations through Composio's ActiveCampaign toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/active_campaign](https://composio.dev/toolkits/active_campaign)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active ActiveCampaign connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `active_campaign`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `active_campaign`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "ActiveCampaign 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 ActiveCampaign task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["active_campaign"]
+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 ActiveCampaign-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `active_campaign` |
+| 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](https://composio.dev)*

activecampaign-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate ActiveCampaign CRM and marketing automation operations through Composio's ActiveCampaign toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/active_campaign](https://composio.dev/toolkits/active_campaign)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -207,3 +209,6 @@ Automate ActiveCampaign CRM and marketing automation operations through Composio
 | Subscribe/unsubscribe | ACTIVE_CAMPAIGN_MANAGE_LIST_SUBSCRIPTION | action, list_id, email |
 | Add to automation | ACTIVE_CAMPAIGN_ADD_CONTACT_TO_AUTOMATION | contact_email, automation_id |
 | Create task | ACTIVE_CAMPAIGN_CREATE_CONTACT_TASK | relid, duedate, dealTasktype, title |
+
+---
+*Powered by [Composio](https://composio.dev)*

addresszen-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: addresszen-automation
+description: "Automate Addresszen tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Addresszen Automation via Rube MCP
+
+Automate Addresszen operations through Composio's Addresszen toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/addresszen](https://composio.dev/toolkits/addresszen)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Addresszen connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `addresszen`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `addresszen`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Addresszen 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 Addresszen task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["addresszen"]
+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 Addresszen-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `addresszen` |
+| 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](https://composio.dev)*

adobe-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: adobe-automation
+description: "Automate Adobe tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Adobe Automation via Rube MCP
+
+Automate Adobe operations through Composio's Adobe toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/adobe](https://composio.dev/toolkits/adobe)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Adobe connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `adobe`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `adobe`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Adobe 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 Adobe task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["adobe"]
+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 Adobe-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `adobe` |
+| 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](https://composio.dev)*

adrapid-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: adrapid-automation
+description: "Automate Adrapid tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Adrapid Automation via Rube MCP
+
+Automate Adrapid operations through Composio's Adrapid toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/adrapid](https://composio.dev/toolkits/adrapid)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Adrapid connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `adrapid`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `adrapid`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Adrapid 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 Adrapid task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["adrapid"]
+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 Adrapid-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `adrapid` |
+| 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](https://composio.dev)*

adyntel-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: adyntel-automation
+description: "Automate Adyntel tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Adyntel Automation via Rube MCP
+
+Automate Adyntel operations through Composio's Adyntel toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/adyntel](https://composio.dev/toolkits/adyntel)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Adyntel connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `adyntel`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `adyntel`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Adyntel 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 Adyntel task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["adyntel"]
+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 Adyntel-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `adyntel` |
+| 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](https://composio.dev)*

aero-workflow-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: aero-workflow-automation
+description: "Automate Aero Workflow tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Aero Workflow Automation via Rube MCP
+
+Automate Aero Workflow operations through Composio's Aero Workflow toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/aero_workflow](https://composio.dev/toolkits/aero_workflow)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Aero Workflow connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aero_workflow`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `aero_workflow`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Aero Workflow 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 Aero Workflow task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["aero_workflow"]
+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 Aero Workflow-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aero_workflow` |
+| 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](https://composio.dev)*

aeroleads-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: aeroleads-automation
+description: "Automate Aeroleads tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Aeroleads Automation via Rube MCP
+
+Automate Aeroleads operations through Composio's Aeroleads toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/aeroleads](https://composio.dev/toolkits/aeroleads)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Aeroleads connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aeroleads`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `aeroleads`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Aeroleads 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 Aeroleads task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["aeroleads"]
+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 Aeroleads-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aeroleads` |
+| 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](https://composio.dev)*

affinda-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: affinda-automation
+description: "Automate Affinda tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Affinda Automation via Rube MCP
+
+Automate Affinda operations through Composio's Affinda toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/affinda](https://composio.dev/toolkits/affinda)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Affinda connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `affinda`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `affinda`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Affinda 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 Affinda task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["affinda"]
+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 Affinda-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `affinda` |
+| 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](https://composio.dev)*

affinity-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: affinity-automation
+description: "Automate Affinity tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Affinity Automation via Rube MCP
+
+Automate Affinity operations through Composio's Affinity toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/affinity](https://composio.dev/toolkits/affinity)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Affinity connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `affinity`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `affinity`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Affinity 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 Affinity task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["affinity"]
+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 Affinity-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `affinity` |
+| 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](https://composio.dev)*

agencyzoom-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agencyzoom-automation
+description: "Automate Agencyzoom tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agencyzoom Automation via Rube MCP
+
+Automate Agencyzoom operations through Composio's Agencyzoom toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agencyzoom](https://composio.dev/toolkits/agencyzoom)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agencyzoom connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agencyzoom`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agencyzoom`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agencyzoom 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 Agencyzoom task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agencyzoom"]
+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 Agencyzoom-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agencyzoom` |
+| 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](https://composio.dev)*

agent-mail-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agent-mail-automation
+description: "Automate Agent Mail tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agent Mail Automation via Rube MCP
+
+Automate Agent Mail operations through Composio's Agent Mail toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agent_mail](https://composio.dev/toolkits/agent_mail)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agent Mail connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agent_mail`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agent_mail`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agent Mail 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 Agent Mail task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agent_mail"]
+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 Agent Mail-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agent_mail` |
+| 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](https://composio.dev)*

agentql-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agentql-automation
+description: "Automate Agentql tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agentql Automation via Rube MCP
+
+Automate Agentql operations through Composio's Agentql toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agentql](https://composio.dev/toolkits/agentql)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agentql connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agentql`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agentql`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agentql 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 Agentql task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agentql"]
+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 Agentql-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agentql` |
+| 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](https://composio.dev)*

agenty-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agenty-automation
+description: "Automate Agenty tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agenty Automation via Rube MCP
+
+Automate Agenty operations through Composio's Agenty toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agenty](https://composio.dev/toolkits/agenty)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agenty connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agenty`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agenty`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agenty 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 Agenty task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agenty"]
+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 Agenty-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agenty` |
+| 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](https://composio.dev)*

agiled-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agiled-automation
+description: "Automate Agiled tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agiled Automation via Rube MCP
+
+Automate Agiled operations through Composio's Agiled toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agiled](https://composio.dev/toolkits/agiled)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agiled connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agiled`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agiled`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agiled 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 Agiled task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agiled"]
+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 Agiled-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agiled` |
+| 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](https://composio.dev)*

agility-cms-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agility-cms-automation
+description: "Automate Agility CMS tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agility CMS Automation via Rube MCP
+
+Automate Agility CMS operations through Composio's Agility CMS toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agility_cms](https://composio.dev/toolkits/agility_cms)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agility CMS connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agility_cms`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agility_cms`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agility CMS 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 Agility CMS task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agility_cms"]
+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 Agility CMS-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agility_cms` |
+| 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](https://composio.dev)*

ahrefs-automation/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: Ahrefs Automation
+description: "Automate SEO research with Ahrefs -- analyze backlink profiles, research keywords, track domain metrics history, audit organic rankings, and perform batch URL analysis through the Composio Ahrefs integration."
+requires:
+  mcp:
+    - rube
+---
+
+# Ahrefs Automation
+
+Run **Ahrefs** SEO analytics directly from Claude Code. Analyze backlink profiles, research keywords, track domain authority over time, audit organic keyword rankings, and batch-analyze multiple URLs without leaving your terminal.
+
+**Toolkit docs:** [composio.dev/toolkits/ahrefs](https://composio.dev/toolkits/ahrefs)
+
+---
+
+## Setup
+
+1. Add the Composio MCP server to your configuration:
+   ```
+   https://rube.app/mcp
+   ```
+2. Connect your Ahrefs account when prompted. The agent will provide an authentication link.
+3. Most tools require a `target` (domain or URL) and a `country` code (ISO 3166-1 alpha-2). Some also require a `date` in `YYYY-MM-DD` format.
+
+---
+
+## Core Workflows
+
+### 1. Site Explorer Metrics
+
+Retrieve comprehensive SEO metrics for a domain including backlink counts, referring domains, organic keyword rankings, and traffic estimates.
+
+**Tool:** `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS`
+
+Key parameters:
+- `target` (required) -- domain or URL to analyze
+- `date` (required) -- metrics date in `YYYY-MM-DD` format
+- `country` -- ISO country code (e.g., `us`, `gb`, `de`)
+- `mode` -- scope: `exact`, `prefix`, `domain`, or `subdomains` (default)
+- `protocol` -- `both`, `http`, or `https`
+- `volume_mode` -- `monthly` or `average`
+
+Example prompt: *"Get Ahrefs site metrics for example.com as of today in the US"*
+
+---
+
+### 2. Historical Metrics Tracking
+
+Track how a domain's SEO metrics have changed over time for trend analysis and competitive benchmarking.
+
+**Tools:** `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS_HISTORY`, `AHREFS_DOMAIN_RATING_HISTORY`
+
+For full metrics history:
+- `target` (required) -- domain to track
+- `date_from` (required) -- start date in `YYYY-MM-DD`
+- `date_to` -- end date
+- `history_grouping` -- `daily`, `weekly`, or `monthly` (default)
+- `select` -- columns like `date,org_cost,org_traffic,paid_cost,paid_traffic`
+
+For Domain Rating (DR) history:
+- `target` (required), `date_from` (required), `date_to`, `history_grouping`
+
+Example prompt: *"Show me the monthly Domain Rating history for example.com over the last year"*
+
+---
+
+### 3. Backlink Analysis
+
+Retrieve a comprehensive list of backlinks including source URLs, anchor text, link attributes, and referring domain metrics.
+
+**Tool:** `AHREFS_FETCH_ALL_BACKLINKS`
+
+Key parameters:
+- `target` (required) -- domain or URL
+- `select` (required) -- comma-separated columns (e.g., `url_from,url_to,anchor,domain_rating_source,first_seen_link`)
+- `limit` (default 1000) -- number of results
+- `aggregation` -- `similar_links` (default), `1_per_domain`, or `all`
+- `mode` -- `exact`, `prefix`, `domain`, or `subdomains`
+- `history` -- `live`, `since:YYYY-MM-DD`, or `all_time`
+- `where` -- rich filter expressions on columns like `is_dofollow`, `domain_rating_source`, `anchor`
+
+Example prompt: *"Get the top 100 dofollow backlinks to example.com with anchor text and referring DR"*
+
+---
+
+### 4. Keyword Research
+
+Get keyword overview metrics and discover matching keyword variations for content strategy.
+
+**Tools:** `AHREFS_EXPLORE_KEYWORDS_OVERVIEW`, `AHREFS_EXPLORE_MATCHING_TERMS_FOR_KEYWORDS`
+
+For keyword overview:
+- `select` (required) -- columns to return (volume, difficulty, CPC, etc.)
+- `country` (required) -- ISO country code
+- `keywords` -- comma-separated keyword list
+- `where` -- filter by volume, difficulty, intent, etc.
+
+For matching terms:
+- `select` (required) and `country` (required)
+- `keywords` -- comma-separated seed keywords
+- `match_mode` -- `terms` (any order) or `phrase` (exact order)
+- `terms` -- `all` or `questions` (question-format keywords only)
+
+Example prompt: *"Find keyword variations for 'project management' in the US with volume and difficulty"*
+
+---
+
+### 5. Organic Keywords Audit
+
+See which keywords a domain ranks for in organic search, with position tracking and historical comparison.
+
+**Tool:** `AHREFS_RETRIEVE_ORGANIC_KEYWORDS`
+
+Key parameters:
+- `target` (required) -- domain or URL
+- `country` (required) -- ISO country code
+- `date` (required) -- date in `YYYY-MM-DD`
+- `select` -- columns to return (keyword, position, volume, traffic, URL, etc.)
+- `date_compared` -- compare against a previous date
+- `where` -- rich filter expressions on `keyword`, `volume`, `best_position`, intent flags, etc.
+- `limit` (default 1000), `order_by`
+
+Example prompt: *"Show all organic keywords where example.com ranks in the top 10 in the US"*
+
+---
+
+### 6. Batch URL Analysis
+
+Analyze up to 100 URLs or domains simultaneously to compare SEO metrics across competitors or site sections.
+
+**Tool:** `AHREFS_BATCH_URL_ANALYSIS`
+
+Key parameters:
+- `targets` (required) -- array of objects with `url`, `mode` (`exact`/`prefix`/`domain`/`subdomains`), and `protocol` (`both`/`http`/`https`)
+- `select` (required) -- array of column identifiers
+- `country` -- ISO country code
+- `output` -- `json` or `php`
+
+Example prompt: *"Compare SEO metrics for competitor1.com, competitor2.com, and competitor3.com"*
+
+---
+
+## Known Pitfalls
+
+- **Column selection is required:** Most Ahrefs tools require a `select` parameter specifying which columns to return. Omitting it or using invalid column names will cause errors. Refer to each tool's response schema for valid identifiers.
+- **Date format consistency:** Dates must be in `YYYY-MM-DD` format. Some historical endpoints return data at the granularity set by `history_grouping`, not by exact date.
+- **API unit costs vary:** Different columns consume different unit amounts. Columns marked with "(5 units)" or "(10 units)" in the schema are more expensive. Monitor API usage when requesting expensive columns like `traffic`, `refdomains_source`, or `difficulty`.
+- **Batch limit is 100 targets:** `AHREFS_BATCH_URL_ANALYSIS` accepts up to 100 targets per request. For larger analyses, split into multiple batches.
+- **Filter expressions are complex:** The `where` parameter uses Ahrefs' filter expression syntax, not standard SQL. Consult the column descriptions in each tool's schema for supported filter types and value formats.
+- **Deprecated offset parameter:** The `offset` parameter was deprecated on May 31, 2024. Use cursor-based pagination or adjust `limit` instead.
+- **Mode affects scope significantly:** Setting `mode` to `subdomains` (the default) includes all subdomains, which can dramatically increase result counts compared to `domain` or `exact`.
+
+---
+
+## Quick Reference
+
+| Tool Slug | Description |
+|---|---|
+| `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS` | Current SEO metrics for a domain/URL |
+| `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS_HISTORY` | Historical SEO metrics over time |
+| `AHREFS_DOMAIN_RATING_HISTORY` | Domain Rating (DR) history |
+| `AHREFS_FETCH_ALL_BACKLINKS` | Comprehensive backlink list with filtering |
+| `AHREFS_FETCH_SITE_EXPLORER_REFERRING_DOMAINS` | List of referring domains |
+| `AHREFS_GET_SITE_EXPLORER_COUNTRY_METRICS` | Country-level traffic breakdown |
+| `AHREFS_BATCH_URL_ANALYSIS` | Batch analysis of up to 100 URLs |
+| `AHREFS_EXPLORE_KEYWORDS_OVERVIEW` | Keyword metrics overview |
+| `AHREFS_EXPLORE_MATCHING_TERMS_FOR_KEYWORDS` | Matching keyword variations |
+| `AHREFS_EXPLORE_KEYWORD_VOLUME_BY_COUNTRY` | Keyword volume across countries |
+| `AHREFS_RETRIEVE_ORGANIC_KEYWORDS` | Organic keyword rankings for a domain |
+| `AHREFS_RETRIEVE_SITE_EXPLORER_KEYWORDS_HISTORY` | Historical keyword ranking data |
+| `AHREFS_RETRIEVE_TOP_PAGES_FROM_SITE_EXPLORER` | Top performing pages by SEO metrics |
+| `AHREFS_GET_SERP_OVERVIEW` | SERP overview for specific keywords |
+
+---
+
+*Powered by [Composio](https://composio.dev)*

ai-ml-api-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ai-ml-api-automation
+description: "Automate AI ML API tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# AI ML API Automation via Rube MCP
+
+Automate AI ML API operations through Composio's AI ML API toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ai_ml_api](https://composio.dev/toolkits/ai_ml_api)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active AI ML API connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ai_ml_api`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ai_ml_api`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "AI ML API 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 AI ML API task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ai_ml_api"]
+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 AI ML API-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ai_ml_api` |
+| 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](https://composio.dev)*

airtable-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate Airtable operations through Composio's Airtable toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/airtable](https://composio.dev/toolkits/airtable)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -168,3 +170,6 @@ Automate Airtable operations through Composio's Airtable toolkit via Rube MCP.
 | Update field | AIRTABLE_UPDATE_FIELD | baseId, tableIdOrName, fieldId |
 | Update table | AIRTABLE_UPDATE_TABLE | baseId, tableIdOrName, name |
 | List comments | AIRTABLE_LIST_COMMENTS | baseId, tableIdOrName, recordId |
+
+---
+*Powered by [Composio](https://composio.dev)*

aivoov-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: aivoov-automation
+description: "Automate Aivoov tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Aivoov Automation via Rube MCP
+
+Automate Aivoov operations through Composio's Aivoov toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/aivoov](https://composio.dev/toolkits/aivoov)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Aivoov connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aivoov`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `aivoov`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Aivoov 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 Aivoov task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["aivoov"]
+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 Aivoov-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aivoov` |
+| 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](https://composio.dev)*

alchemy-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: alchemy-automation
+description: "Automate Alchemy tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Alchemy Automation via Rube MCP
+
+Automate Alchemy operations through Composio's Alchemy toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/alchemy](https://composio.dev/toolkits/alchemy)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Alchemy connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `alchemy`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `alchemy`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Alchemy 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 Alchemy task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["alchemy"]
+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 Alchemy-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alchemy` |
+| 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](https://composio.dev)*

algodocs-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: algodocs-automation
+description: "Automate Algodocs tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Algodocs Automation via Rube MCP
+
+Automate Algodocs operations through Composio's Algodocs toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/algodocs](https://composio.dev/toolkits/algodocs)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Algodocs connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `algodocs`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `algodocs`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Algodocs 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 Algodocs task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["algodocs"]
+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 Algodocs-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `algodocs` |
+| 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](https://composio.dev)*

algolia-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: algolia-automation
+description: "Automate Algolia tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Algolia Automation via Rube MCP
+
+Automate Algolia operations through Composio's Algolia toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/algolia](https://composio.dev/toolkits/algolia)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Algolia connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `algolia`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `algolia`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Algolia 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 Algolia task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["algolia"]
+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 Algolia-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `algolia` |
+| 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](https://composio.dev)*

all-images-ai-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: all-images-ai-automation
+description: "Automate All Images AI tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# All Images AI Automation via Rube MCP
+
+Automate All Images AI operations through Composio's All Images AI toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/all_images_ai](https://composio.dev/toolkits/all_images_ai)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active All Images AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `all_images_ai`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `all_images_ai`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "All Images AI 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 All Images AI task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["all_images_ai"]
+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 All Images AI-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `all_images_ai` |
+| 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](https://composio.dev)*

alpha-vantage-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: alpha-vantage-automation
+description: "Automate Alpha Vantage tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Alpha Vantage Automation via Rube MCP
+
+Automate Alpha Vantage operations through Composio's Alpha Vantage toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/alpha_vantage](https://composio.dev/toolkits/alpha_vantage)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Alpha Vantage connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `alpha_vantage`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `alpha_vantage`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Alpha Vantage 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 Alpha Vantage task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["alpha_vantage"]
+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 Alpha Vantage-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alpha_vantage` |
+| 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](https://composio.dev)*

altoviz-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: altoviz-automation
+description: "Automate Altoviz tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Altoviz Automation via Rube MCP
+
+Automate Altoviz operations through Composio's Altoviz toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/altoviz](https://composio.dev/toolkits/altoviz)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Altoviz connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `altoviz`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `altoviz`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Altoviz 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 Altoviz task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["altoviz"]
+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 Altoviz-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `altoviz` |
+| 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](https://composio.dev)*

alttext-ai-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: alttext-ai-automation
+description: "Automate Alttext AI tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Alttext AI Automation via Rube MCP
+
+Automate Alttext AI operations through Composio's Alttext AI toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/alttext_ai](https://composio.dev/toolkits/alttext_ai)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Alttext AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `alttext_ai`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `alttext_ai`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Alttext AI 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 Alttext AI task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["alttext_ai"]
+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 Alttext AI-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alttext_ai` |
+| 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](https://composio.dev)*

amara-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: amara-automation
+description: "Automate Amara tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Amara Automation via Rube MCP
+
+Automate Amara operations through Composio's Amara toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/amara](https://composio.dev/toolkits/amara)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Amara connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amara`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `amara`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Amara 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 Amara task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["amara"]
+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 Amara-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `amara` |
+| 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](https://composio.dev)*

amazon-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: amazon-automation
+description: "Automate Amazon tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Amazon Automation via Rube MCP
+
+Automate Amazon operations through Composio's Amazon toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/amazon](https://composio.dev/toolkits/amazon)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Amazon connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amazon`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `amazon`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Amazon 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 Amazon task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["amazon"]
+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 Amazon-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `amazon` |
+| 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](https://composio.dev)*

ambee-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ambee-automation
+description: "Automate Ambee tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ambee Automation via Rube MCP
+
+Automate Ambee operations through Composio's Ambee toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ambee](https://composio.dev/toolkits/ambee)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ambee connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ambee`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ambee`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ambee 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 Ambee task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ambee"]
+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 Ambee-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ambee` |
+| 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](https://composio.dev)*

ambient-weather-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ambient-weather-automation
+description: "Automate Ambient Weather tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ambient Weather Automation via Rube MCP
+
+Automate Ambient Weather operations through Composio's Ambient Weather toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ambient_weather](https://composio.dev/toolkits/ambient_weather)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ambient Weather connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ambient_weather`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ambient_weather`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ambient Weather 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 Ambient Weather task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ambient_weather"]
+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 Ambient Weather-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ambient_weather` |
+| 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](https://composio.dev)*

amcards-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: amcards-automation
+description: "Automate Amcards tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Amcards Automation via Rube MCP
+
+Automate Amcards operations through Composio's Amcards toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/amcards](https://composio.dev/toolkits/amcards)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Amcards connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amcards`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `amcards`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Amcards 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 Amcards task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["amcards"]
+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 Amcards-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `amcards` |
+| 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](https://composio.dev)*

amplitude-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate Amplitude product analytics through Composio's Amplitude toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/amplitude](https://composio.dev/toolkits/amplitude)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -214,3 +216,6 @@ For cohort membership updates:
 | Update cohort members | AMPLITUDE_UPDATE_COHORT_MEMBERSHIP | cohort_id, memberships |
 | Check cohort status | AMPLITUDE_CHECK_COHORT_STATUS | request_id |
 | List event categories | AMPLITUDE_GET_EVENT_CATEGORIES | (none) |
+
+---
+*Powered by [Composio](https://composio.dev)*

anchor-browser-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: anchor-browser-automation
+description: "Automate Anchor Browser tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Anchor Browser Automation via Rube MCP
+
+Automate Anchor Browser operations through Composio's Anchor Browser toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/anchor_browser](https://composio.dev/toolkits/anchor_browser)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Anchor Browser connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anchor_browser`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `anchor_browser`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Anchor Browser 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 Anchor Browser task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["anchor_browser"]
+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 Anchor Browser-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anchor_browser` |
+| 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](https://composio.dev)*

anonyflow-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: anonyflow-automation
+description: "Automate Anonyflow tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Anonyflow Automation via Rube MCP
+
+Automate Anonyflow operations through Composio's Anonyflow toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/anonyflow](https://composio.dev/toolkits/anonyflow)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Anonyflow connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anonyflow`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `anonyflow`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Anonyflow 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 Anonyflow task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["anonyflow"]
+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 Anonyflow-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anonyflow` |
+| 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](https://composio.dev)*

anthropic-administrator-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: anthropic-administrator-automation
+description: "Automate Anthropic Admin tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Anthropic Admin Automation via Rube MCP
+
+Automate Anthropic Admin operations through Composio's Anthropic Admin toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/anthropic_administrator](https://composio.dev/toolkits/anthropic_administrator)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Anthropic Admin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Anthropic Admin 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 Anthropic Admin task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["anthropic_administrator"]
+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 Anthropic Admin-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator` |
+| 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](https://composio.dev)*

anthropic_administrator-automation/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: anthropic_administrator-automation
+description: "Automate Anthropic Admin tasks via Rube MCP (Composio): API keys, usage, workspaces, and organization management. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Anthropic Admin Automation via Rube MCP
+
+Automate Anthropic Admin operations through Composio's Anthropic Admin toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/anthropic_administrator](https://composio.dev/toolkits/anthropic_administrator)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Anthropic Admin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS: queries=[{"use_case": "API keys, usage, workspaces, and organization management", "known_fields": ""}]
+```
+
+This returns:
+- Available tool slugs for Anthropic Admin
+- Recommended execution plan steps
+- Known pitfalls and edge cases
+- Input schemas for each tool
+
+## Core Workflows
+
+### 1. Discover Available Anthropic Admin Tools
+
+```
+RUBE_SEARCH_TOOLS:
+  queries:
+    - use_case: "list all available Anthropic Admin tools and capabilities"
+```
+
+Review the returned tools, their descriptions, and input schemas before proceeding.
+
+### 2. Execute Anthropic Admin Operations
+
+After discovering tools, execute them via:
+
+```
+RUBE_MULTI_EXECUTE_TOOL:
+  tools:
+    - tool_slug: "<discovered_tool_slug>"
+      arguments: {<schema-compliant arguments>}
+  memory: {}
+  sync_response_to_workbench: false
+```
+
+### 3. Multi-Step Workflows
+
+For complex workflows involving multiple Anthropic Admin operations:
+
+1. Search for all relevant tools: `RUBE_SEARCH_TOOLS` with specific use case
+2. Execute prerequisite steps first (e.g., fetch before update)
+3. Pass data between steps using tool responses
+4. Use `RUBE_REMOTE_WORKBENCH` for bulk operations or data processing
+
+## Common Patterns
+
+### Search Before Action
+Always search for existing resources before creating new ones to avoid duplicates.
+
+### Pagination
+Many list operations support pagination. Check responses for `next_cursor` or `page_token` and continue fetching until exhausted.
+
+### Error Handling
+- Check tool responses for errors before proceeding
+- If a tool fails, verify the connection is still ACTIVE
+- Re-authenticate via `RUBE_MANAGE_CONNECTIONS` if connection expired
+
+### Batch Operations
+For bulk operations, use `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` in a loop with `ThreadPoolExecutor` for parallel execution.
+
+## Known Pitfalls
+
+- **Always search tools first**: Tool schemas and available operations may change. Never hardcode tool slugs without first discovering them via `RUBE_SEARCH_TOOLS`.
+- **Check connection status**: Ensure the Anthropic Admin connection is ACTIVE before executing any tools. Expired OAuth tokens require re-authentication.
+- **Respect rate limits**: If you receive rate limit errors, reduce request frequency and implement backoff.
+- **Validate schemas**: Always pass strictly schema-compliant arguments. Use `RUBE_GET_TOOL_SCHEMAS` to load full input schemas when `schemaRef` is returned instead of `input_schema`.
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Anthropic Admin-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator` |
+| 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` |
+
+> **Toolkit docs**: [composio.dev/toolkits/anthropic_administrator](https://composio.dev/toolkits/anthropic_administrator)

apaleo-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apaleo-automation
+description: "Automate Apaleo tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apaleo Automation via Rube MCP
+
+Automate Apaleo operations through Composio's Apaleo toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apaleo](https://composio.dev/toolkits/apaleo)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apaleo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apaleo`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apaleo`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apaleo 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 Apaleo task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apaleo"]
+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 Apaleo-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apaleo` |
+| 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](https://composio.dev)*

apex27-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apex27-automation
+description: "Automate Apex27 tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apex27 Automation via Rube MCP
+
+Automate Apex27 operations through Composio's Apex27 toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apex27](https://composio.dev/toolkits/apex27)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apex27 connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apex27`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apex27`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apex27 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 Apex27 task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apex27"]
+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 Apex27-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apex27` |
+| 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](https://composio.dev)*

api-bible-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api-bible-automation
+description: "Automate API Bible tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# API Bible Automation via Rube MCP
+
+Automate API Bible operations through Composio's API Bible toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api_bible](https://composio.dev/toolkits/api_bible)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active API Bible connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_bible`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api_bible`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "API Bible 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 API Bible task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api_bible"]
+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 API Bible-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_bible` |
+| 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](https://composio.dev)*

api-labz-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api-labz-automation
+description: "Automate API Labz tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# API Labz Automation via Rube MCP
+
+Automate API Labz operations through Composio's API Labz toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api_labz](https://composio.dev/toolkits/api_labz)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active API Labz connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_labz`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api_labz`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "API Labz 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 API Labz task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api_labz"]
+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 API Labz-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_labz` |
+| 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](https://composio.dev)*

api-ninjas-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api-ninjas-automation
+description: "Automate API Ninjas tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# API Ninjas Automation via Rube MCP
+
+Automate API Ninjas operations through Composio's API Ninjas toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api_ninjas](https://composio.dev/toolkits/api_ninjas)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active API Ninjas connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_ninjas`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api_ninjas`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "API Ninjas 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 API Ninjas task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api_ninjas"]
+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 API Ninjas-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_ninjas` |
+| 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](https://composio.dev)*

api-sports-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api-sports-automation
+description: "Automate API Sports tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# API Sports Automation via Rube MCP
+
+Automate API Sports operations through Composio's API Sports toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api_sports](https://composio.dev/toolkits/api_sports)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active API Sports connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_sports`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api_sports`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "API Sports 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 API Sports task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api_sports"]
+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 API Sports-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_sports` |
+| 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](https://composio.dev)*

api2pdf-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api2pdf-automation
+description: "Automate Api2pdf tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Api2pdf Automation via Rube MCP
+
+Automate Api2pdf operations through Composio's Api2pdf toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api2pdf](https://composio.dev/toolkits/api2pdf)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Api2pdf connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api2pdf`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api2pdf`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Api2pdf 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 Api2pdf task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api2pdf"]
+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 Api2pdf-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api2pdf` |
+| 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](https://composio.dev)*

apiflash-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apiflash-automation
+description: "Automate Apiflash tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apiflash Automation via Rube MCP
+
+Automate Apiflash operations through Composio's Apiflash toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apiflash](https://composio.dev/toolkits/apiflash)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apiflash connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apiflash`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apiflash`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apiflash 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 Apiflash task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apiflash"]
+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 Apiflash-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apiflash` |
+| 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](https://composio.dev)*

apify-automation/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: Apify Automation
+description: "Automate web scraping and data extraction with Apify -- run Actors, manage datasets, create reusable tasks, and retrieve crawl results through the Composio Apify integration."
+requires:
+  mcp:
+    - rube
+---
+
+# Apify Automation
+
+Run **Apify** web scraping Actors and manage datasets directly from Claude Code. Execute crawlers synchronously or asynchronously, retrieve structured data, create reusable tasks, and inspect run logs without leaving your terminal.
+
+**Toolkit docs:** [composio.dev/toolkits/apify](https://composio.dev/toolkits/apify)
+
+---
+
+## Setup
+
+1. Add the Composio MCP server to your configuration:
+   ```
+   https://rube.app/mcp
+   ```
+2. Connect your Apify account when prompted. The agent will provide an authentication link.
+3. Browse available Actors at [apify.com/store](https://apify.com/store). Each Actor has its own unique input schema -- always check the Actor's documentation before running.
+
+---
+
+## Core Workflows
+
+### 1. Run an Actor Synchronously and Get Results
+
+Execute an Actor and immediately retrieve its dataset items in a single call. Best for quick scraping jobs.
+
+**Tool:** `APIFY_RUN_ACTOR_SYNC_GET_DATASET_ITEMS`
+
+Key parameters:
+- `actorId` (required) -- Actor ID in format `username/actor-name` (e.g., `compass/crawler-google-places`)
+- `input` -- JSON input object matching the Actor's schema. Each Actor has unique field names -- check [apify.com/store](https://apify.com/store) for the exact schema.
+- `limit` -- max items to return
+- `offset` -- skip items for pagination
+- `format` -- `json` (default), `csv`, `jsonl`, `html`, `xlsx`, `xml`
+- `timeout` -- run timeout in seconds
+- `waitForFinish` -- max wait time (0-300 seconds)
+- `fields` -- comma-separated list of fields to include
+- `omit` -- comma-separated list of fields to exclude
+
+Example prompt: *"Run the Google Places scraper for 'restaurants in New York' and return the first 50 results"*
+
+---
+
+### 2. Run an Actor Asynchronously
+
+Trigger an Actor run without waiting for completion. Use for long-running scraping jobs.
+
+**Tool:** `APIFY_RUN_ACTOR`
+
+Key parameters:
+- `actorId` (required) -- Actor slug or ID
+- `body` -- JSON input object for the Actor
+- `memory` -- memory limit in MB (must be power of 2, minimum 128)
+- `timeout` -- run timeout in seconds
+- `maxItems` -- cap on returned items
+- `build` -- specific build tag (e.g., `latest`, `beta`)
+
+Follow up with `APIFY_GET_DATASET_ITEMS` to retrieve results using the run's `datasetId`.
+
+Example prompt: *"Start the web scraper Actor for example.com asynchronously with 1024MB memory"*
+
+---
+
+### 3. Retrieve Dataset Items
+
+Fetch data from a specific dataset with pagination, field selection, and filtering.
+
+**Tool:** `APIFY_GET_DATASET_ITEMS`
+
+Key parameters:
+- `datasetId` (required) -- dataset identifier
+- `limit` (default/max 1000) -- items per page
+- `offset` (default 0) -- pagination offset
+- `format` -- `json` (recommended), `csv`, `xlsx`
+- `fields` -- include only specific fields
+- `omit` -- exclude specific fields
+- `clean` -- remove Apify-specific metadata
+- `desc` -- reverse order (newest first)
+
+Example prompt: *"Get the first 500 items from dataset myDatasetId in JSON format"*
+
+---
+
+### 4. Inspect Actor Details
+
+View Actor metadata, input schema, and configuration before running it.
+
+**Tool:** `APIFY_GET_ACTOR`
+
+Key parameters:
+- `actorId` (required) -- Actor ID in format `username/actor-name` or hex ID
+
+Example prompt: *"Show me the details and input schema for the apify/web-scraper Actor"*
+
+---
+
+### 5. Create Reusable Tasks
+
+Configure reusable Actor tasks with preset inputs for recurring scraping jobs.
+
+**Tool:** `APIFY_CREATE_TASK`
+
+Configure a task once, then trigger it repeatedly with consistent input parameters. Useful for scheduled or recurring data collection workflows.
+
+Example prompt: *"Create an Apify task for the Google Search scraper with default query 'AI startups' and US location"*
+
+---
+
+### 6. Manage Runs and Datasets
+
+List Actor runs, browse datasets, and inspect run details for monitoring and debugging.
+
+**Tools:** `APIFY_GET_LIST_OF_RUNS`, `APIFY_DATASETS_GET`, `APIFY_DATASET_GET`, `APIFY_GET_LOG`
+
+For listing runs:
+- Filter by Actor and optionally by status
+- Get `datasetId` from run details for data retrieval
+
+For dataset management:
+- `APIFY_DATASETS_GET` -- list all your datasets with pagination
+- `APIFY_DATASET_GET` -- get metadata for a specific dataset
+
+For debugging:
+- `APIFY_GET_LOG` -- retrieve execution logs for a run or build
+
+Example prompt: *"List the last 10 runs for the web scraper Actor and show logs for the most recent one"*
+
+---
+
+## Known Pitfalls
+
+- **Actor input schemas vary wildly:** Every Actor has its own unique input fields. Generic field names like `queries` or `search_terms` will be rejected. Always check the Actor's page on [apify.com/store](https://apify.com/store) for exact field names (e.g., `searchStringsArray` for Google Maps, `startUrls` for web scrapers).
+- **URL format requirements:** Always include the full protocol (`https://` or `http://`) in URLs. Many Actors require URLs as objects with a `url` property: `{"startUrls": [{"url": "https://example.com"}]}`.
+- **Dataset pagination cap:** `APIFY_GET_DATASET_ITEMS` has a max `limit` of 1000 per call. For large datasets, loop with `offset` to collect all items.
+- **Enum values are lowercase:** Most Actors expect lowercase enum values (e.g., `relevance` not `RELEVANCE`, `all` not `ALL`).
+- **Sync timeout at 5 minutes:** `APIFY_RUN_ACTOR_SYNC_GET_DATASET_ITEMS` has a maximum `waitForFinish` of 300 seconds. For longer runs, use `APIFY_RUN_ACTOR` (async) and poll with `APIFY_GET_DATASET_ITEMS`.
+- **Data volume costs:** Large datasets can be expensive to fetch. Prefer moderate limits and incremental processing to avoid timeouts or memory pressure.
+- **JSON format recommended:** While CSV/XLSX formats are available, JSON is the most reliable for automated processing. Avoid CSV/XLSX for downstream automation.
+
+---
+
+## Quick Reference
+
+| Tool Slug | Description |
+|---|---|
+| `APIFY_RUN_ACTOR_SYNC_GET_DATASET_ITEMS` | Run Actor synchronously and get results immediately |
+| `APIFY_RUN_ACTOR` | Run Actor asynchronously (trigger and return) |
+| `APIFY_RUN_ACTOR_SYNC` | Run Actor synchronously, return output record |
+| `APIFY_GET_ACTOR` | Get Actor metadata and input schema |
+| `APIFY_GET_DATASET_ITEMS` | Retrieve items from a dataset (paginated) |
+| `APIFY_DATASET_GET` | Get dataset metadata (item count, etc.) |
+| `APIFY_DATASETS_GET` | List all user datasets |
+| `APIFY_CREATE_TASK` | Create a reusable Actor task |
+| `APIFY_GET_TASK_INPUT` | Inspect a task's stored input |
+| `APIFY_GET_LIST_OF_RUNS` | List runs for an Actor |
+| `APIFY_GET_LOG` | Get execution logs for a run |
+
+---
+
+*Powered by [Composio](https://composio.dev)*

apilio-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apilio-automation
+description: "Automate Apilio tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apilio Automation via Rube MCP
+
+Automate Apilio operations through Composio's Apilio toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apilio](https://composio.dev/toolkits/apilio)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apilio connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apilio`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apilio`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apilio 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 Apilio task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apilio"]
+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 Apilio-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apilio` |
+| 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](https://composio.dev)*

apipie-ai-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apipie-ai-automation
+description: "Automate Apipie AI tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apipie AI Automation via Rube MCP
+
+Automate Apipie AI operations through Composio's Apipie AI toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apipie_ai](https://composio.dev/toolkits/apipie_ai)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apipie AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apipie_ai`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apipie_ai`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apipie AI 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 Apipie AI task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apipie_ai"]
+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 Apipie AI-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apipie_ai` |
+| 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](https://composio.dev)*

apitemplate-io-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apitemplate-io-automation
+description: "Automate Apitemplate IO tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apitemplate IO Automation via Rube MCP
+
+Automate Apitemplate IO operations through Composio's Apitemplate IO toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apitemplate_io](https://composio.dev/toolkits/apitemplate_io)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apitemplate IO connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apitemplate_io`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apitemplate_io`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apitemplate 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 Apitemplate IO task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apitemplate_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_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 Apitemplate IO-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apitemplate_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](https://composio.dev)*

apiverve-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apiverve-automation
+description: "Automate Apiverve tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apiverve Automation via Rube MCP
+
+Automate Apiverve operations through Composio's Apiverve toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apiverve](https://composio.dev/toolkits/apiverve)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apiverve connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apiverve`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apiverve`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apiverve 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 Apiverve task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apiverve"]
+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 Apiverve-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apiverve` |
+| 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](https://composio.dev)*

apollo-automation/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: Apollo Automation
+description: "Automate Apollo.io lead generation -- search organizations, discover contacts, enrich prospect data, manage contact stages, and build targeted outreach lists -- using natural language through the Composio MCP integration."
+category: sales-intelligence
+requires:
+  mcp:
+    - rube
+---
+
+# Apollo Automation
+
+Supercharge your sales prospecting with Apollo.io -- search companies, discover decision-makers, enrich contact data with emails and phone numbers, and manage your sales pipeline stages -- all through natural language commands.
+
+**Toolkit docs:** [composio.dev/toolkits/apollo](https://composio.dev/toolkits/apollo)
+
+---
+
+## Setup
+
+1. Add the Composio MCP server to your client configuration:
+   ```
+   https://rube.app/mcp
+   ```
+2. Connect your Apollo.io account when prompted (API key authentication).
+3. Start issuing natural language commands to prospect and enrich leads.
+
+---
+
+## Core Workflows
+
+### 1. Search Organizations
+Find target companies using filters like name, location, employee count, and industry keywords.
+
+**Tool:** `APOLLO_ORGANIZATION_SEARCH`
+
+**Example prompt:**
+> "Find SaaS companies in Texas with 50-500 employees on Apollo"
+
+**Key parameters:**
+- `q_organization_name` -- Partial name match (e.g., "Apollo" matches "Apollo Inc.")
+- `organization_locations` -- HQ locations to include (e.g., "texas", "tokyo")
+- `organization_not_locations` -- HQ locations to exclude
+- `organization_num_employees_ranges` -- Employee ranges in "min,max" format (e.g., "50,500")
+- `q_organization_keyword_tags` -- Industry keywords (e.g., "software", "healthcare")
+- `page` / `per_page` -- Pagination (max 100 per page, max 500 pages)
+
+---
+
+### 2. Discover People at Companies
+Search Apollo's contact database for people matching title, seniority, location, and company criteria.
+
+**Tool:** `APOLLO_PEOPLE_SEARCH`
+
+**Example prompt:**
+> "Find VPs of Sales at microsoft.com and apollo.io"
+
+**Key parameters:**
+- `person_titles` -- Job titles (e.g., "VP of Sales", "CTO")
+- `person_seniorities` -- Seniority levels (e.g., "director", "vp", "senior")
+- `person_locations` -- Geographic locations of people
+- `q_organization_domains` -- Company domains (e.g., "apollo.io" -- exclude "www.")
+- `organization_ids` -- Apollo company IDs from Organization Search
+- `contact_email_status` -- Filter by email status: "verified", "unverified", "likely to engage"
+- `page` / `per_page` -- Pagination (max 100 per page)
+
+---
+
+### 3. Enrich Individual Contacts
+Get comprehensive data (email, phone, LinkedIn, company info) for a single person using their email, LinkedIn URL, or name + company.
+
+**Tool:** `APOLLO_PEOPLE_ENRICHMENT`
+
+**Example prompt:**
+> "Enrich Tim Zheng at Apollo.io on Apollo"
+
+**Key parameters (at least one identifier required):**
+- `email` -- Person's email address
+- `linkedin_url` -- Full LinkedIn profile URL
+- `first_name` + `last_name` + (`organization_name` or `domain`) -- Name-based matching
+- `domain` -- Bare hostname without protocol (e.g., "apollo.io", not "https://apollo.io")
+- `reveal_personal_emails` -- Set true to get personal emails (may use extra credits)
+- `reveal_phone_number` -- Set true for phone numbers (requires `webhook_url`)
+
+---
+
+### 4. Bulk Enrich Prospects
+Enrich up to 10 people simultaneously for efficient batch processing.
+
+**Tool:** `APOLLO_BULK_PEOPLE_ENRICHMENT`
+
+**Example prompt:**
+> "Bulk enrich these 5 leads with their Apollo data: [list of names/emails]"
+
+**Key parameters:**
+- `details` (required) -- Array of 1-10 person objects, each with identifiers like `email`, `linkedin_url`, `first_name`, `last_name`, `domain`, `company_name`
+- `reveal_personal_emails` -- Include personal emails (extra credits)
+- `reveal_phone_number` -- Include phone numbers (requires `webhook_url`)
+
+---
+
+### 5. Manage Contact Pipeline Stages
+List available stages and update contacts through your sales funnel.
+
+**Tools:** `APOLLO_LIST_CONTACT_STAGES`, `APOLLO_UPDATE_CONTACT_STAGE`
+
+**Example prompt:**
+> "Move contacts X and Y to the 'Qualified' stage in Apollo"
+
+**Key parameters for listing stages:** None required.
+
+**Key parameters for updating stage:**
+- `contact_ids` (required) -- Array of contact IDs to update
+- `contact_stage_id` (required) -- Target stage ID (from List Contact Stages)
+
+---
+
+### 6. Create and Search Saved Contacts
+Create new contact records and search your existing Apollo contact database.
+
+**Tools:** `APOLLO_CREATE_CONTACT`, `APOLLO_SEARCH_CONTACTS`
+
+**Example prompt:**
+> "Search my Apollo contacts for anyone at Stripe"
+
+**Key parameters for search:**
+- Keyword search, stage ID filtering, sorting options
+- `page` / `per_page` -- Pagination
+
+**Key parameters for create:**
+- `first_name`, `last_name`, `email`, `organization_name`
+- `account_id` -- Link to an organization
+- `contact_stage_id` -- Initial sales stage
+
+---
+
+## Known Pitfalls
+
+- **Organization domains can be empty**: Some organizations from `APOLLO_ORGANIZATION_SEARCH` return missing or empty domain fields. Use `APOLLO_ORGANIZATION_ENRICHMENT` to validate domains before relying on them.
+- **HTTP 403 means config issues**: A 403 response indicates API key or plan access problems -- do not retry. Fix your credentials or plan first.
+- **People search returns obfuscated data**: `APOLLO_PEOPLE_SEARCH` may show `has_email`/`has_direct_phone` flags or obfuscated fields instead of full contact details. Use `APOLLO_PEOPLE_ENRICHMENT` to get complete information.
+- **Pagination limits are strict**: People search supports `per_page` up to 100 and max 500 pages. Stopping early can miss large portions of the result set.
+- **Bulk enrichment has small batch limits**: `APOLLO_BULK_PEOPLE_ENRICHMENT` accepts only 10 items per call. It can return `status='success'` with `missing_records > 0` when identifiers are insufficient -- retry individual records with `APOLLO_PEOPLE_ENRICHMENT`.
+- **No automatic deduplication**: `APOLLO_CREATE_CONTACT` does not deduplicate. Check for existing contacts first with `APOLLO_SEARCH_CONTACTS`.
+- **Domain format matters**: Always use bare hostnames (e.g., "apollo.io") without protocol prefixes ("https://") or "www." prefix.
+
+---
+
+## Quick Reference
+
+| Action | Tool Slug | Required Params |
+|---|---|---|
+| Search organizations | `APOLLO_ORGANIZATION_SEARCH` | None (optional filters) |
+| Enrich organization | `APOLLO_ORGANIZATION_ENRICHMENT` | `domain` |
+| Bulk enrich orgs | `APOLLO_BULK_ORGANIZATION_ENRICHMENT` | `domains` |
+| Search people | `APOLLO_PEOPLE_SEARCH` | None (optional filters) |
+| Enrich person | `APOLLO_PEOPLE_ENRICHMENT` | One of: `email`, `linkedin_url`, or name+company |
+| Bulk enrich people | `APOLLO_BULK_PEOPLE_ENRICHMENT` | `details` (1-10 person objects) |
+| List contact stages | `APOLLO_LIST_CONTACT_STAGES` | None |
+| Update contact stage | `APOLLO_UPDATE_CONTACT_STAGE` | `contact_ids`, `contact_stage_id` |
+| Create contact | `APOLLO_CREATE_CONTACT` | Name + identifiers |
+| Search contacts | `APOLLO_SEARCH_CONTACTS` | None (optional filters) |
+
+---
+
+*Powered by [Composio](https://composio.dev)*

appcircle-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appcircle-automation
+description: "Automate Appcircle tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appcircle Automation via Rube MCP
+
+Automate Appcircle operations through Composio's Appcircle toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appcircle](https://composio.dev/toolkits/appcircle)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appcircle connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appcircle`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appcircle`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appcircle 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 Appcircle task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appcircle"]
+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 Appcircle-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appcircle` |
+| 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](https://composio.dev)*

appdrag-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appdrag-automation
+description: "Automate Appdrag tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appdrag Automation via Rube MCP
+
+Automate Appdrag operations through Composio's Appdrag toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appdrag](https://composio.dev/toolkits/appdrag)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appdrag connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appdrag`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appdrag`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appdrag 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 Appdrag task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appdrag"]
+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 Appdrag-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appdrag` |
+| 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](https://composio.dev)*

appointo-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appointo-automation
+description: "Automate Appointo tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appointo Automation via Rube MCP
+
+Automate Appointo operations through Composio's Appointo toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appointo](https://composio.dev/toolkits/appointo)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appointo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appointo`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appointo`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appointo 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 Appointo task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appointo"]
+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 Appointo-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appointo` |
+| 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](https://composio.dev)*

appsflyer-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appsflyer-automation
+description: "Automate Appsflyer tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appsflyer Automation via Rube MCP
+
+Automate Appsflyer operations through Composio's Appsflyer toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appsflyer](https://composio.dev/toolkits/appsflyer)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appsflyer connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appsflyer`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appsflyer`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appsflyer 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 Appsflyer task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appsflyer"]
+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 Appsflyer-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appsflyer` |
+| 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](https://composio.dev)*

appveyor-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appveyor-automation
+description: "Automate Appveyor tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appveyor Automation via Rube MCP
+
+Automate Appveyor operations through Composio's Appveyor toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appveyor](https://composio.dev/toolkits/appveyor)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appveyor connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appveyor`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appveyor`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appveyor 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 Appveyor task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appveyor"]
+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 Appveyor-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appveyor` |
+| 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](https://composio.dev)*

aryn-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: aryn-automation
+description: "Automate Aryn tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Aryn Automation via Rube MCP
+
+Automate Aryn operations through Composio's Aryn toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/aryn](https://composio.dev/toolkits/aryn)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Aryn connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aryn`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `aryn`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Aryn 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 Aryn task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["aryn"]
+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 Aryn-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aryn` |
+| 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](https://composio.dev)*

asana-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate Asana operations through Composio's Asana toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/asana](https://composio.dev/toolkits/asana)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -169,3 +171,6 @@ Automate Asana operations through Composio's Asana toolkit via Rube MCP.
 | Workspace users | ASANA_GET_USERS_FOR_WORKSPACE | workspace_gid |
 | Current user | ASANA_GET_CURRENT_USER | (none) |
 | Parallel requests | ASANA_SUBMIT_PARALLEL_REQUESTS | actions |
+
+---
+*Powered by [Composio](https://composio.dev)*

ascora-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ascora-automation
+description: "Automate Ascora tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ascora Automation via Rube MCP
+
+Automate Ascora operations through Composio's Ascora toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ascora](https://composio.dev/toolkits/ascora)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ascora connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ascora`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ascora`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ascora 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 Ascora task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ascora"]
+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 Ascora-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ascora` |
+| 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](https://composio.dev)*

ashby-automation/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: Ashby Automation
+description: "Automate recruiting and hiring workflows in Ashby -- manage candidates, jobs, applications, interviews, and notes through natural language commands."
+requires:
+  mcp:
+    - rube
+---
+
+# Ashby Automation
+
+Automate your Ashby ATS recruiting operations directly from Claude Code. Create candidates, post jobs, manage applications, view interview schedules, and search your talent pipeline -- all without leaving your terminal.
+
+**Toolkit docs:** [composio.dev/toolkits/ashby](https://composio.dev/toolkits/ashby)
+
+---
+
+## Setup
+
+1. Add the Rube MCP server to your Claude Code config with URL: `https://rube.app/mcp`
+2. When prompted, authenticate your Ashby account through the connection link provided
+3. Start automating your recruiting workflows with natural language
+
+---
+
+## Core Workflows
+
+### 1. Manage Candidates
+
+Create, list, search, update, and retrieve detailed candidate information.
+
+**Tools:** `ASHBY_CREATE_CANDIDATE`, `ASHBY_LIST_CANDIDATES`, `ASHBY_SEARCH_CANDIDATES`, `ASHBY_GET_CANDIDATE_INFO`, `ASHBY_UPDATE_CANDIDATE`
+
+```
+Create a candidate named "Jane Smith" with email jane@example.com and LinkedIn profile https://linkedin.com/in/janesmith
+```
+
+Key parameters for `ASHBY_CREATE_CANDIDATE`:
+- `name` (required) -- full name of the candidate
+- `email` -- primary email address
+- `phoneNumber`, `linkedInUrl`, `githubUrl`, `websiteUrl` -- contact/social profiles
+
+Key parameters for `ASHBY_SEARCH_CANDIDATES`:
+- `email` -- exact email match
+- `name` -- partial name match
+
+Key parameters for `ASHBY_LIST_CANDIDATES`:
+- `perPage` (max 100) / `cursor` -- pagination
+- `syncToken` -- for incremental updates since last sync
+
+### 2. Create and List Jobs
+
+Post new job openings and browse existing positions.
+
+**Tools:** `ASHBY_CREATE_JOB`, `ASHBY_LIST_JOBS`, `ASHBY_GET_JOB_INFO`
+
+```
+Create a new "Senior Software Engineer" job in team dept-123 at location loc-456 with brand brand-789
+```
+
+Key parameters for `ASHBY_CREATE_JOB`:
+- `title` (required) -- job title
+- `teamId` (required) -- department/team ID (from list departments)
+- `locationId` (required) -- office location ID (from list locations)
+- `brandId` (required) -- employer brand ID (from list brands)
+- `defaultInterviewPlanId` -- required to open the job for applications
+- `jobTemplateId` -- pre-populate from a template
+
+Key parameters for `ASHBY_LIST_JOBS`:
+- `perPage` (max 100) / `cursor` / `syncToken` -- pagination and incremental sync
+
+**Note:** Newly created jobs start in "Draft" status. You must set a `defaultInterviewPlanId` to open/publish the job.
+
+### 3. Manage Applications
+
+Create applications to connect candidates to jobs and track their progress.
+
+**Tools:** `ASHBY_CREATE_APPLICATION`, `ASHBY_LIST_APPLICATIONS`
+
+```
+Apply candidate cand-abc123 to job job-xyz789 with source src-referral
+```
+
+Key parameters for `ASHBY_CREATE_APPLICATION`:
+- `candidateId` (required) -- UUID of an existing candidate
+- `jobId` (required) -- UUID of an existing job
+- `sourceId` -- UUID of the application source (LinkedIn, Referral, etc.)
+- `creditedToUserId` -- UUID of recruiter/referrer to credit
+- `interviewStageId` -- place directly into a specific stage (defaults to first stage)
+
+Key parameters for `ASHBY_LIST_APPLICATIONS`:
+- `perPage` (max 100) / `cursor` / `syncToken` -- pagination and incremental sync
+
+### 4. View Interview Schedules
+
+List scheduled interviews with timing, interviewer, and candidate details.
+
+**Tool:** `ASHBY_LIST_INTERVIEW_SCHEDULES`
+
+```
+Show me all upcoming interview schedules
+```
+
+Key parameters:
+- `perPage` (max 100) / `cursor` -- pagination
+- `syncToken` -- incremental sync for changed schedules
+
+### 5. Candidate Notes
+
+View internal notes, observations, and recruiter comments on candidates.
+
+**Tool:** `ASHBY_LIST_CANDIDATE_NOTES`
+
+```
+Show me all notes for candidate cand-abc123
+```
+
+- Retrieves all notes added by recruiters and hiring team members
+- Useful for reviewing interview feedback and internal assessments
+
+### 6. Pipeline Reporting
+
+Combine listing tools to build hiring pipeline reports.
+
+**Tools:** `ASHBY_LIST_CANDIDATES`, `ASHBY_LIST_APPLICATIONS`, `ASHBY_LIST_JOBS`
+
+```
+List all applications to see the current state of our hiring pipeline
+```
+
+- Use `syncToken` for incremental data fetches (efficient for recurring reports)
+- Combine candidate, application, and job data for full pipeline visibility
+- Paginate through all results with `cursor` for complete datasets
+
+---
+
+## Known Pitfalls
+
+- **Jobs start in Draft:** Newly created jobs via `ASHBY_CREATE_JOB` start in "Draft" status and cannot accept applications until a `defaultInterviewPlanId` is set and the job is opened.
+- **Four required fields for jobs:** `ASHBY_CREATE_JOB` requires `title`, `teamId`, `locationId`, and `brandId`. Use list departments, locations, and brands endpoints to discover valid IDs.
+- **Candidate before application:** A candidate must exist before creating an application. Always create or find the candidate first, then create the application.
+- **Cursor-based pagination:** All list endpoints use cursor-based pagination with `perPage` (max 100) and `cursor`. You cannot jump to arbitrary pages -- you must iterate sequentially.
+- **`syncToken` for efficiency:** Use `syncToken` from previous responses to fetch only changed records. This dramatically reduces API calls for recurring workflows.
+- **UUID format everywhere:** All IDs (candidates, jobs, applications, stages) are UUIDs. Passing malformed IDs returns 400 errors.
+- **Search limitations:** `ASHBY_SEARCH_CANDIDATES` supports exact email match or partial name match, but not combined queries or other fields. For broader searches, use `ASHBY_LIST_CANDIDATES` with pagination.
+
+---
+
+## Quick Reference
+
+| Tool Slug | Description |
+|---|---|
+| `ASHBY_CREATE_CANDIDATE` | Create a new candidate (requires `name`) |
+| `ASHBY_LIST_CANDIDATES` | List all candidates with pagination and sync |
+| `ASHBY_SEARCH_CANDIDATES` | Search candidates by email or name |
+| `ASHBY_GET_CANDIDATE_INFO` | Get full candidate details (requires `candidateId`) |
+| `ASHBY_UPDATE_CANDIDATE` | Update candidate profile information |
+| `ASHBY_LIST_CANDIDATE_NOTES` | List internal notes for a candidate |
+| `ASHBY_CREATE_JOB` | Create a job opening (requires `title`, `teamId`, `locationId`, `brandId`) |
+| `ASHBY_LIST_JOBS` | List all jobs with pagination and sync |
+| `ASHBY_GET_JOB_INFO` | Get full job details by ID |
+| `ASHBY_CREATE_APPLICATION` | Apply a candidate to a job (requires `candidateId`, `jobId`) |
+| `ASHBY_LIST_APPLICATIONS` | List all applications with pagination and sync |
+| `ASHBY_LIST_INTERVIEW_SCHEDULES` | List scheduled interviews with pagination |
+
+---
+
+*Powered by [Composio](https://composio.dev)*

asin-data-api-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: asin-data-api-automation
+description: "Automate Asin Data API tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Asin Data API Automation via Rube MCP
+
+Automate Asin Data API operations through Composio's Asin Data API toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/asin_data_api](https://composio.dev/toolkits/asin_data_api)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Asin Data API connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `asin_data_api`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `asin_data_api`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Asin Data API 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 Asin Data API task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["asin_data_api"]
+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 Asin Data API-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `asin_data_api` |
+| 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](https://composio.dev)*

astica-ai-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: astica-ai-automation
+description: "Automate Astica AI tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Astica AI Automation via Rube MCP
+
+Automate Astica AI operations through Composio's Astica AI toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/astica_ai](https://composio.dev/toolkits/astica_ai)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Astica AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `astica_ai`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `astica_ai`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Astica AI 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 Astica AI task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["astica_ai"]
+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 Astica AI-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `astica_ai` |
+| 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](https://composio.dev)*

async-interview-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: async-interview-automation
+description: "Automate Async Interview tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Async Interview Automation via Rube MCP
+
+Automate Async Interview operations through Composio's Async Interview toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/async_interview](https://composio.dev/toolkits/async_interview)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Async Interview connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `async_interview`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `async_interview`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Async Interview 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 Async Interview task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["async_interview"]
+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 Async Interview-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `async_interview` |
+| 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](https://composio.dev)*

atlassian-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: atlassian-automation
+description: "Automate Atlassian tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Atlassian Automation via Rube MCP
+
+Automate Atlassian operations through Composio's Atlassian toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/atlassian](https://composio.dev/toolkits/atlassian)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Atlassian connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `atlassian`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `atlassian`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Atlassian 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 Atlassian task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["atlassian"]
+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 Atlassian-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `atlassian` |
+| 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](https://composio.dev)*

attio-automation/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: Attio Automation
+description: "Automate Attio CRM operations -- search records, query contacts and companies with advanced filters, manage notes, list attributes, and navigate your relationship data -- using natural language through the Composio MCP integration."
+category: crm
+requires:
+  mcp:
+    - rube
+---
+
+# Attio Automation
+
+Manage your Attio CRM workspace -- fuzzy search across people and companies, run complex filtered queries, browse notes, discover object schemas, and list records -- all through natural language commands.
+
+**Toolkit docs:** [composio.dev/toolkits/attio](https://composio.dev/toolkits/attio)
+
+---
+
+## Setup
+
+1. Add the Composio MCP server to your client configuration:
+   ```
+   https://rube.app/mcp
+   ```
+2. Connect your Attio account when prompted (OAuth authentication).
+3. Start issuing natural language commands to manage your CRM data.
+
+---
+
+## Core Workflows
+
+### 1. Fuzzy Search Across Records
+Search for people, companies, deals, or any object by name, domain, email, phone, or social handle.
+
+**Tool:** `ATTIO_SEARCH_RECORDS`
+
+**Example prompt:**
+> "Search Attio for anyone named Alan Mathis"
+
+**Key parameters (all required):**
+- `query` -- Search string (max 256 characters). Empty string returns default results.
+- `objects` -- Array of object slugs to search (e.g., `["people"]`, `["people", "companies"]`, `["deals"]`)
+- `request_as` -- Context: use `{"type": "workspace"}` for full workspace search, or specify a workspace member
+
+---
+
+### 2. Advanced Filtered Queries
+Query records with server-side filtering, sorting, and complex conditions -- far more powerful than fuzzy search.
+
+**Tool:** `ATTIO_QUERY_RECORDS`
+
+**Example prompt:**
+> "Find all companies in Attio created after January 2025 sorted by name"
+
+**Key parameters:**
+- `object` (required) -- Object slug or UUID (e.g., "people", "companies", "deals")
+- `filter` -- Attio filter object with operators like `$eq`, `$contains`, `$gte`, `$and`, `$or`
+- `sorts` -- Array of sort specifications with `direction` ("asc"/"desc") and `attribute`
+- `limit` -- Max records to return (up to 500)
+- `offset` -- Pagination offset
+
+**Filter examples:**
+```json
+{"name": {"first_name": {"$contains": "John"}}}
+{"email_addresses": {"$contains": "@example.com"}}
+{"created_at": {"$gte": "2025-01-01T00:00:00.000Z"}}
+```
+
+---
+
+### 3. Find Records by ID or Attributes
+Look up a specific record by its unique ID or search by unique attribute values.
+
+**Tool:** `ATTIO_FIND_RECORD`
+
+**Example prompt:**
+> "Find the Attio company with domain example.com"
+
+**Key parameters:**
+- `object_id` (required) -- Object type slug: "people", "companies", "deals", "users", "workspaces"
+- `record_id` -- Direct lookup by UUID (optional)
+- `attributes` -- Dictionary of attribute filters (e.g., `{"email_addresses": "john@example.com"}`)
+- `limit` -- Max records (up to 1000)
+- `offset` -- Pagination offset
+
+---
+
+### 4. Browse and Filter Notes
+List notes across the workspace or filter by specific parent objects and records.
+
+**Tool:** `ATTIO_LIST_NOTES`
+
+**Example prompt:**
+> "Show the last 10 notes on the Acme Corp company record in Attio"
+
+**Key parameters:**
+- `parent_object` -- Object slug (e.g., "people", "companies", "deals") -- requires `parent_record_id`
+- `parent_record_id` -- UUID of the parent record -- requires `parent_object`
+- `limit` -- Max notes to return (1-50, default 10)
+- `offset` -- Number of results to skip
+
+---
+
+### 5. Discover Object Schemas and Attributes
+Understand your workspace structure by listing objects and their attribute definitions.
+
+**Tools:** `ATTIO_GET_OBJECT`, `ATTIO_LIST_ATTRIBUTES`
+
+**Example prompt:**
+> "What attributes does the companies object have in Attio?"
+
+**Key parameters for Get Object:**
+- `object_id` -- Object slug or UUID
+
+**Key parameters for List Attributes:**
+- `target` -- "objects" or "lists"
+- `identifier` -- Object or list ID/slug
+
+---
+
+### 6. List All Records
+Retrieve records from a specific object type with simple pagination, returned in creation order.
+
+**Tool:** `ATTIO_LIST_RECORDS`
+
+**Example prompt:**
+> "List the first 100 people records in Attio"
+
+**Key parameters:**
+- Object type identifier
+- Pagination parameters
+
+---
+
+## Known Pitfalls
+
+- **Timestamp format is critical**: ALL timestamp comparisons (`created_at`, `updated_at`, custom timestamps) MUST use ISO8601 string format (e.g., `2025-01-01T00:00:00.000Z`). Unix timestamps or numeric values cause "Invalid timestamp value" errors.
+- **Name attributes must be nested**: The `name` attribute has sub-properties (`first_name`, `last_name`, `full_name`) that MUST be nested under `name`. Correct: `{"name": {"first_name": {"$contains": "John"}}}`. Wrong: `{"first_name": {...}}` -- this fails with "unknown_filter_attribute_slug".
+- **Email operators are limited**: `email_addresses` supports `$eq`, `$contains`, `$starts_with`, `$ends_with` but NOT `$not_empty`.
+- **Record-reference attributes need path filtering**: For attributes that reference other records (e.g., "team", "company"), use path-based filtering, not nested syntax. Example: `{"path": [["companies", "team"], ["people", "name"]], "constraints": {"first_name": {"$eq": "John"}}}`.
+- **"lists" is not an object type**: Do not use "lists" as an `object_id`. Use list-specific actions for list operations.
+- **Search is eventually consistent**: `ATTIO_SEARCH_RECORDS` returns eventually consistent results. For guaranteed up-to-date results, use `ATTIO_QUERY_RECORDS` instead.
+- **Attribute slugs vary by workspace**: System attributes (e.g., "email_addresses", "name") are consistent, but custom attributes vary. Use `ATTIO_LIST_ATTRIBUTES` to discover valid slugs for your workspace.
+
+---
+
+## Quick Reference
+
+| Action | Tool Slug | Required Params |
+|---|---|---|
+| Fuzzy search records | `ATTIO_SEARCH_RECORDS` | `query`, `objects`, `request_as` |
+| Query with filters | `ATTIO_QUERY_RECORDS` | `object` |
+| Find record by ID/attributes | `ATTIO_FIND_RECORD` | `object_id` |
+| List notes | `ATTIO_LIST_NOTES` | None (optional filters) |
+| Get object schema | `ATTIO_GET_OBJECT` | `object_id` |
+| List attributes | `ATTIO_LIST_ATTRIBUTES` | `target`, `identifier` |
+| List records | `ATTIO_LIST_RECORDS` | Object type |
+
+---
+
+*Powered by [Composio](https://composio.dev)*

auth0-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: auth0-automation
+description: "Automate Auth0 tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Auth0 Automation via Rube MCP
+
+Automate Auth0 operations through Composio's Auth0 toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/auth0](https://composio.dev/toolkits/auth0)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Auth0 connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `auth0`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `auth0`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Auth0 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 Auth0 task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["auth0"]
+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 Auth0-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `auth0` |
+| 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](https://composio.dev)*

autobound-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: autobound-automation
+description: "Automate Autobound tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Autobound Automation via Rube MCP
+
+Automate Autobound operations through Composio's Autobound toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/autobound](https://composio.dev/toolkits/autobound)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Autobound connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `autobound`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `autobound`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Autobound 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 Autobound task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["autobound"]
+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 Autobound-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `autobound` |
+| 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](https://composio.dev)*

autom-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: autom-automation
+description: "Automate Autom tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Autom Automation via Rube MCP
+
+Automate Autom operations through Composio's Autom toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/autom](https://composio.dev/toolkits/autom)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Autom connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `autom`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `autom`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Autom 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 Autom task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["autom"]
+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 Autom-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `autom` |
+| 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](https://composio.dev)*

axonaut-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: axonaut-automation
+description: "Automate Axonaut tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Axonaut Automation via Rube MCP
+
+Automate Axonaut operations through Composio's Axonaut toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/axonaut](https://composio.dev/toolkits/axonaut)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Axonaut connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `axonaut`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `axonaut`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Axonaut 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 Axonaut task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["axonaut"]
+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 Axonaut-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `axonaut` |
+| 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](https://composio.dev)*

ayrshare-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ayrshare-automation
+description: "Automate Ayrshare tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ayrshare Automation via Rube MCP
+
+Automate Ayrshare operations through Composio's Ayrshare toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ayrshare](https://composio.dev/toolkits/ayrshare)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ayrshare connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ayrshare`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ayrshare`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ayrshare 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 Ayrshare task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ayrshare"]
+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 Ayrshare-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ayrshare` |
+| 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](https://composio.dev)*

backendless-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: backendless-automation
+description: "Automate Backendless tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Backendless Automation via Rube MCP
+
+Automate Backendless operations through Composio's Backendless toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/backendless](https://composio.dev/toolkits/backendless)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Backendless connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `backendless`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `backendless`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Backendless 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 Backendless task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["backendless"]
+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 Backendless-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `backendless` |
+| 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](https://composio.dev)*

bamboohr-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate BambooHR human resources operations through Composio's BambooHR toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/bamboohr](https://composio.dev/toolkits/bamboohr)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -218,3 +220,6 @@ For keeping external systems in sync with BambooHR:
 | Update employee | BAMBOOHR_UPDATE_EMPLOYEE | id, (field updates) |
 | List dependents | BAMBOOHR_DEPENDENTS_GET_ALL | employeeId |
 | Benefit coverages | BAMBOOHR_BENEFIT_GET_COVERAGES | (check schema) |
+
+---
+*Powered by [Composio](https://composio.dev)*

bannerbear-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bannerbear-automation
+description: "Automate Bannerbear tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bannerbear Automation via Rube MCP
+
+Automate Bannerbear operations through Composio's Bannerbear toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bannerbear](https://composio.dev/toolkits/bannerbear)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bannerbear connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bannerbear`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bannerbear`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bannerbear 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 Bannerbear task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bannerbear"]
+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 Bannerbear-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bannerbear` |
+| 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](https://composio.dev)*

bart-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bart-automation
+description: "Automate Bart tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bart Automation via Rube MCP
+
+Automate Bart operations through Composio's Bart toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bart](https://composio.dev/toolkits/bart)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bart connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bart`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bart`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bart 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 Bart task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bart"]
+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 Bart-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bart` |
+| 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](https://composio.dev)*

basecamp-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate Basecamp operations including project management, to-do list creation, task management, message board posting, people management, and to-do group organization through Composio's Basecamp toolkit.
 
+**Toolkit docs**: [composio.dev/toolkits/basecamp](https://composio.dev/toolkits/basecamp)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -232,3 +234,6 @@ Basecamp uses page-based pagination on list endpoints:
 | List all people | `BASECAMP_GET_PEOPLE` | (none) |
 | List project people | `BASECAMP_LIST_PROJECT_PEOPLE` | `project_id` |
 | Manage access | `BASECAMP_PUT_PROJECTS_PEOPLE_USERS` | `project_id`, `grant`, `revoke`, `create` |
+
+---
+*Powered by [Composio](https://composio.dev)*

baselinker-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: baselinker-automation
+description: "Automate Baselinker tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Baselinker Automation via Rube MCP
+
+Automate Baselinker operations through Composio's Baselinker toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/baselinker](https://composio.dev/toolkits/baselinker)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Baselinker connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `baselinker`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `baselinker`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Baselinker 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 Baselinker task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["baselinker"]
+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 Baselinker-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `baselinker` |
+| 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](https://composio.dev)*

baserow-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: baserow-automation
+description: "Automate Baserow tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Baserow Automation via Rube MCP
+
+Automate Baserow operations through Composio's Baserow toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/baserow](https://composio.dev/toolkits/baserow)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Baserow connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `baserow`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `baserow`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Baserow 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 Baserow task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["baserow"]
+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 Baserow-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `baserow` |
+| 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](https://composio.dev)*

basin-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: basin-automation
+description: "Automate Basin tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Basin Automation via Rube MCP
+
+Automate Basin operations through Composio's Basin toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/basin](https://composio.dev/toolkits/basin)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Basin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `basin`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `basin`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Basin 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 Basin task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["basin"]
+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 Basin-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `basin` |
+| 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](https://composio.dev)*

battlenet-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: battlenet-automation
+description: "Automate Battlenet tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Battlenet Automation via Rube MCP
+
+Automate Battlenet operations through Composio's Battlenet toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/battlenet](https://composio.dev/toolkits/battlenet)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Battlenet connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `battlenet`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `battlenet`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Battlenet 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 Battlenet task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["battlenet"]
+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 Battlenet-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `battlenet` |
+| 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](https://composio.dev)*

beaconchain-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: beaconchain-automation
+description: "Automate Beaconchain tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Beaconchain Automation via Rube MCP
+
+Automate Beaconchain operations through Composio's Beaconchain toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/beaconchain](https://composio.dev/toolkits/beaconchain)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Beaconchain connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconchain`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconchain`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Beaconchain 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 Beaconchain task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["beaconchain"]
+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 Beaconchain-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconchain` |
+| 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](https://composio.dev)*

beaconstac-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: beaconstac-automation
+description: "Automate Beaconstac tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Beaconstac Automation via Rube MCP
+
+Automate Beaconstac operations through Composio's Beaconstac toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/beaconstac](https://composio.dev/toolkits/beaconstac)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Beaconstac connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconstac`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconstac`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Beaconstac 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 Beaconstac task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["beaconstac"]
+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 Beaconstac-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconstac` |
+| 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](https://composio.dev)*

beamer-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: beamer-automation
+description: "Automate Beamer tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Beamer Automation via Rube MCP
+
+Automate Beamer operations through Composio's Beamer toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/beamer](https://composio.dev/toolkits/beamer)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Beamer connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `beamer`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `beamer`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Beamer 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 Beamer task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["beamer"]
+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 Beamer-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `beamer` |
+| 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](https://composio.dev)*

beeminder-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: beeminder-automation
+description: "Automate Beeminder tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Beeminder Automation via Rube MCP
+
+Automate Beeminder operations through Composio's Beeminder toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/beeminder](https://composio.dev/toolkits/beeminder)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Beeminder connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `beeminder`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `beeminder`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Beeminder 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 Beeminder task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["beeminder"]
+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 Beeminder-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `beeminder` |
+| 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](https://composio.dev)*

bench-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bench-automation
+description: "Automate Bench tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bench Automation via Rube MCP
+
+Automate Bench operations through Composio's Bench toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bench](https://composio.dev/toolkits/bench)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bench connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bench`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bench`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bench 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 Bench task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bench"]
+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 Bench-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bench` |
+| 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](https://composio.dev)*

benchmark-email-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: benchmark-email-automation
+description: "Automate Benchmark Email tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Benchmark Email Automation via Rube MCP
+
+Automate Benchmark Email operations through Composio's Benchmark Email toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/benchmark_email](https://composio.dev/toolkits/benchmark_email)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Benchmark Email connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `benchmark_email`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `benchmark_email`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Benchmark Email 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 Benchmark Email task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["benchmark_email"]
+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 Benchmark Email-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `benchmark_email` |
+| 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](https://composio.dev)*

benzinga-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: benzinga-automation
+description: "Automate Benzinga tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Benzinga Automation via Rube MCP
+
+Automate Benzinga operations through Composio's Benzinga toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/benzinga](https://composio.dev/toolkits/benzinga)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Benzinga connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `benzinga`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `benzinga`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Benzinga 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 Benzinga task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["benzinga"]
+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 Benzinga-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `benzinga` |
+| 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](https://composio.dev)*

bestbuy-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bestbuy-automation
+description: "Automate Bestbuy tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bestbuy Automation via Rube MCP
+
+Automate Bestbuy operations through Composio's Bestbuy toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bestbuy](https://composio.dev/toolkits/bestbuy)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bestbuy connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bestbuy`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bestbuy`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bestbuy 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 Bestbuy task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bestbuy"]
+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 Bestbuy-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bestbuy` |
+| 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](https://composio.dev)*

better-proposals-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: better-proposals-automation
+description: "Automate Better Proposals tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Better Proposals Automation via Rube MCP
+
+Automate Better Proposals operations through Composio's Better Proposals toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/better_proposals](https://composio.dev/toolkits/better_proposals)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Better Proposals connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `better_proposals`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `better_proposals`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Better Proposals 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 Better Proposals task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["better_proposals"]
+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 Better Proposals-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `better_proposals` |
+| 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](https://composio.dev)*

better-stack-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: better-stack-automation
+description: "Automate Better Stack tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Better Stack Automation via Rube MCP
+
+Automate Better Stack operations through Composio's Better Stack toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/better_stack](https://composio.dev/toolkits/better_stack)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Better Stack connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `better_stack`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `better_stack`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Better Stack 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 Better Stack task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["better_stack"]
+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 Better Stack-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `better_stack` |
+| 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](https://composio.dev)*

bidsketch-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bidsketch-automation
+description: "Automate Bidsketch tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bidsketch Automation via Rube MCP
+
+Automate Bidsketch operations through Composio's Bidsketch toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bidsketch](https://composio.dev/toolkits/bidsketch)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bidsketch connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bidsketch`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bidsketch`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bidsketch 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 Bidsketch task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bidsketch"]
+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 Bidsketch-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bidsketch` |
+| 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](https://composio.dev)*

big-data-cloud-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: big-data-cloud-automation
+description: "Automate Big Data Cloud tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Big Data Cloud Automation via Rube MCP
+
+Automate Big Data Cloud operations through Composio's Big Data Cloud toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/big_data_cloud](https://composio.dev/toolkits/big_data_cloud)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Big Data Cloud connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `big_data_cloud`
+- 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.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `big_data_cloud`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Big Data Cloud 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 Big Data Cloud task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["big_data_cloud"]
+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 Big Data Cloud-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `big_data_cloud` |
+| 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](https://composio.dev)*