What is Echtpost Automation via Rube MCP?

It is a workflow approach to automate Echtpost tasks using Composio's Echtpost toolkit through the Rube MCP interface, with dynamic schema discovery and validated connections.

Why must I search for tool schemas every time?

Tool schemas change over time. Calling RUBE_SEARCH_TOOLS ensures you use current tool slugs and exact field names, preventing failures from hardcoded values.

How do I ensure I only run tools when the connection is ready?

Always verify ACTIVE status with RUBE_MANAGE_CONNECTIONS for the Echtpost toolkit before executing any tools, and wait for an ACTIVE confirmation prior to RUBE_MULTI_EXECUTE_TOOL.

echtpost-automation

Scanned

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

Files (1)

SKILL.md

2.9 KB

Echtpost Automation via Rube MCP

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

Toolkit docs: composio.dev/toolkits/echtpost

Prerequisites

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

Step 2: Check Connection

RUBE_MANAGE_CONNECTIONS
toolkits: ["echtpost"]
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 Echtpost-specific use case
Connect	`RUBE_MANAGE_CONNECTIONS` with toolkit `echtpost`
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/echtpost-automation/SKILL.mdView on GitHub

Overview

Echtpost Automation via Rube MCP enables executing Echtpost workflows by discovering current tool schemas through RUBE_SEARCH_TOOLS, managing Echtpost connections with RUBE_MANAGE_CONNECTIONS, and running tools via RUBE_MULTI_EXECUTE_TOOL. This keeps integrations up-to-date and avoids hardcoding tool slugs. It emphasizes validating ACTIVE connections before execution.

How This Skill Works

You connect Rube MCP to Echtpost, then first call RUBE_SEARCH_TOOLS to retrieve latest Echtpost tool schemas. After confirming an ACTIVE Echtpost connection with RUBE_MANAGE_CONNECTIONS, you execute the desired tool using RUBE_MULTI_EXECUTE_TOOL, supplying the exact arguments from the discovered schema and memory payload. This pattern supports session reuse and handles pagination as needed.

When to Use It

Automating recurring Echtpost operations (daily/weekly tasks).
When tool schemas change, requiring dynamic discovery before each run.
When building a multi-step Echtpost workflow that chains tool executions.
When performing bulk Echtpost operations via a single workflow (multiple tools).
When onboarding a new Echtpost integration and establishing a fresh ACTIVE connection.

Quick Start

Step 1: Discover Echtpost tools with RUBE_SEARCH_TOOLS using use_case: "Echtpost operations".
Step 2: Check the Echtpost connection status with RUBE_MANAGE_CONNECTIONS for toolkit: "echtpost" and ensure ACTIVE.
Step 3: Execute a tool with RUBE_MULTI_EXECUTE_TOOL, providing memory and the exact arguments from the discovered schema.

Best Practices

Always call RUBE_SEARCH_TOOLS before executing to get current tool schemas.
Verify RUBE_MANAGE_CONNECTIONS reports ACTIVE before any tool runs.
Use exact field names and types from the current tool schemas; avoid hardcoding slugs.
Include memory in RUBE_MULTI_EXECUTE_TOOL payloads, even if empty.
Reuse session IDs within a workflow and fetch new ones for new workflows; handle pagination tokens when present.

Example Use Cases

Schedule a daily Echtpost export by discovering the relevant tool slug, establishing an ACTIVE connection, and executing with a prepared memory state.
Create a two-step Echtpost workflow: discover tools for a task, then run Tool_Slug_X with the required arguments in a single session.
Perform bulk Echtpost operations across multiple tools using RUBE_REMOTE_WORKBENCH and run_composio_tool().
Onboard a new Echtpost integration by discovering available tools, connecting with the Echtpost toolkit, and executing an initial task.
Debug tool schema changes by re-running RUBE_SEARCH_TOOLS to refresh tool slugs and input schemas before execution.

Frequently Asked Questions

Add this skill to your agents