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

refiner-automation skill

safe

/refiner-automation

This skill automates Refiner tasks via Rube MCP, always discovering current tool schemas before execution to ensure accurate up to date workflows.

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

# Refiner Automation via Rube MCP

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

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

## Prerequisites

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

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["refiner"]
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 Refiner-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `refiner` |
| 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 Refiner tasks by orchestrating Composio’s Refiner toolkit through Rube MCP. It provides a reliable pattern for discovering tools, validating connections, and executing multi-step Refiner operations while enforcing schema compliance. Use it to run single or bulk Refiner workflows programmatically and safely.

How this skill works

The skill first calls RUBE_SEARCH_TOOLS to discover current tool slugs, input schemas, and recommended plans. It then ensures an active Refiner connection via RUBE_MANAGE_CONNECTIONS and runs operations with RUBE_MULTI_EXECUTE_TOOL or RUBE_REMOTE_WORKBENCH, always passing memory and session IDs. It emphasizes live schema inspection and session reuse to avoid brittle, hardcoded calls.

When to use it

Automate Refiner form or survey creation, updates, or responses.
Execute bulk Refiner operations across multiple resources reliably.
Integrate Refiner actions into larger agent workflows or pipelines.
When tool schemas may change frequently and you need schema-first execution.
When multi-step Refiner workflows require consistent session and memory handling.

Best practices

Always call RUBE_SEARCH_TOOLS before any execution to fetch current schemas and tool slugs.
Verify RUBE_MANAGE_CONNECTIONS reports ACTIVE for the refiner toolkit before running tools.
Use exact field names and types returned by the search; don’t guess or hardcode argument shapes.
Include a memory object (even empty {}) in RUBE_MULTI_EXECUTE_TOOL calls.
Reuse session IDs for steps in the same workflow; generate a new session for separate workflows.
Check for pagination tokens in responses and fetch until complete when listing resources.

Example use cases

Create or update multiple Refiner surveys: discover survey tool, validate connection, execute multi-create via RUBE_MULTI_EXECUTE_TOOL.
Ingest responses into a downstream system: search for response-export tools, run export, then call downstream processors in the same session.
Bulk modify survey fields or logic across many forms using RUBE_REMOTE_WORKBENCH and run_composio_tool().
Build an agent that reacts to events and performs Refiner tasks dynamically by always fetching schemas first.

FAQ

Do I need API keys to use Rube MCP?

No API keys are required. Add https://rube.app/mcp as an MCP server in your client and call the Rube endpoints.

What if a tool schema changed mid-workflow?

Always re-run RUBE_SEARCH_TOOLS before critical steps. Reuse sessions for step continuity but rediscover tools when inputs or tool behavior may have changed.