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

ascora-automation skill

safe

/ascora-automation

This skill automates Ascora workflows via Rube MCP, prioritizing live tool schemas and active connections for reliable task execution.

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

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

Files (1)

SKILL.md

2.8 KB

---
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)*

Overview

This skill automates Ascora tasks using Composio's Ascora toolkit via the Rube MCP gateway. It orchestrates discovery, connection management, and tool execution so workflows run against the current tool schemas. It is designed to be used from an agent that can call Rube MCP actions.

How this skill works

The skill always begins by calling RUBE_SEARCH_TOOLS to discover available Ascora tool slugs and input schemas. It verifies or establishes an Ascora connection via RUBE_MANAGE_CONNECTIONS, then runs actions with RUBE_MULTI_EXECUTE_TOOL (including a memory object) or RUBE_REMOTE_WORKBENCH for bulk operations. It handles session IDs, pagination tokens, and enforces schema compliance based on the returned tool definitions.

When to use it

Automating Ascora administrative tasks (resources, configs, operations).
Running composable Ascora workflows from an agent or automation service.
When tool schemas may change frequently and discovery is required.
Bulk operations or remote workbench runs against Ascora tools.
Integrating Ascora steps into larger multi-tool automation flows.

Best practices

Always call RUBE_SEARCH_TOOLS first — never hardcode tool slugs or argument shapes.
Verify Ascora connection with RUBE_MANAGE_CONNECTIONS and confirm status is ACTIVE before executing tools.
Pass exact field names and types returned in the tool schema; schema compliance is mandatory.
Include a memory object (even empty {}) in RUBE_MULTI_EXECUTE_TOOL calls.
Reuse session_id for steps in the same workflow; generate a new session for separate workflows.
Handle pagination tokens in search results and use RUBE_GET_TOOL_SCHEMAS when full schemas are needed.

Example use cases

Provision Ascora resources by discovering the appropriate provisioning tool and executing it with schema-compliant arguments.
Run a sequence of Ascora operations in one session: discover tools, confirm connection, and call RUBE_MULTI_EXECUTE_TOOL with multiple tool entries.
Perform bulk changes across Ascora environments using RUBE_REMOTE_WORKBENCH and run_composio_tool().
Validate and sync Ascora configuration by fetching tool schemas (RUBE_GET_TOOL_SCHEMAS) and applying updates programmatically.
Automate maintenance tasks that require repeated pagination-aware queries and batched executions.

FAQ

Do I need API keys to use Rube MCP?

No API keys are required; add the MCP endpoint (https://rube.app/mcp) to your client configuration and use the Rube MCP actions.

What if the Ascora connection is not ACTIVE?

Follow the auth link returned by RUBE_MANAGE_CONNECTIONS to complete setup, then recheck until the connection status is ACTIVE before running tools.