Do I need API keys to use renderform-automation?

No API keys are required; you only need to add the MCP endpoint (https://rube.app/mcp) to your client.

How do I ensure I’m calling the current tool schemas?

Always call RUBE_SEARCH_TOOLS before selecting a tool_slug to fetch up-to-date schemas and avoid hardcoding.

What indicates a successful workflow?

A successful workflow should show that the tool executed with a valid session_id and the connection status is ACTIVE before and after execution.

renderform-automation

Scanned

npx machina-cli add skill ComposioHQ/awesome-claude-skills/renderform-automation --openclaw

Files (1)

SKILL.md

2.9 KB

Renderform Automation via Rube MCP

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

Toolkit docs: composio.dev/toolkits/renderform

Prerequisites

Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
Active Renderform connection via RUBE_MANAGE_CONNECTIONS with toolkit renderform
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.

Verify Rube MCP is available by confirming RUBE_SEARCH_TOOLS responds
Call RUBE_MANAGE_CONNECTIONS with toolkit renderform
If connection is not ACTIVE, follow the returned auth link to complete setup
Confirm connection status shows ACTIVE before running any workflows

Tool Discovery

Always discover available tools before executing workflows:

RUBE_SEARCH_TOOLS
queries: [{use_case: "Renderform 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 Renderform task"}]
session: {id: "existing_session_id"}

Step 2: Check Connection

RUBE_MANAGE_CONNECTIONS
toolkits: ["renderform"]
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 Renderform-specific use case
Connect	`RUBE_MANAGE_CONNECTIONS` with toolkit `renderform`
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

Source

git clone https://github.com/ComposioHQ/awesome-claude-skills/blob/master/composio-skills/renderform-automation/SKILL.mdView on GitHub

Overview

This skill automates Renderform operations through Composio’s Renderform toolkit using Rube MCP. It emphasizes discovering current tool schemas first with RUBE_SEARCH_TOOLS and verifying an ACTIVE connection via RUBE_MANAGE_CONNECTIONS before executing workflows.

How This Skill Works

Connect to Rube MCP and verify availability with RUBE_SEARCH_TOOLS. Manage a Renderform connection using RUBE_MANAGE_CONNECTIONS and ensure the status is ACTIVE. Then discover available tools, select a tool_slug, provide schema-compliant arguments, and execute via RUBE_MULTI_EXECUTE_TOOL, including an empty memory object and a session_id for continuity.

When to Use It

You need to automate a specific Renderform operation end-to-end using discovered tool schemas.
Tool schemas change frequently and you must fetch current slugs and argument names before execution.
You want to ensure the Renderform connection is ACTIVE before running workflows.
You perform bulk or chained Renderform tasks within a single session.
You need a repeatable workflow template that handles tool discovery and execution reliably.

Quick Start

Step 1: Add https://rube.app/mcp as an MCP server in your client configuration.
Step 2: Verify MCP availability with RUBE_SEARCH_TOOLS and establish a Renderform connection using RUBE_MANAGE_CONNECTIONS.
Step 3: Discover a Renderform tool slug, then execute it with RUBE_MULTI_EXECUTE_TOOL using memory and a session_id.

Best Practices

Always call RUBE_SEARCH_TOOLS before selecting a tool slug to get current schemas.
Check the connection status with RUBE_MANAGE_CONNECTIONS and ensure it is ACTIVE before executing tools.
Use exact field names and types from the search results; do not hardcode slugs or arguments.
Include memory in RUBE_MULTI_EXECUTE_TOOL calls, even if it is an empty object {}.
Reuse session IDs within a workflow and handle pagination when tool discovery responses are paginated.

Example Use Cases

Automate rendering a document by discovering the appropriate Renderform tool and executing it with the correct arguments derived from the tool's schema.
Validate the Renderform connection and tool schemas before running a batch of render tasks to prevent failures.
Bulk render multiple documents by discovering tools, then iterating executions within a single session.
Fetch full tool schemas via RUBE_GET_TOOL_SCHEMAS to reference exact input fields for complex tasks.
Recover from a failed run by reusing an existing session_id and retrying with updated arguments.

Frequently Asked Questions

Add this skill to your agents