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

chmeetings-automation skill

safe

/chmeetings-automation

This skill automates Chmeetings tasks via Rube MCP by discovering current tool schemas first and executing compliant tools.

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

# Chmeetings Automation via Rube MCP

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

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

## Prerequisites

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

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["chmeetings"]
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 Chmeetings-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `chmeetings` |
| 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 Chmeetings tasks by driving Composio’s Chmeetings toolkit through the Rube MCP bridge. It orchestrates discovery, connection verification, and execution of Composio tools so you can run meeting and event operations programmatically. The flow enforces live schema discovery and safe session/connection handling to avoid brittle integrations.

How this skill works

The skill always begins by calling RUBE_SEARCH_TOOLS to retrieve current tool slugs, input schemas, and execution guidance. It then checks and activates the Chmeetings connection via RUBE_MANAGE_CONNECTIONS. Finally it runs one or more tools using RUBE_MULTI_EXECUTE_TOOL (including memory and session handling) and follows pagination or schema refs when needed.

When to use it

Automate scheduling, attendee management, or event updates in Chmeetings.
Run bulk operations or remote workflows that require Composio tools.
Integrate Chmeetings actions into larger Claude-driven automation pipelines.
Ensure schema-driven execution when tool inputs may change frequently.

Best practices

Always call RUBE_SEARCH_TOOLS first to obtain current tool slugs and exact input schemas.
Verify connection status with RUBE_MANAGE_CONNECTIONS and complete any auth steps until status is ACTIVE.
Pass a session_id and reuse it across related calls; generate a new session for distinct workflows.
Include a memory parameter (even an empty object) in every RUBE_MULTI_EXECUTE_TOOL call.
Watch for pagination tokens and follow them to fetch complete results.
Respect schema field names and types exactly—do not hardcode inputs.

Example use cases

Create or update meeting records in bulk by discovering the correct create/update tool and supplying schema-compliant arguments.
Onboard a new Chmeetings account by running the connection flow, completing auth, and validating ACTIVE status programmatically.
Trigger attendee notifications and follow-up tasks by composing multiple tool executions in a single session.
Run periodic audits to fetch full event lists using pagination-aware calls to RUBE_GET_TOOL_SCHEMAS and multi-execute flows.

FAQ

Do I need API keys to connect to Rube MCP?

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

What if a tool slug or input changes?

Always re-run RUBE_SEARCH_TOOLS before executing. The search response provides the current slug, input schema, and recommended execution plan to avoid failures.