home / skills / composiohq / awesome-claude-skills / castingwords-automation

castingwords-automation skill

safe

This skill automates Castingwords tasks via Rube MCP, prioritizing tool discovery and active connections to streamline workflows.

npx playbooks add skill composiohq/awesome-claude-skills --skill castingwords-automation

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.9 KB

---
name: castingwords-automation
description: "Automate Castingwords tasks via Rube MCP (Composio). Always search tools first for current schemas."
requires:
  mcp: [rube]
---

# Castingwords Automation via Rube MCP

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

**Toolkit docs**: [composio.dev/toolkits/castingwords](https://composio.dev/toolkits/castingwords)

## Prerequisites

- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Castingwords connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `castingwords`
- 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 `castingwords`
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: "Castingwords 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 Castingwords task"}]
session: {id: "existing_session_id"}
```

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["castingwords"]
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 Castingwords-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `castingwords` |
| 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)*

Overview

This skill automates Castingwords tasks through Composio’s Castingwords toolkit using the Rube MCP. It provides a repeatable workflow: discover tools, verify connections, then execute toolkit operations with schema-compliant arguments. The skill emphasizes always searching tools first to avoid broken calls when schemas change.

How this skill works

The skill drives Rube MCP endpoints: RUBE_SEARCH_TOOLS to discover current tool slugs and input schemas, RUBE_MANAGE_CONNECTIONS to validate or complete the Castingwords connection, and RUBE_MULTI_EXECUTE_TOOL (or RUBE_REMOTE_WORKBENCH for bulk jobs) to run operations. Each run reuses a session ID, includes a memory object (even if empty), and follows the exact field names/types returned by the search.

When to use it

Automating transcription upload, status checks, and result retrieval for Castingwords.
Running bulk or scheduled Castingwords jobs via Composio toolchains.
Integrating Castingwords operations into Claude or other agent workflows.
When you need schema-safe, repeatable execution across changing tool APIs.
Before any Castingwords call to prevent failures from outdated tool metadata.

Best practices

Always call RUBE_SEARCH_TOOLS first and use returned tool slugs and schemas.
Verify toolkit connection with RUBE_MANAGE_CONNECTIONS and follow auth link until status is ACTIVE.
Include memory in RUBE_MULTI_EXECUTE_TOOL calls, even if empty ({}).
Reuse session_id within a workflow; generate a new one for separate workflows.
Check for pagination tokens and continue fetching until results are complete.

Example use cases

Discover available Castingwords operations and run a single transcription-submit tool with schema-compliant args.
Automate a daily batch: use RUBE_SEARCH_TOOLS, confirm connection, then call RUBE_REMOTE_WORKBENCH to run run_composio_tool() across many files.
Build an agent that checks transcription job status and retrieves completed transcripts using tool slugs from search results.
Migrate from manual uploads to a CI job that submits media and polls for completion using sessions and memory.

FAQ

Do I need API keys to use Rube MCP?

No API keys are required when you add https://rube.app/mcp as an MCP server; you must still manage and complete Castingwords authorization via RUBE_MANAGE_CONNECTIONS.

What happens if a tool schema changes?

Always re-run RUBE_SEARCH_TOOLS before executing. Use the returned schema fields and types; never hardcode arguments based on prior results.