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

ncscale-automation skill

safe

/ncscale-automation

This skill automates Ncscale operations via Rube MCP, ensuring up-to-date tool schemas are discovered before executing workflows for reliable automation.

npx playbooks add skill composiohq/awesome-claude-skills --skill ncscale-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: ncscale-automation
description: "Automate Ncscale tasks via Rube MCP (Composio). Always search tools first for current schemas."
requires:
  mcp: [rube]
---

# Ncscale Automation via Rube MCP

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

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

## Prerequisites

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

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["ncscale"]
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 Ncscale-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ncscale` |
| 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 Ncscale tasks using Composio’s Ncscale toolkit through a Rube MCP server. It provides a repeatable pattern for discovering current tool schemas, validating connections, and executing Composio tools safely. Follow the search-first approach to avoid schema drift and execution errors.

How this skill works

The skill queries the Rube MCP registry (RUBE_SEARCH_TOOLS) to retrieve available tools, input schemas, and recommended plans for Ncscale operations. It verifies an active Ncscale connection via RUBE_MANAGE_CONNECTIONS, then runs one or more tools using RUBE_MULTI_EXECUTE_TOOL or RUBE_REMOTE_WORKBENCH with schema-compliant arguments and a session context. Memory and session handling are included to ensure consistent workflows.

When to use it

Automate routine Ncscale tasks like deployments, scaling, or configuration updates
Run bulk Ncscale operations across environments or projects
Integrate Ncscale operations into CI/CD or orchestration pipelines
Recover or audit Ncscale workflows that require exact schema compliance
When you need to programmatically discover current tool fields and avoid hardcoded arguments

Best practices

Always call RUBE_SEARCH_TOOLS first to fetch current tool slugs and full input schemas
Validate RUBE_MANAGE_CONNECTIONS shows ACTIVE for the ncscale toolkit before executing tools
Use the exact field names and types returned by search results; never assume schema shape
Include a memory object in RUBE_MULTI_EXECUTE_TOOL calls even if empty ({}). Reuse session IDs within a workflow and generate new ones per new workflow
Handle pagination in search responses and follow pagination tokens until all tools or results are fetched

Example use cases

Scale a set of Ncscale services by discovering the appropriate scaler tool and passing schema-compliant arguments
Bulk update configuration across environments using RUBE_REMOTE_WORKBENCH with run_composio_tool()
Embed Ncscale connection checks into CI pipelines to ensure operations only run when the toolkit is ACTIVE
Build an agent that dynamically discovers available Ncscale operations and constructs plans at runtime based on returned execution recommendations

FAQ

Why must I call RUBE_SEARCH_TOOLS first?

Tool schemas and slugs can change. Searching first ensures you use the current tool identifiers and exact input fields to avoid runtime errors.

What happens if the ncscale connection is not ACTIVE?

Follow the auth link returned by RUBE_MANAGE_CONNECTIONS to complete setup. Do not run execute calls until the connection status shows ACTIVE.

Do I need API keys to use Rube MCP?

No API keys are required when adding the MCP endpoint (https://rube.app/mcp) to your client; the MCP handles tool discovery and orchestration.