firefrost-gaming/composio-skills-reference
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upgrade 71 popular app skills with real tool data from RUBE_SEARCH_TOOLS

Browse Source 
Replaced generic templates with detailed skills containing:
- Real tool slugs discovered via RUBE_SEARCH_TOOLS
- Actual parameter schemas and types
- API-specific known pitfalls
- Quick reference tables with all discovered tools

Apps upgraded: Google Workspace (10), Finance/Microsoft (10),
CRM/Sales (9), DevOps/AI (10), Marketing/Social (8),
Support/Productivity/HR (8), Content/Analytics (9), Comms/Events (7)

8 apps skipped (no native Composio tools): Twitch, ManyChat,
Front, Deel, Adobe, RingCentral, Zoho Desk, Wave Accounting

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
sohamganatra
2026-02-11 14:30:20 -08:00
parent 8c60204e19
commit bea5251d4c
74 changed files with 8403 additions and 4126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
ahrefs-automation/SKILL.md
View File

@@ -1,91 +1,177 @@
---
name: ahrefs-automation
description: "Automate Ahrefs tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Ahrefs Automation
description: "Automate SEO research with Ahrefs -- analyze backlink profiles, research keywords, track domain metrics history, audit organic rankings, and perform batch URL analysis through the Composio Ahrefs integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Ahrefs Automation via Rube MCP
# Ahrefs Automation
Automate Ahrefs operations through Composio's Ahrefs toolkit via Rube MCP.
Run **Ahrefs** SEO analytics directly from Claude Code. Analyze backlink profiles, research keywords, track domain authority over time, audit organic keyword rankings, and batch-analyze multiple URLs without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/ahrefs](https://composio.dev/toolkits/ahrefs)
**Toolkit docs:** [composio.dev/toolkits/ahrefs](https://composio.dev/toolkits/ahrefs)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Ahrefs connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ahrefs`
- 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. Add the Composio MCP server to your configuration:
```
https://rube.app/mcp
```
2. Connect your Ahrefs account when prompted. The agent will provide an authentication link.
3. Most tools require a `target` (domain or URL) and a `country` code (ISO 3166-1 alpha-2). Some also require a `date` in `YYYY-MM-DD` format.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ahrefs`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Site Explorer Metrics
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Ahrefs operations", known_fields: ""}]
session: {generate_id: true}
```
Retrieve comprehensive SEO metrics for a domain including backlink counts, referring domains, organic keyword rankings, and traffic estimates.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS`
## Core Workflow Pattern
Key parameters:
- `target` (required) -- domain or URL to analyze
- `date` (required) -- metrics date in `YYYY-MM-DD` format
- `country` -- ISO country code (e.g., `us`, `gb`, `de`)
- `mode` -- scope: `exact`, `prefix`, `domain`, or `subdomains` (default)
- `protocol` -- `both`, `http`, or `https`
- `volume_mode` -- `monthly` or `average`
### Step 1: Discover Available Tools
Example prompt: *"Get Ahrefs site metrics for example.com as of today in the US"*
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Ahrefs task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Historical Metrics Tracking
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["ahrefs"]
session_id: "your_session_id"
```
Track how a domain's SEO metrics have changed over time for trend analysis and competitive benchmarking.
### Step 3: Execute Tools
**Tools:** `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS_HISTORY`, `AHREFS_DOMAIN_RATING_HISTORY`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
For full metrics history:
- `target` (required) -- domain to track
- `date_from` (required) -- start date in `YYYY-MM-DD`
- `date_to` -- end date
- `history_grouping` -- `daily`, `weekly`, or `monthly` (default)
- `select` -- columns like `date,org_cost,org_traffic,paid_cost,paid_traffic`
For Domain Rating (DR) history:
- `target` (required), `date_from` (required), `date_to`, `history_grouping`
Example prompt: *"Show me the monthly Domain Rating history for example.com over the last year"*
---
### 3. Backlink Analysis
Retrieve a comprehensive list of backlinks including source URLs, anchor text, link attributes, and referring domain metrics.
**Tool:** `AHREFS_FETCH_ALL_BACKLINKS`
Key parameters:
- `target` (required) -- domain or URL
- `select` (required) -- comma-separated columns (e.g., `url_from,url_to,anchor,domain_rating_source,first_seen_link`)
- `limit` (default 1000) -- number of results
- `aggregation` -- `similar_links` (default), `1_per_domain`, or `all`
- `mode` -- `exact`, `prefix`, `domain`, or `subdomains`
- `history` -- `live`, `since:YYYY-MM-DD`, or `all_time`
- `where` -- rich filter expressions on columns like `is_dofollow`, `domain_rating_source`, `anchor`
Example prompt: *"Get the top 100 dofollow backlinks to example.com with anchor text and referring DR"*
---
### 4. Keyword Research
Get keyword overview metrics and discover matching keyword variations for content strategy.
**Tools:** `AHREFS_EXPLORE_KEYWORDS_OVERVIEW`, `AHREFS_EXPLORE_MATCHING_TERMS_FOR_KEYWORDS`
For keyword overview:
- `select` (required) -- columns to return (volume, difficulty, CPC, etc.)
- `country` (required) -- ISO country code
- `keywords` -- comma-separated keyword list
- `where` -- filter by volume, difficulty, intent, etc.
For matching terms:
- `select` (required) and `country` (required)
- `keywords` -- comma-separated seed keywords
- `match_mode` -- `terms` (any order) or `phrase` (exact order)
- `terms` -- `all` or `questions` (question-format keywords only)
Example prompt: *"Find keyword variations for 'project management' in the US with volume and difficulty"*
---
### 5. Organic Keywords Audit
See which keywords a domain ranks for in organic search, with position tracking and historical comparison.
**Tool:** `AHREFS_RETRIEVE_ORGANIC_KEYWORDS`
Key parameters:
- `target` (required) -- domain or URL
- `country` (required) -- ISO country code
- `date` (required) -- date in `YYYY-MM-DD`
- `select` -- columns to return (keyword, position, volume, traffic, URL, etc.)
- `date_compared` -- compare against a previous date
- `where` -- rich filter expressions on `keyword`, `volume`, `best_position`, intent flags, etc.
- `limit` (default 1000), `order_by`
Example prompt: *"Show all organic keywords where example.com ranks in the top 10 in the US"*
---
### 6. Batch URL Analysis
Analyze up to 100 URLs or domains simultaneously to compare SEO metrics across competitors or site sections.
**Tool:** `AHREFS_BATCH_URL_ANALYSIS`
Key parameters:
- `targets` (required) -- array of objects with `url`, `mode` (`exact`/`prefix`/`domain`/`subdomains`), and `protocol` (`both`/`http`/`https`)
- `select` (required) -- array of column identifiers
- `country` -- ISO country code
- `output` -- `json` or `php`
Example prompt: *"Compare SEO metrics for competitor1.com, competitor2.com, and competitor3.com"*
---
## 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
- **Column selection is required:** Most Ahrefs tools require a `select` parameter specifying which columns to return. Omitting it or using invalid column names will cause errors. Refer to each tool's response schema for valid identifiers.
- **Date format consistency:** Dates must be in `YYYY-MM-DD` format. Some historical endpoints return data at the granularity set by `history_grouping`, not by exact date.
- **API unit costs vary:** Different columns consume different unit amounts. Columns marked with "(5 units)" or "(10 units)" in the schema are more expensive. Monitor API usage when requesting expensive columns like `traffic`, `refdomains_source`, or `difficulty`.
- **Batch limit is 100 targets:** `AHREFS_BATCH_URL_ANALYSIS` accepts up to 100 targets per request. For larger analyses, split into multiple batches.
- **Filter expressions are complex:** The `where` parameter uses Ahrefs' filter expression syntax, not standard SQL. Consult the column descriptions in each tool's schema for supported filter types and value formats.
- **Deprecated offset parameter:** The `offset` parameter was deprecated on May 31, 2024. Use cursor-based pagination or adjust `limit` instead.
- **Mode affects scope significantly:** Setting `mode` to `subdomains` (the default) includes all subdomains, which can dramatically increase result counts compared to `domain` or `exact`.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Ahrefs-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ahrefs` |
| 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` |
| Tool Slug | Description |
|---|---|
| `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS` | Current SEO metrics for a domain/URL |
| `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS_HISTORY` | Historical SEO metrics over time |
| `AHREFS_DOMAIN_RATING_HISTORY` | Domain Rating (DR) history |
| `AHREFS_FETCH_ALL_BACKLINKS` | Comprehensive backlink list with filtering |
| `AHREFS_FETCH_SITE_EXPLORER_REFERRING_DOMAINS` | List of referring domains |
| `AHREFS_GET_SITE_EXPLORER_COUNTRY_METRICS` | Country-level traffic breakdown |
| `AHREFS_BATCH_URL_ANALYSIS` | Batch analysis of up to 100 URLs |
| `AHREFS_EXPLORE_KEYWORDS_OVERVIEW` | Keyword metrics overview |
| `AHREFS_EXPLORE_MATCHING_TERMS_FOR_KEYWORDS` | Matching keyword variations |
| `AHREFS_EXPLORE_KEYWORD_VOLUME_BY_COUNTRY` | Keyword volume across countries |
| `AHREFS_RETRIEVE_ORGANIC_KEYWORDS` | Organic keyword rankings for a domain |
| `AHREFS_RETRIEVE_SITE_EXPLORER_KEYWORDS_HISTORY` | Historical keyword ranking data |
| `AHREFS_RETRIEVE_TOP_PAGES_FROM_SITE_EXPLORER` | Top performing pages by SEO metrics |
| `AHREFS_GET_SERP_OVERVIEW` | SERP overview for specific keywords |
---
*Powered by [Composio](https://composio.dev)*

196
apify-automation/SKILL.md
View File

@@ -1,91 +1,167 @@
---
name: apify-automation
description: "Automate Apify tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Apify Automation
description: "Automate web scraping and data extraction with Apify -- run Actors, manage datasets, create reusable tasks, and retrieve crawl results through the Composio Apify integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Apify Automation via Rube MCP
# Apify Automation
Automate Apify operations through Composio's Apify toolkit via Rube MCP.
Run **Apify** web scraping Actors and manage datasets directly from Claude Code. Execute crawlers synchronously or asynchronously, retrieve structured data, create reusable tasks, and inspect run logs without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/apify](https://composio.dev/toolkits/apify)
**Toolkit docs:** [composio.dev/toolkits/apify](https://composio.dev/toolkits/apify)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Apify connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apify`
- 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. Add the Composio MCP server to your configuration:
```
https://rube.app/mcp
```
2. Connect your Apify account when prompted. The agent will provide an authentication link.
3. Browse available Actors at [apify.com/store](https://apify.com/store). Each Actor has its own unique input schema -- always check the Actor's documentation before running.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apify`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Run an Actor Synchronously and Get Results
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Apify operations", known_fields: ""}]
session: {generate_id: true}
```
Execute an Actor and immediately retrieve its dataset items in a single call. Best for quick scraping jobs.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `APIFY_RUN_ACTOR_SYNC_GET_DATASET_ITEMS`
## Core Workflow Pattern
Key parameters:
- `actorId` (required) -- Actor ID in format `username/actor-name` (e.g., `compass/crawler-google-places`)
- `input` -- JSON input object matching the Actor's schema. Each Actor has unique field names -- check [apify.com/store](https://apify.com/store) for the exact schema.
- `limit` -- max items to return
- `offset` -- skip items for pagination
- `format` -- `json` (default), `csv`, `jsonl`, `html`, `xlsx`, `xml`
- `timeout` -- run timeout in seconds
- `waitForFinish` -- max wait time (0-300 seconds)
- `fields` -- comma-separated list of fields to include
- `omit` -- comma-separated list of fields to exclude
### Step 1: Discover Available Tools
Example prompt: *"Run the Google Places scraper for 'restaurants in New York' and return the first 50 results"*
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Apify task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Run an Actor Asynchronously
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["apify"]
session_id: "your_session_id"
```
Trigger an Actor run without waiting for completion. Use for long-running scraping jobs.
### Step 3: Execute Tools
**Tool:** `APIFY_RUN_ACTOR`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
Key parameters:
- `actorId` (required) -- Actor slug or ID
- `body` -- JSON input object for the Actor
- `memory` -- memory limit in MB (must be power of 2, minimum 128)
- `timeout` -- run timeout in seconds
- `maxItems` -- cap on returned items
- `build` -- specific build tag (e.g., `latest`, `beta`)
Follow up with `APIFY_GET_DATASET_ITEMS` to retrieve results using the run's `datasetId`.
Example prompt: *"Start the web scraper Actor for example.com asynchronously with 1024MB memory"*
---
### 3. Retrieve Dataset Items
Fetch data from a specific dataset with pagination, field selection, and filtering.
**Tool:** `APIFY_GET_DATASET_ITEMS`
Key parameters:
- `datasetId` (required) -- dataset identifier
- `limit` (default/max 1000) -- items per page
- `offset` (default 0) -- pagination offset
- `format` -- `json` (recommended), `csv`, `xlsx`
- `fields` -- include only specific fields
- `omit` -- exclude specific fields
- `clean` -- remove Apify-specific metadata
- `desc` -- reverse order (newest first)
Example prompt: *"Get the first 500 items from dataset myDatasetId in JSON format"*
---
### 4. Inspect Actor Details
View Actor metadata, input schema, and configuration before running it.
**Tool:** `APIFY_GET_ACTOR`
Key parameters:
- `actorId` (required) -- Actor ID in format `username/actor-name` or hex ID
Example prompt: *"Show me the details and input schema for the apify/web-scraper Actor"*
---
### 5. Create Reusable Tasks
Configure reusable Actor tasks with preset inputs for recurring scraping jobs.
**Tool:** `APIFY_CREATE_TASK`
Configure a task once, then trigger it repeatedly with consistent input parameters. Useful for scheduled or recurring data collection workflows.
Example prompt: *"Create an Apify task for the Google Search scraper with default query 'AI startups' and US location"*
---
### 6. Manage Runs and Datasets
List Actor runs, browse datasets, and inspect run details for monitoring and debugging.
**Tools:** `APIFY_GET_LIST_OF_RUNS`, `APIFY_DATASETS_GET`, `APIFY_DATASET_GET`, `APIFY_GET_LOG`
For listing runs:
- Filter by Actor and optionally by status
- Get `datasetId` from run details for data retrieval
For dataset management:
- `APIFY_DATASETS_GET` -- list all your datasets with pagination
- `APIFY_DATASET_GET` -- get metadata for a specific dataset
For debugging:
- `APIFY_GET_LOG` -- retrieve execution logs for a run or build
Example prompt: *"List the last 10 runs for the web scraper Actor and show logs for the most recent one"*
---
## 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
- **Actor input schemas vary wildly:** Every Actor has its own unique input fields. Generic field names like `queries` or `search_terms` will be rejected. Always check the Actor's page on [apify.com/store](https://apify.com/store) for exact field names (e.g., `searchStringsArray` for Google Maps, `startUrls` for web scrapers).
- **URL format requirements:** Always include the full protocol (`https://` or `http://`) in URLs. Many Actors require URLs as objects with a `url` property: `{"startUrls": [{"url": "https://example.com"}]}`.
- **Dataset pagination cap:** `APIFY_GET_DATASET_ITEMS` has a max `limit` of 1000 per call. For large datasets, loop with `offset` to collect all items.
- **Enum values are lowercase:** Most Actors expect lowercase enum values (e.g., `relevance` not `RELEVANCE`, `all` not `ALL`).
- **Sync timeout at 5 minutes:** `APIFY_RUN_ACTOR_SYNC_GET_DATASET_ITEMS` has a maximum `waitForFinish` of 300 seconds. For longer runs, use `APIFY_RUN_ACTOR` (async) and poll with `APIFY_GET_DATASET_ITEMS`.
- **Data volume costs:** Large datasets can be expensive to fetch. Prefer moderate limits and incremental processing to avoid timeouts or memory pressure.
- **JSON format recommended:** While CSV/XLSX formats are available, JSON is the most reliable for automated processing. Avoid CSV/XLSX for downstream automation.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Apify-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apify` |
| 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` |
| Tool Slug | Description |
|---|---|
| `APIFY_RUN_ACTOR_SYNC_GET_DATASET_ITEMS` | Run Actor synchronously and get results immediately |
| `APIFY_RUN_ACTOR` | Run Actor asynchronously (trigger and return) |
| `APIFY_RUN_ACTOR_SYNC` | Run Actor synchronously, return output record |
| `APIFY_GET_ACTOR` | Get Actor metadata and input schema |
| `APIFY_GET_DATASET_ITEMS` | Retrieve items from a dataset (paginated) |
| `APIFY_DATASET_GET` | Get dataset metadata (item count, etc.) |
| `APIFY_DATASETS_GET` | List all user datasets |
| `APIFY_CREATE_TASK` | Create a reusable Actor task |
| `APIFY_GET_TASK_INPUT` | Inspect a task's stored input |
| `APIFY_GET_LIST_OF_RUNS` | List runs for an Actor |
| `APIFY_GET_LOG` | Get execution logs for a run |
---
*Powered by [Composio](https://composio.dev)*

194
apollo-automation/SKILL.md
View File

@@ -1,91 +1,165 @@
---
name: apollo-automation
description: "Automate Apollo tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Apollo Automation
description: "Automate Apollo.io lead generation -- search organizations, discover contacts, enrich prospect data, manage contact stages, and build targeted outreach lists -- using natural language through the Composio MCP integration."
category: sales-intelligence
requires:
mcp: [rube]
mcp:
- rube
---
# Apollo Automation via Rube MCP
# Apollo Automation
Automate Apollo operations through Composio's Apollo toolkit via Rube MCP.
Supercharge your sales prospecting with Apollo.io -- search companies, discover decision-makers, enrich contact data with emails and phone numbers, and manage your sales pipeline stages -- all through natural language commands.
**Toolkit docs**: [composio.dev/toolkits/apollo](https://composio.dev/toolkits/apollo)
**Toolkit docs:** [composio.dev/toolkits/apollo](https://composio.dev/toolkits/apollo)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Apollo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apollo`
- 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. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Connect your Apollo.io account when prompted (API key authentication).
3. Start issuing natural language commands to prospect and enrich leads.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apollo`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Search Organizations
Find target companies using filters like name, location, employee count, and industry keywords.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Apollo operations", known_fields: ""}]
session: {generate_id: true}
```
**Tool:** `APOLLO_ORGANIZATION_SEARCH`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Example prompt:**
> "Find SaaS companies in Texas with 50-500 employees on Apollo"
## Core Workflow Pattern
**Key parameters:**
- `q_organization_name` -- Partial name match (e.g., "Apollo" matches "Apollo Inc.")
- `organization_locations` -- HQ locations to include (e.g., "texas", "tokyo")
- `organization_not_locations` -- HQ locations to exclude
- `organization_num_employees_ranges` -- Employee ranges in "min,max" format (e.g., "50,500")
- `q_organization_keyword_tags` -- Industry keywords (e.g., "software", "healthcare")
- `page` / `per_page` -- Pagination (max 100 per page, max 500 pages)
### Step 1: Discover Available Tools
---
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Apollo task"}]
session: {id: "existing_session_id"}
```
### 2. Discover People at Companies
Search Apollo's contact database for people matching title, seniority, location, and company criteria.
### Step 2: Check Connection
**Tool:** `APOLLO_PEOPLE_SEARCH`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["apollo"]
session_id: "your_session_id"
```
**Example prompt:**
> "Find VPs of Sales at microsoft.com and apollo.io"
### Step 3: Execute Tools
**Key parameters:**
- `person_titles` -- Job titles (e.g., "VP of Sales", "CTO")
- `person_seniorities` -- Seniority levels (e.g., "director", "vp", "senior")
- `person_locations` -- Geographic locations of people
- `q_organization_domains` -- Company domains (e.g., "apollo.io" -- exclude "www.")
- `organization_ids` -- Apollo company IDs from Organization Search
- `contact_email_status` -- Filter by email status: "verified", "unverified", "likely to engage"
- `page` / `per_page` -- Pagination (max 100 per page)
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
---
### 3. Enrich Individual Contacts
Get comprehensive data (email, phone, LinkedIn, company info) for a single person using their email, LinkedIn URL, or name + company.
**Tool:** `APOLLO_PEOPLE_ENRICHMENT`
**Example prompt:**
> "Enrich Tim Zheng at Apollo.io on Apollo"
**Key parameters (at least one identifier required):**
- `email` -- Person's email address
- `linkedin_url` -- Full LinkedIn profile URL
- `first_name` + `last_name` + (`organization_name` or `domain`) -- Name-based matching
- `domain` -- Bare hostname without protocol (e.g., "apollo.io", not "https://apollo.io")
- `reveal_personal_emails` -- Set true to get personal emails (may use extra credits)
- `reveal_phone_number` -- Set true for phone numbers (requires `webhook_url`)
---
### 4. Bulk Enrich Prospects
Enrich up to 10 people simultaneously for efficient batch processing.
**Tool:** `APOLLO_BULK_PEOPLE_ENRICHMENT`
**Example prompt:**
> "Bulk enrich these 5 leads with their Apollo data: [list of names/emails]"
**Key parameters:**
- `details` (required) -- Array of 1-10 person objects, each with identifiers like `email`, `linkedin_url`, `first_name`, `last_name`, `domain`, `company_name`
- `reveal_personal_emails` -- Include personal emails (extra credits)
- `reveal_phone_number` -- Include phone numbers (requires `webhook_url`)
---
### 5. Manage Contact Pipeline Stages
List available stages and update contacts through your sales funnel.
**Tools:** `APOLLO_LIST_CONTACT_STAGES`, `APOLLO_UPDATE_CONTACT_STAGE`
**Example prompt:**
> "Move contacts X and Y to the 'Qualified' stage in Apollo"
**Key parameters for listing stages:** None required.
**Key parameters for updating stage:**
- `contact_ids` (required) -- Array of contact IDs to update
- `contact_stage_id` (required) -- Target stage ID (from List Contact Stages)
---
### 6. Create and Search Saved Contacts
Create new contact records and search your existing Apollo contact database.
**Tools:** `APOLLO_CREATE_CONTACT`, `APOLLO_SEARCH_CONTACTS`
**Example prompt:**
> "Search my Apollo contacts for anyone at Stripe"
**Key parameters for search:**
- Keyword search, stage ID filtering, sorting options
- `page` / `per_page` -- Pagination
**Key parameters for create:**
- `first_name`, `last_name`, `email`, `organization_name`
- `account_id` -- Link to an organization
- `contact_stage_id` -- Initial sales stage
---
## 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
- **Organization domains can be empty**: Some organizations from `APOLLO_ORGANIZATION_SEARCH` return missing or empty domain fields. Use `APOLLO_ORGANIZATION_ENRICHMENT` to validate domains before relying on them.
- **HTTP 403 means config issues**: A 403 response indicates API key or plan access problems -- do not retry. Fix your credentials or plan first.
- **People search returns obfuscated data**: `APOLLO_PEOPLE_SEARCH` may show `has_email`/`has_direct_phone` flags or obfuscated fields instead of full contact details. Use `APOLLO_PEOPLE_ENRICHMENT` to get complete information.
- **Pagination limits are strict**: People search supports `per_page` up to 100 and max 500 pages. Stopping early can miss large portions of the result set.
- **Bulk enrichment has small batch limits**: `APOLLO_BULK_PEOPLE_ENRICHMENT` accepts only 10 items per call. It can return `status='success'` with `missing_records > 0` when identifiers are insufficient -- retry individual records with `APOLLO_PEOPLE_ENRICHMENT`.
- **No automatic deduplication**: `APOLLO_CREATE_CONTACT` does not deduplicate. Check for existing contacts first with `APOLLO_SEARCH_CONTACTS`.
- **Domain format matters**: Always use bare hostnames (e.g., "apollo.io") without protocol prefixes ("https://") or "www." prefix.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Apollo-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apollo` |
| 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` |
| Action | Tool Slug | Required Params |
|---|---|---|
| Search organizations | `APOLLO_ORGANIZATION_SEARCH` | None (optional filters) |
| Enrich organization | `APOLLO_ORGANIZATION_ENRICHMENT` | `domain` |
| Bulk enrich orgs | `APOLLO_BULK_ORGANIZATION_ENRICHMENT` | `domains` |
| Search people | `APOLLO_PEOPLE_SEARCH` | None (optional filters) |
| Enrich person | `APOLLO_PEOPLE_ENRICHMENT` | One of: `email`, `linkedin_url`, or name+company |
| Bulk enrich people | `APOLLO_BULK_PEOPLE_ENRICHMENT` | `details` (1-10 person objects) |
| List contact stages | `APOLLO_LIST_CONTACT_STAGES` | None |
| Update contact stage | `APOLLO_UPDATE_CONTACT_STAGE` | `contact_ids`, `contact_stage_id` |
| Create contact | `APOLLO_CREATE_CONTACT` | Name + identifiers |
| Search contacts | `APOLLO_SEARCH_CONTACTS` | None (optional filters) |
---
*Powered by [Composio](https://composio.dev)*

180
ashby-automation/SKILL.md
View File

@@ -1,91 +1,167 @@
---
name: ashby-automation
description: "Automate Ashby tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Ashby Automation
description: "Automate recruiting and hiring workflows in Ashby -- manage candidates, jobs, applications, interviews, and notes through natural language commands."
requires:
mcp: [rube]
mcp:
- rube
---
# Ashby Automation via Rube MCP
# Ashby Automation
Automate Ashby operations through Composio's Ashby toolkit via Rube MCP.
Automate your Ashby ATS recruiting operations directly from Claude Code. Create candidates, post jobs, manage applications, view interview schedules, and search your talent pipeline -- all without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/ashby](https://composio.dev/toolkits/ashby)
**Toolkit docs:** [composio.dev/toolkits/ashby](https://composio.dev/toolkits/ashby)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Ashby connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ashby`
- 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. Add the Rube MCP server to your Claude Code config with URL: `https://rube.app/mcp`
2. When prompted, authenticate your Ashby account through the connection link provided
3. Start automating your recruiting workflows with natural language
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ashby`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Manage Candidates
Create, list, search, update, and retrieve detailed candidate information.
**Tools:** `ASHBY_CREATE_CANDIDATE`, `ASHBY_LIST_CANDIDATES`, `ASHBY_SEARCH_CANDIDATES`, `ASHBY_GET_CANDIDATE_INFO`, `ASHBY_UPDATE_CANDIDATE`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Ashby operations", known_fields: ""}]
session: {generate_id: true}
Create a candidate named "Jane Smith" with email jane@example.com and LinkedIn profile https://linkedin.com/in/janesmith
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Key parameters for `ASHBY_CREATE_CANDIDATE`:
- `name` (required) -- full name of the candidate
- `email` -- primary email address
- `phoneNumber`, `linkedInUrl`, `githubUrl`, `websiteUrl` -- contact/social profiles
## Core Workflow Pattern
Key parameters for `ASHBY_SEARCH_CANDIDATES`:
- `email` -- exact email match
- `name` -- partial name match
### Step 1: Discover Available Tools
Key parameters for `ASHBY_LIST_CANDIDATES`:
- `perPage` (max 100) / `cursor` -- pagination
- `syncToken` -- for incremental updates since last sync
### 2. Create and List Jobs
Post new job openings and browse existing positions.
**Tools:** `ASHBY_CREATE_JOB`, `ASHBY_LIST_JOBS`, `ASHBY_GET_JOB_INFO`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Ashby task"}]
session: {id: "existing_session_id"}
Create a new "Senior Software Engineer" job in team dept-123 at location loc-456 with brand brand-789
```
### Step 2: Check Connection
Key parameters for `ASHBY_CREATE_JOB`:
- `title` (required) -- job title
- `teamId` (required) -- department/team ID (from list departments)
- `locationId` (required) -- office location ID (from list locations)
- `brandId` (required) -- employer brand ID (from list brands)
- `defaultInterviewPlanId` -- required to open the job for applications
- `jobTemplateId` -- pre-populate from a template
Key parameters for `ASHBY_LIST_JOBS`:
- `perPage` (max 100) / `cursor` / `syncToken` -- pagination and incremental sync
**Note:** Newly created jobs start in "Draft" status. You must set a `defaultInterviewPlanId` to open/publish the job.
### 3. Manage Applications
Create applications to connect candidates to jobs and track their progress.
**Tools:** `ASHBY_CREATE_APPLICATION`, `ASHBY_LIST_APPLICATIONS`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["ashby"]
session_id: "your_session_id"
Apply candidate cand-abc123 to job job-xyz789 with source src-referral
```
### Step 3: Execute Tools
Key parameters for `ASHBY_CREATE_APPLICATION`:
- `candidateId` (required) -- UUID of an existing candidate
- `jobId` (required) -- UUID of an existing job
- `sourceId` -- UUID of the application source (LinkedIn, Referral, etc.)
- `creditedToUserId` -- UUID of recruiter/referrer to credit
- `interviewStageId` -- place directly into a specific stage (defaults to first stage)
Key parameters for `ASHBY_LIST_APPLICATIONS`:
- `perPage` (max 100) / `cursor` / `syncToken` -- pagination and incremental sync
### 4. View Interview Schedules
List scheduled interviews with timing, interviewer, and candidate details.
**Tool:** `ASHBY_LIST_INTERVIEW_SCHEDULES`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Show me all upcoming interview schedules
```
Key parameters:
- `perPage` (max 100) / `cursor` -- pagination
- `syncToken` -- incremental sync for changed schedules
### 5. Candidate Notes
View internal notes, observations, and recruiter comments on candidates.
**Tool:** `ASHBY_LIST_CANDIDATE_NOTES`
```
Show me all notes for candidate cand-abc123
```
- Retrieves all notes added by recruiters and hiring team members
- Useful for reviewing interview feedback and internal assessments
### 6. Pipeline Reporting
Combine listing tools to build hiring pipeline reports.
**Tools:** `ASHBY_LIST_CANDIDATES`, `ASHBY_LIST_APPLICATIONS`, `ASHBY_LIST_JOBS`
```
List all applications to see the current state of our hiring pipeline
```
- Use `syncToken` for incremental data fetches (efficient for recurring reports)
- Combine candidate, application, and job data for full pipeline visibility
- Paginate through all results with `cursor` for complete datasets
---
## 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
- **Jobs start in Draft:** Newly created jobs via `ASHBY_CREATE_JOB` start in "Draft" status and cannot accept applications until a `defaultInterviewPlanId` is set and the job is opened.
- **Four required fields for jobs:** `ASHBY_CREATE_JOB` requires `title`, `teamId`, `locationId`, and `brandId`. Use list departments, locations, and brands endpoints to discover valid IDs.
- **Candidate before application:** A candidate must exist before creating an application. Always create or find the candidate first, then create the application.
- **Cursor-based pagination:** All list endpoints use cursor-based pagination with `perPage` (max 100) and `cursor`. You cannot jump to arbitrary pages -- you must iterate sequentially.
- **`syncToken` for efficiency:** Use `syncToken` from previous responses to fetch only changed records. This dramatically reduces API calls for recurring workflows.
- **UUID format everywhere:** All IDs (candidates, jobs, applications, stages) are UUIDs. Passing malformed IDs returns 400 errors.
- **Search limitations:** `ASHBY_SEARCH_CANDIDATES` supports exact email match or partial name match, but not combined queries or other fields. For broader searches, use `ASHBY_LIST_CANDIDATES` with pagination.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Ashby-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ashby` |
| 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` |
| Tool Slug | Description |
|---|---|
| `ASHBY_CREATE_CANDIDATE` | Create a new candidate (requires `name`) |
| `ASHBY_LIST_CANDIDATES` | List all candidates with pagination and sync |
| `ASHBY_SEARCH_CANDIDATES` | Search candidates by email or name |
| `ASHBY_GET_CANDIDATE_INFO` | Get full candidate details (requires `candidateId`) |
| `ASHBY_UPDATE_CANDIDATE` | Update candidate profile information |
| `ASHBY_LIST_CANDIDATE_NOTES` | List internal notes for a candidate |
| `ASHBY_CREATE_JOB` | Create a job opening (requires `title`, `teamId`, `locationId`, `brandId`) |
| `ASHBY_LIST_JOBS` | List all jobs with pagination and sync |
| `ASHBY_GET_JOB_INFO` | Get full job details by ID |
| `ASHBY_CREATE_APPLICATION` | Apply a candidate to a job (requires `candidateId`, `jobId`) |
| `ASHBY_LIST_APPLICATIONS` | List all applications with pagination and sync |
| `ASHBY_LIST_INTERVIEW_SCHEDULES` | List scheduled interviews with pagination |
---
*Powered by [Composio](https://composio.dev)*

187
attio-automation/SKILL.md
View File

@@ -1,91 +1,160 @@
---
name: attio-automation
description: "Automate Attio tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Attio Automation
description: "Automate Attio CRM operations -- search records, query contacts and companies with advanced filters, manage notes, list attributes, and navigate your relationship data -- using natural language through the Composio MCP integration."
category: crm
requires:
mcp: [rube]
mcp:
- rube
---
# Attio Automation via Rube MCP
# Attio Automation
Automate Attio operations through Composio's Attio toolkit via Rube MCP.
Manage your Attio CRM workspace -- fuzzy search across people and companies, run complex filtered queries, browse notes, discover object schemas, and list records -- all through natural language commands.
**Toolkit docs**: [composio.dev/toolkits/attio](https://composio.dev/toolkits/attio)
**Toolkit docs:** [composio.dev/toolkits/attio](https://composio.dev/toolkits/attio)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Attio connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `attio`
- 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. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Connect your Attio account when prompted (OAuth authentication).
3. Start issuing natural language commands to manage your CRM data.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `attio`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Fuzzy Search Across Records
Search for people, companies, deals, or any object by name, domain, email, phone, or social handle.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Attio operations", known_fields: ""}]
session: {generate_id: true}
**Tool:** `ATTIO_SEARCH_RECORDS`
**Example prompt:**
> "Search Attio for anyone named Alan Mathis"
**Key parameters (all required):**
- `query` -- Search string (max 256 characters). Empty string returns default results.
- `objects` -- Array of object slugs to search (e.g., `["people"]`, `["people", "companies"]`, `["deals"]`)
- `request_as` -- Context: use `{"type": "workspace"}` for full workspace search, or specify a workspace member
---
### 2. Advanced Filtered Queries
Query records with server-side filtering, sorting, and complex conditions -- far more powerful than fuzzy search.
**Tool:** `ATTIO_QUERY_RECORDS`
**Example prompt:**
> "Find all companies in Attio created after January 2025 sorted by name"
**Key parameters:**
- `object` (required) -- Object slug or UUID (e.g., "people", "companies", "deals")
- `filter` -- Attio filter object with operators like `$eq`, `$contains`, `$gte`, `$and`, `$or`
- `sorts` -- Array of sort specifications with `direction` ("asc"/"desc") and `attribute`
- `limit` -- Max records to return (up to 500)
- `offset` -- Pagination offset
**Filter examples:**
```json
{"name": {"first_name": {"$contains": "John"}}}
{"email_addresses": {"$contains": "@example.com"}}
{"created_at": {"$gte": "2025-01-01T00:00:00.000Z"}}
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
---
## Core Workflow Pattern
### 3. Find Records by ID or Attributes
Look up a specific record by its unique ID or search by unique attribute values.
### Step 1: Discover Available Tools
**Tool:** `ATTIO_FIND_RECORD`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Attio task"}]
session: {id: "existing_session_id"}
```
**Example prompt:**
> "Find the Attio company with domain example.com"
### Step 2: Check Connection
**Key parameters:**
- `object_id` (required) -- Object type slug: "people", "companies", "deals", "users", "workspaces"
- `record_id` -- Direct lookup by UUID (optional)
- `attributes` -- Dictionary of attribute filters (e.g., `{"email_addresses": "john@example.com"}`)
- `limit` -- Max records (up to 1000)
- `offset` -- Pagination offset
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["attio"]
session_id: "your_session_id"
```
---
### Step 3: Execute Tools
### 4. Browse and Filter Notes
List notes across the workspace or filter by specific parent objects and records.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Tool:** `ATTIO_LIST_NOTES`
**Example prompt:**
> "Show the last 10 notes on the Acme Corp company record in Attio"
**Key parameters:**
- `parent_object` -- Object slug (e.g., "people", "companies", "deals") -- requires `parent_record_id`
- `parent_record_id` -- UUID of the parent record -- requires `parent_object`
- `limit` -- Max notes to return (1-50, default 10)
- `offset` -- Number of results to skip
---
### 5. Discover Object Schemas and Attributes
Understand your workspace structure by listing objects and their attribute definitions.
**Tools:** `ATTIO_GET_OBJECT`, `ATTIO_LIST_ATTRIBUTES`
**Example prompt:**
> "What attributes does the companies object have in Attio?"
**Key parameters for Get Object:**
- `object_id` -- Object slug or UUID
**Key parameters for List Attributes:**
- `target` -- "objects" or "lists"
- `identifier` -- Object or list ID/slug
---
### 6. List All Records
Retrieve records from a specific object type with simple pagination, returned in creation order.
**Tool:** `ATTIO_LIST_RECORDS`
**Example prompt:**
> "List the first 100 people records in Attio"
**Key parameters:**
- Object type identifier
- Pagination parameters
---
## 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
- **Timestamp format is critical**: ALL timestamp comparisons (`created_at`, `updated_at`, custom timestamps) MUST use ISO8601 string format (e.g., `2025-01-01T00:00:00.000Z`). Unix timestamps or numeric values cause "Invalid timestamp value" errors.
- **Name attributes must be nested**: The `name` attribute has sub-properties (`first_name`, `last_name`, `full_name`) that MUST be nested under `name`. Correct: `{"name": {"first_name": {"$contains": "John"}}}`. Wrong: `{"first_name": {...}}` -- this fails with "unknown_filter_attribute_slug".
- **Email operators are limited**: `email_addresses` supports `$eq`, `$contains`, `$starts_with`, `$ends_with` but NOT `$not_empty`.
- **Record-reference attributes need path filtering**: For attributes that reference other records (e.g., "team", "company"), use path-based filtering, not nested syntax. Example: `{"path": [["companies", "team"], ["people", "name"]], "constraints": {"first_name": {"$eq": "John"}}}`.
- **"lists" is not an object type**: Do not use "lists" as an `object_id`. Use list-specific actions for list operations.
- **Search is eventually consistent**: `ATTIO_SEARCH_RECORDS` returns eventually consistent results. For guaranteed up-to-date results, use `ATTIO_QUERY_RECORDS` instead.
- **Attribute slugs vary by workspace**: System attributes (e.g., "email_addresses", "name") are consistent, but custom attributes vary. Use `ATTIO_LIST_ATTRIBUTES` to discover valid slugs for your workspace.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Attio-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `attio` |
| 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` |
| Action | Tool Slug | Required Params |
|---|---|---|
| Fuzzy search records | `ATTIO_SEARCH_RECORDS` | `query`, `objects`, `request_as` |
| Query with filters | `ATTIO_QUERY_RECORDS` | `object` |
| Find record by ID/attributes | `ATTIO_FIND_RECORD` | `object_id` |
| List notes | `ATTIO_LIST_NOTES` | None (optional filters) |
| Get object schema | `ATTIO_GET_OBJECT` | `object_id` |
| List attributes | `ATTIO_LIST_ATTRIBUTES` | `target`, `identifier` |
| List records | `ATTIO_LIST_RECORDS` | Object type |
---
*Powered by [Composio](https://composio.dev)*

197
braintree-automation/SKILL.md
View File

@@ -1,91 +1,186 @@
---
name: braintree-automation
description: "Automate Braintree tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Braintree Automation
description: "Braintree Automation: manage payment processing via Stripe-compatible tools for customers, subscriptions, payment methods, and transactions"
requires:
mcp: [rube]
---
# Braintree Automation via Rube MCP
# Braintree Automation
Automate Braintree operations through Composio's Braintree toolkit via Rube MCP.
Automate payment processing operations via Stripe-compatible tooling including managing customers, subscriptions, payment methods, balance transactions, and customer searches. The Composio platform routes Braintree payment workflows through the Stripe toolkit for unified payment management.
**Toolkit docs**: [composio.dev/toolkits/braintree](https://composio.dev/toolkits/braintree)
**Toolkit docs:** [composio.dev/toolkits/braintree](https://composio.dev/toolkits/braintree)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Braintree connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `braintree`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `braintree`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure an active connection exists for the `stripe` toolkit. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
---
Always discover available tools before executing workflows:
## Core Workflows
### 1. Create and Manage Customers
Create new customers and retrieve existing customer details.
**Tools:**
- `STRIPE_CREATE_CUSTOMER` -- Create a new customer
- `STRIPE_GET_CUSTOMERS_CUSTOMER` -- Retrieve a customer by ID
- `STRIPE_POST_CUSTOMERS_CUSTOMER` -- Update an existing customer
- `STRIPE_LIST_CUSTOMERS` -- List customers with pagination
- `STRIPE_GET_V1_CUSTOMERS_SEARCH_CUSTOMERS` -- Search customers by email, name, metadata
**Key Parameters for `STRIPE_CREATE_CUSTOMER`:**
- `email` -- Customer's primary email address
- `name` -- Full name or business name
- `phone` -- Phone number with country code
- `description` -- Internal reference notes
- `address` -- Billing address object with `line1`, `city`, `state`, `postal_code`, `country`
**Key Parameters for `STRIPE_GET_V1_CUSTOMERS_SEARCH_CUSTOMERS`:**
- `query` (required) -- Stripe Search Query Language. Must use `field:value` syntax:
- `email:'user@example.com'` -- Exact match (case insensitive)
- `name~'John'` -- Substring match (min 3 chars)
- `metadata['key']:'value'` -- Metadata search
- `created>1609459200` -- Timestamp comparison
- Combine with `AND` or `OR` (max 10 clauses, cannot mix)
- `limit` -- Results per page (1--100, default 10)
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Braintree operations", known_fields: ""}]
session: {generate_id: true}
Tool: STRIPE_CREATE_CUSTOMER
Arguments:
email: "jane@example.com"
name: "Jane Doe"
description: "Enterprise plan customer"
address: {
"line1": "123 Main St",
"city": "San Francisco",
"state": "CA",
"postal_code": "94105",
"country": "US"
}
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
---
## Core Workflow Pattern
### 2. Manage Subscriptions
### Step 1: Discover Available Tools
Create subscriptions and view customer subscription details.
**Tools:**
- `STRIPE_CREATE_SUBSCRIPTION` -- Create a new subscription for an existing customer
- `STRIPE_GET_CUSTOMERS_CUSTOMER_SUBSCRIPTIONS` -- List all subscriptions for a customer
- `STRIPE_GET_CUSTOMERS_CUSTOMER_SUBS_SUB_EXPOSED_ID` -- Get a specific subscription
**Key Parameters for `STRIPE_CREATE_SUBSCRIPTION`:**
- `customer` (required) -- Customer ID, e.g., `"cus_xxxxxxxxxxxxxx"`
- `items` (required) -- Array of subscription items, each with:
- `price` -- Price ID, e.g., `"price_xxxxxxxxxxxxxx"` (use this OR `price_data`)
- `price_data` -- Inline price definition with `currency`, `product`, `unit_amount`, `recurring`
- `quantity` -- Item quantity
- `default_payment_method` -- Payment method ID (not required for trials or invoice billing)
- `trial_period_days` -- Trial days (no payment required during trial)
- `collection_method` -- `"charge_automatically"` (default) or `"send_invoice"`
- `cancel_at_period_end` -- Cancel at end of billing period (boolean)
**Key Parameters for `STRIPE_GET_CUSTOMERS_CUSTOMER_SUBSCRIPTIONS`:**
- `customer` (required) -- Customer ID
- `status` -- Filter: `"active"`, `"all"`, `"canceled"`, `"trialing"`, `"past_due"`, etc.
- `limit` -- Results per page (1--100, default 10)
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Braintree task"}]
session: {id: "existing_session_id"}
Tool: STRIPE_CREATE_SUBSCRIPTION
Arguments:
customer: "cus_abc123"
items: [{"price": "price_xyz789", "quantity": 1}]
trial_period_days: 14
```
### Step 2: Check Connection
---
### 3. Manage Payment Methods
List and attach payment methods to customers.
**Tools:**
- `STRIPE_GET_CUSTOMERS_CUSTOMER_PAYMENT_METHODS` -- List a customer's payment methods
- `STRIPE_ATTACH_PAYMENT_METHOD` -- Attach a payment method to a customer
**Key Parameters for `STRIPE_GET_CUSTOMERS_CUSTOMER_PAYMENT_METHODS`:**
- `customer` (required) -- Customer ID
- `type` -- Filter by type: `"card"`, `"sepa_debit"`, `"us_bank_account"`, etc.
- `limit` -- Results per page (1--100, default 10)
**Example:**
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["braintree"]
session_id: "your_session_id"
Tool: STRIPE_GET_CUSTOMERS_CUSTOMER_PAYMENT_METHODS
Arguments:
customer: "cus_abc123"
type: "card"
limit: 10
```
### Step 3: Execute Tools
---
### 4. View Balance Transactions
Retrieve the history of balance changes for a customer.
**Tool:** `STRIPE_GET_CUSTOMERS_CUSTOMER_BALANCE_TRANSACTIONS`
**Key Parameters:**
- `customer` (required) -- Customer ID
- `created` -- Filter by creation date with comparison operators: `{"gte": 1609459200}` or `{"gt": 1609459200, "lt": 1640995200}`
- `invoice` -- Filter by related invoice ID
- `limit` -- Results per page (1--100)
- `starting_after` / `ending_before` -- Pagination cursors
**Example:**
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: STRIPE_GET_CUSTOMERS_CUSTOMER_BALANCE_TRANSACTIONS
Arguments:
customer: "cus_abc123"
limit: 25
created: {"gte": 1704067200}
```
---
## 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
| Pitfall | Detail |
|---------|--------|
| **Search query syntax** | `STRIPE_GET_V1_CUSTOMERS_SEARCH_CUSTOMERS` requires field-prefixed queries (e.g., `email:'x'`). Bare strings without field prefixes are invalid and will error. |
| **Subscription payment method** | `default_payment_method` is not required if using `trial_period_days` or `collection_method='send_invoice'`. Otherwise, the subscription may fail to activate. |
| **Payment method attachment** | A `PaymentMethod` must be in a detached state before attaching to a customer. Already-attached methods will error. |
| **Pagination cursors** | Use `starting_after`/`ending_before` with object IDs, not page numbers. Extract the last/first object ID from each response. |
| **Balance amounts in cents** | All monetary amounts are in the smallest currency unit (e.g., cents for USD). 1000 = $10.00. |
| **Subscription status default** | `GET_CUSTOMERS_CUSTOMER_SUBSCRIPTIONS` excludes canceled subscriptions by default. Pass `status: "all"` to include them. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Braintree-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `braintree` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `STRIPE_CREATE_CUSTOMER` | Create a new customer |
| `STRIPE_GET_CUSTOMERS_CUSTOMER` | Retrieve a customer by ID |
| `STRIPE_POST_CUSTOMERS_CUSTOMER` | Update an existing customer |
| `STRIPE_LIST_CUSTOMERS` | List customers with pagination |
| `STRIPE_GET_V1_CUSTOMERS_SEARCH_CUSTOMERS` | Search customers by attributes |
| `STRIPE_CREATE_SUBSCRIPTION` | Create a subscription for a customer |
| `STRIPE_GET_CUSTOMERS_CUSTOMER_SUBSCRIPTIONS` | List customer subscriptions |
| `STRIPE_GET_CUSTOMERS_CUSTOMER_SUBS_SUB_EXPOSED_ID` | Get a specific subscription |
| `STRIPE_GET_CUSTOMERS_CUSTOMER_PAYMENT_METHODS` | List customer payment methods |
| `STRIPE_ATTACH_PAYMENT_METHOD` | Attach payment method to customer |
| `STRIPE_GET_CUSTOMERS_CUSTOMER_BALANCE_TRANSACTIONS` | List customer balance transactions |
---
*Powered by [Composio](https://composio.dev)*

206
capsule-crm-automation/SKILL.md
View File

@@ -1,91 +1,177 @@
---
name: capsule-crm-automation
description: "Automate Capsule CRM tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Capsule CRM Automation
description: "Automate Capsule CRM operations -- manage contacts (parties), run structured filter queries, track tasks and projects, log entries, and handle organizations -- using natural language through the Composio MCP integration."
category: crm
requires:
mcp: [rube]
mcp:
- rube
---
# Capsule CRM Automation via Rube MCP
# Capsule CRM Automation
Automate Capsule CRM operations through Composio's Capsule CRM toolkit via Rube MCP.
Manage your Capsule CRM -- create and update contacts, run powerful filter queries on parties/opportunities/cases, track tasks and projects, browse activity entries, and organize team relationships -- all through natural language commands.
**Toolkit docs**: [composio.dev/toolkits/capsule_crm](https://composio.dev/toolkits/capsule_crm)
**Toolkit docs:** [composio.dev/toolkits/capsule_crm](https://composio.dev/toolkits/capsule_crm)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Capsule CRM connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `capsule_crm`
- 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. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Connect your Capsule CRM account when prompted (OAuth authentication).
3. Start issuing natural language commands to manage your CRM.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `capsule_crm`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Run Structured Filter Queries
Query parties, opportunities, or cases (projects) with multiple filter conditions, operators, and sorting.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Capsule CRM operations", known_fields: ""}]
session: {generate_id: true}
```
**Tool:** `CAPSULE_CRM_RUN_FILTER_QUERY`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Example prompt:**
> "Find all Capsule CRM contacts in California tagged as 'VIP' sorted by name"
## Core Workflow Pattern
**Key parameters:**
- `entity` (required) -- One of: `parties`, `opportunities`, `kases`
- `filter` (required) -- Filter object with:
- `conditions` -- Array of conditions, each with:
- `field` -- Field name (e.g., "name", "email", "state", "country", "tag", "owner", "jobTitle", "addedOn")
- `operator` -- One of: "is", "is not", "starts with", "ends with", "contains", "is greater than", "is less than", "is after", "is before", "is older than", "is within last", "is within next"
- `value` -- Value to compare against
- `orderBy` -- Array of sort objects with `field` and `direction` ("ascending"/"descending")
- `embed` -- Additional data to include in response
- `page` / `perPage` -- Pagination (max 100 per page)
### Step 1: Discover Available Tools
**Important field notes:**
- Address fields (`city`, `state`, `country`, `zip`) are top-level, NOT nested under "address"
- Country must be an ISO 3166-1 alpha-2 code (e.g., "US", "GB", "CA")
- Custom fields use `custom:{fieldId}` format
- Organization fields use `org.` prefix (e.g., `org.name`, `org.tag`)
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Capsule CRM task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. List and Manage Contacts (Parties)
Retrieve all contacts with optional filtering by modification date and embedded related data.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["capsule_crm"]
session_id: "your_session_id"
```
**Tool:** `CAPSULE_CRM_LIST_PARTIES`
### Step 3: Execute Tools
**Example prompt:**
> "List all Capsule CRM contacts modified since January 2025 with their tags and organizations"
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Key parameters:**
- `since` -- ISO8601 date to filter contacts changed after this date
- `embed` -- Additional data: "tags", "fields", "organisation", "missingImportantFields"
- `page` / `perPage` -- Pagination (max 100 per page, default 50)
---
### 3. Create New Contacts
Add people or organizations to your Capsule CRM with full details including emails, phones, addresses, tags, and custom fields.
**Tool:** `CAPSULE_CRM_CREATE_PARTY`
**Example prompt:**
> "Create a new person in Capsule CRM: John Smith, VP of Sales at Acme Corp, john@acme.com"
**Key parameters:**
- `type` (required) -- "person" or "organisation"
- For persons: `firstName`, `lastName`, `jobTitle`, `title`
- For organisations: `name`
- `emailAddresses` -- Array of `{address, type}` objects
- `phoneNumbers` -- Array of `{number, type}` objects
- `addresses` -- Array of address objects with `street`, `city`, `state`, `country`, `zip`, `type` (Home/Postal/Office/Billing/Shipping)
- `organisation` -- Link to org by `{id}` or `{name}` (creates if not found)
- `tags` -- Array of tags by `{name}` or `{id}`
- `fields` -- Custom field values with `{definition, value}`
- `websites` -- Array of `{address, service, type}` objects
- `owner` -- Assign owner user `{id}`
---
### 4. Update Existing Contacts
Modify any aspect of a party record including adding/removing emails, phones, tags, and custom fields.
**Tool:** `CAPSULE_CRM_UPDATE_PARTY`
**Example prompt:**
> "Update Capsule CRM party 11587: add a work email john.new@acme.com and remove tag 'prospect'"
**Key parameters:**
- `partyId` (required) -- Integer ID of the party to update
- `party` (required) -- Object with fields to update. Supports:
- All creation fields (name, emails, phones, addresses, etc.)
- `_delete: true` on sub-items to remove them (requires the item's `id`)
- Tags: add by `{name}` or remove with `{id, _delete: true}`
---
### 5. Track Tasks
List tasks with filtering by status and embedded related data.
**Tool:** `CAPSULE_CRM_LIST_TASKS`
**Example prompt:**
> "Show all open tasks in Capsule CRM with their linked parties and owners"
**Key parameters:**
- `status` -- Filter by status: "open", "completed", "pending" (array)
- `embed` -- Additional data: "party", "opportunity", "kase", "owner", "nextTask"
- `page` / `perPage` -- Pagination (max 100 per page, default 50)
---
### 6. Browse Projects and Activity Entries
List projects (cases) and recent activity entries including notes, emails, and completed tasks.
**Tools:** `CAPSULE_CRM_LIST_PROJECTS`, `CAPSULE_CRM_LIST_ENTRIES_BY_DATE`
**Example prompt:**
> "Show all open projects in Capsule CRM" / "Show recent activity entries with party details"
**Key parameters for projects:**
- `status` -- Filter by "OPEN" or "CLOSED"
- `search` -- Search term for project names/descriptions
- `since` -- ISO8601 date for modifications after this date
- `embed` -- "tags,fields,party,opportunity,missingImportantFields"
**Key parameters for entries:**
- `embed` -- "party", "kase", "opportunity", "creator", "activityType"
- `page` / `perPage` -- Pagination (max 100 per page)
---
## 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
- **Address fields are top-level**: When filtering, use `state`, `city`, `country`, `zip` directly -- NOT `address.state` or nested syntax.
- **Country codes are ISO alpha-2**: Filter by "US", "GB", "CA" -- not "United States" or "United Kingdom".
- **Custom fields use special syntax**: Reference custom fields as `custom:{fieldId}` in filter conditions. For org-level custom fields, use `org.custom:{fieldId}`.
- **Projects are called "kases" in the API**: Despite being "projects" in the UI, the API entity type is `kases`. Use `kases` in filter queries.
- **Delete operations require item IDs**: When updating a party to remove sub-items (emails, phones, tags), you must include the item's `id` along with `_delete: true`. List the party first to get sub-item IDs.
- **Pagination defaults to 50**: All list endpoints default to 50 items per page with a max of 100. Always implement pagination for complete data retrieval.
- **Embed values vary by entity**: Not all embed options work for all entities. Check the documentation for supported embed values per endpoint.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Capsule CRM-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `capsule_crm` |
| 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` |
| Action | Tool Slug | Required Params |
|---|---|---|
| Run filter query | `CAPSULE_CRM_RUN_FILTER_QUERY` | `entity`, `filter` |
| List contacts | `CAPSULE_CRM_LIST_PARTIES` | None (optional filters) |
| Create contact | `CAPSULE_CRM_CREATE_PARTY` | `type` |
| Update contact | `CAPSULE_CRM_UPDATE_PARTY` | `partyId`, `party` |
| Delete contact | `CAPSULE_CRM_DELETE_PARTY` | `party_id` |
| List tasks | `CAPSULE_CRM_LIST_TASKS` | None (optional filters) |
| List projects | `CAPSULE_CRM_LIST_PROJECTS` | None (optional filters) |
| List activity entries | `CAPSULE_CRM_LIST_ENTRIES_BY_DATE` | None (optional filters) |
| List org employees | `CAPSULE_CRM_LIST_ORG_EMPLOYEES` | Organisation ID |
| List deleted opportunities | `CAPSULE_CRM_LIST_DELETED_OPPORTUNITIES` | `since` |
---
*Powered by [Composio](https://composio.dev)*

160
clockify-automation/SKILL.md
View File

@@ -1,91 +1,147 @@
---
name: clockify-automation
description: "Automate Clockify tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Clockify Automation
description: "Automate time tracking workflows in Clockify -- create and manage time entries, workspaces, and users through natural language commands."
requires:
mcp: [rube]
mcp:
- rube
---
# Clockify Automation via Rube MCP
# Clockify Automation
Automate Clockify operations through Composio's Clockify toolkit via Rube MCP.
Automate your Clockify time tracking operations directly from Claude Code. Log time entries, query historical data, manage workspaces, and audit team activity -- all without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/clockify](https://composio.dev/toolkits/clockify)
**Toolkit docs:** [composio.dev/toolkits/clockify](https://composio.dev/toolkits/clockify)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Clockify connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `clockify`
- 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. Add the Rube MCP server to your Claude Code config with URL: `https://rube.app/mcp`
2. When prompted, authenticate your Clockify account through the connection link provided
3. Start automating your time tracking workflows with natural language
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `clockify`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Create Time Entries
Log time with project, task, and tag associations, plus billable status.
**Tool:** `CLOCKIFY_CREATE_TIME_ENTRY`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Clockify operations", known_fields: ""}]
session: {generate_id: true}
Log 2 hours of work on project 64a687e2 in workspace 64a687e3 starting at 9am UTC today with description "API development"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Key parameters:
- `workspaceId` (required) -- workspace where the entry is created
- `start` (required) -- ISO 8601 start time (e.g., `2026-02-11T09:00:00Z`)
- `end` -- ISO 8601 end time; omit to create a running timer
- `projectId` -- associate with a project
- `taskId` -- associate with a task
- `description` -- work description (0-3000 chars)
- `tagIds` -- array of tag IDs
- `billable` -- whether the entry is billable
- `customFieldValues` -- array of custom field entries with `customFieldId` and `value`
## Core Workflow Pattern
### 2. Query Time Entries
### Step 1: Discover Available Tools
Retrieve historical time entries for reporting, auditing, and invoicing.
**Tool:** `CLOCKIFY_GET_TIME_ENTRIES`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Clockify task"}]
session: {id: "existing_session_id"}
Get all time entries for user abc123 in workspace xyz789 from January 2026
```
### Step 2: Check Connection
Key parameters:
- `workspaceId` (required) -- workspace to query
- `userId` (required) -- user whose entries to retrieve
- `start` / `end` -- ISO 8601 date range filters
- `project` -- filter by project ID
- `task` -- filter by task ID
- `tags` -- comma-separated tag IDs
- `description` -- text filter (partial match)
- `hydrated` -- set `true` to get full project/task/tag objects instead of just IDs
- `in-progress` -- set `true` to return only the running timer
- `page` / `page-size` -- pagination (default 50 per page)
### 3. Delete Time Entries
Remove erroneous, duplicate, or cancelled time entries.
**Tool:** `CLOCKIFY_DELETE_TIME_ENTRY`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["clockify"]
session_id: "your_session_id"
Delete time entry 5b715448 from workspace 64a687e3
```
### Step 3: Execute Tools
- Requires `workspaceId` and `id` (the time entry ID)
- Use for cleanup of bad imports or duplicates
### 4. Manage Workspaces
List all workspaces the authenticated user belongs to.
**Tool:** `CLOCKIFY_GET_ALL_MY_WORKSPACES`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Show me all my Clockify workspaces
```
- Optional `roles` filter -- array of roles like `["WORKSPACE_ADMIN", "OWNER"]`
- Use this to discover workspace IDs before creating or querying entries
### 5. User Information
Retrieve current user details and list workspace members.
**Tools:** `CLOCKIFY_GET_CURRENTLY_LOGGED_IN_USER_INFO`, `CLOCKIFY_FIND_ALL_USERS_ON_WORKSPACE`
```
Who am I logged in as? Then list all users in workspace 64a687e3
```
- `CLOCKIFY_GET_CURRENTLY_LOGGED_IN_USER_INFO` returns the authenticated user's profile (no parameters needed)
- `CLOCKIFY_FIND_ALL_USERS_ON_WORKSPACE` requires `workspaceId`; supports `name`, `email` filters and pagination (`page`, `page-size` max 100)
### 6. Running Timer Management
Start a timer by omitting `end` in create, or check for running entries.
**Tools:** `CLOCKIFY_CREATE_TIME_ENTRY`, `CLOCKIFY_GET_TIME_ENTRIES`
```
Start a timer on project abc in workspace xyz with description "Working on bug fix"
```
- Create without `end` to start a running timer
- Use `CLOCKIFY_GET_TIME_ENTRIES` with `in-progress: true` to check if a timer is running
---
## 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
- **Workspace and user IDs are required:** Most Clockify tools require both `workspaceId` and `userId`. Always call `CLOCKIFY_GET_ALL_MY_WORKSPACES` and `CLOCKIFY_GET_CURRENTLY_LOGGED_IN_USER_INFO` first to resolve these IDs.
- **ISO 8601 timestamps:** All time parameters must be in ISO 8601 format with timezone (e.g., `2026-02-11T09:00:00Z`). Omitting the timezone causes unpredictable behavior.
- **Running timers:** Only one timer can run at a time. Creating a new entry without `end` will fail if another timer is already active. Stop the existing timer first.
- **Pagination defaults:** `CLOCKIFY_GET_TIME_ENTRIES` defaults to 50 entries per page. For full exports, loop through pages until no more results are returned.
- **Tag IDs are workspace-scoped:** Tag IDs from one workspace cannot be used in another. Always resolve tags within the target workspace context.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Clockify-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `clockify` |
| 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` |
| Tool Slug | Description |
|---|---|
| `CLOCKIFY_CREATE_TIME_ENTRY` | Create a time entry or start a timer (requires `workspaceId`, `start`) |
| `CLOCKIFY_GET_TIME_ENTRIES` | List time entries with filters (requires `workspaceId`, `userId`) |
| `CLOCKIFY_DELETE_TIME_ENTRY` | Delete a time entry (requires `workspaceId`, `id`) |
| `CLOCKIFY_GET_ALL_MY_WORKSPACES` | List all workspaces for the authenticated user |
| `CLOCKIFY_GET_CURRENTLY_LOGGED_IN_USER_INFO` | Get current user profile info |
| `CLOCKIFY_FIND_ALL_USERS_ON_WORKSPACE` | List all users in a workspace (requires `workspaceId`) |
---
*Powered by [Composio](https://composio.dev)*

214
cloudinary-automation/SKILL.md
View File

@@ -1,91 +1,185 @@
---
name: cloudinary-automation
description: "Automate Cloudinary tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Cloudinary Automation
description: "Automate Cloudinary media management including folder organization, upload presets, asset lookup, transformations, and usage monitoring through natural language commands"
requires:
mcp: [rube]
mcp:
- rube
---
# Cloudinary Automation via Rube MCP
# Cloudinary Automation
Automate Cloudinary operations through Composio's Cloudinary toolkit via Rube MCP.
Automate Cloudinary media management workflows -- create folders, configure upload presets, look up assets, manage transformations, search folders, and monitor usage -- all through natural language.
**Toolkit docs**: [composio.dev/toolkits/cloudinary](https://composio.dev/toolkits/cloudinary)
**Toolkit docs:** [composio.dev/toolkits/cloudinary](https://composio.dev/toolkits/cloudinary)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Cloudinary connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `cloudinary`
- 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. Add the Rube MCP server to your environment: `https://rube.app/mcp`
2. Connect your Cloudinary account when prompted (API key auth via Composio)
3. Start issuing natural language commands for Cloudinary automation
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `cloudinary`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Organize Assets with Folders
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Cloudinary operations", known_fields: ""}]
session: {generate_id: true}
```
Create folder structures for organizing hosted images, videos, and raw files.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `CLOUDINARY_CREATE_FOLDER`
## Core Workflow Pattern
Key parameters:
- `folder` -- full path of the new asset folder (required), e.g., `images/events/2023`
### Step 1: Discover Available Tools
Supporting tools:
- `CLOUDINARY_SEARCH_FOLDERS` -- search folders by name, path, or creation date using Lucene-like expressions
- `expression` -- search filter (e.g., `name:sample AND path:events`)
- `max_results` -- 1-500 results (default 50)
- `sort_by` -- list of sort objects (e.g., `[{"created_at": "desc"}]`)
- `next_cursor` -- pagination cursor
- `CLOUDINARY_GET_RESOURCES_BY_ASSET_FOLDER` -- list assets within a specific folder
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Cloudinary task"}]
session: {id: "existing_session_id"}
```
Example prompt:
> "Create a folder called 'marketing/campaigns/spring-2026' in Cloudinary"
### Step 2: Check Connection
---
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["cloudinary"]
session_id: "your_session_id"
```
### 2. Configure Upload Presets
### Step 3: Execute Tools
Define centralized upload behavior including target folder, allowed formats, transformations, tags, and overwrite rules.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Tool:** `CLOUDINARY_CREATE_UPLOAD_PRESET`
Key parameters:
- `name` -- preset name (auto-generated if omitted)
- `folder` -- target folder path for uploads (e.g., `samples/`)
- `allowed_formats` -- comma-separated list (e.g., `jpg,png,webp`)
- `tags` -- comma-separated tags to apply (e.g., `marketing,thumbnail`)
- `transformation` -- incoming transformation (e.g., `c_limit,w_500`)
- `eager` -- eager transformations to generate on upload (e.g., `c_fill,g_face,h_150,w_150`)
- `unsigned` -- allow unsigned uploads (`true`/`false`)
- `overwrite` -- overwrite existing assets with same public_id (cannot be `true` when `unsigned=true`)
- `resource_type` -- `image`, `video`, or `raw` (default `image`)
- `unique_filename` -- append random suffix to avoid collisions (default `true`)
- `use_filename` -- use original filename (default `false`)
- `moderation` -- moderation type: `manual`, `webpurify`, `aws_rek`, etc.
- `auto_tagging` -- confidence threshold 0.0-1.0 for AI auto-tagging
- `notification_url` -- webhook URL for upload notifications
Example prompt:
> "Create an upload preset called 'product-images' that only allows JPG and PNG, stores in 'products/' folder, and auto-tags with 0.7 confidence"
---
### 3. Look Up Asset Details
Retrieve full details for a specific asset by its public ID, including metadata, derived assets, and related resources.
**Tool:** `CLOUDINARY_GET_RESOURCE_BY_PUBLIC_ID`
Key parameters:
- `public_id` -- the asset's public ID (required)
- `resource_type` -- `image`, `video`, or `raw` (required)
- `type` -- delivery type: `upload`, `private`, `authenticated`, `fetch`, etc. (required)
- `colors` -- include color histogram and predominant colors
- `faces` -- include detected face coordinates
- `media_metadata` -- include IPTC, XMP, and detailed metadata
- `quality_analysis` -- include quality analysis scores
- `phash` -- include perceptual hash for similarity detection
- `versions` -- include backed-up versions
- `related` -- include related assets
- `max_results` -- max derived/related assets to return (1-500)
Example prompt:
> "Get full details for the image 'products/hero-banner' including color analysis and quality scores"
---
### 4. Manage Transformations and Derived Assets
List existing transformations, apply eager transformations to uploaded assets, and clean up derived resources.
**Tools:**
- `CLOUDINARY_GET_TRANSFORMATIONS` -- list all named and unnamed transformations
- `max_results` -- 1-500 (default 10)
- `next_cursor` -- pagination cursor
- `CLOUDINARY_EXPLICIT_RESOURCE` -- update an existing asset: pre-generate transformations, update metadata, move to new folders, or modify tags
- `public_id` -- target asset (required)
- `eager` -- list of transformation strings to pre-generate (e.g., `["c_fill,w_300,h_200", "c_thumb,w_100,h_100,g_face"]`)
- `eager_async` -- generate transformations asynchronously
- `tags` -- replace existing tags
- `asset_folder` -- move asset to a new folder
- `display_name` -- set display name
- `context` -- key-value metadata (e.g., `{"alt": "Mountain view"}`)
- `invalidate` -- invalidate CDN cache (takes up to 1 hour)
- `CLOUDINARY_DELETE_DERIVED_RESOURCES` -- delete specific derived assets by IDs (up to 100 per call)
Example prompt:
> "Pre-generate a 300x200 fill crop and a 100x100 face-detection thumbnail for asset 'products/hero-banner'"
---
### 5. Monitor Usage and Configuration
Check account-level usage limits, environment configuration, and tag inventory.
**Tools:**
- `CLOUDINARY_GET_USAGE` -- monitor storage, bandwidth, requests, and quota limits
- `CLOUDINARY_GET_CONFIG` -- fetch environment config details
- `settings` -- set to `true` to include configuration settings like `folder_mode`
- `CLOUDINARY_GET_TAGS` -- list all tags for a resource type
Example prompt:
> "Show me my Cloudinary account usage and remaining quota"
---
### 6. Set Up Webhook Triggers
Create webhook notifications for specific Cloudinary events.
**Tool:** `CLOUDINARY_CREATE_TRIGGER`
Use to receive callbacks when uploads complete, transformations finish, or other events occur.
Example prompt:
> "Create a webhook trigger that notifies https://my-app.com/hook on upload events"
---
## 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
| Pitfall | Details |
|---------|---------|
| Folder creation idempotency | `CLOUDINARY_CREATE_FOLDER` may error or no-op if the path already exists -- design idempotent folder naming |
| Preset-upload alignment | Upload preset options like `allowed_formats`, `folder`, and `unsigned` must match the actual upload method or uploads will be rejected |
| Strict asset lookup | `CLOUDINARY_GET_RESOURCE_BY_PUBLIC_ID` fails if any of `resource_type`, `type`, or `public_id` is incorrect, even when the asset exists |
| Folder path sensitivity | `CLOUDINARY_GET_RESOURCES_BY_ASSET_FOLDER` only lists assets in the exact folder specified; typos return empty results |
| Quota blocking | `CLOUDINARY_GET_USAGE` reflects account-level limits -- hitting caps silently blocks uploads until usage is checked and addressed |
| CDN invalidation delay | Setting `invalidate=true` on `CLOUDINARY_EXPLICIT_RESOURCE` takes up to 1 hour to propagate |
| Unsigned vs overwrite conflict | Cannot set `overwrite=true` when `unsigned=true` in upload presets |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Cloudinary-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `cloudinary` |
| 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` |
| Action | Tool Slug | Key Params |
|--------|-----------|------------|
| Create folder | `CLOUDINARY_CREATE_FOLDER` | `folder` |
| Search folders | `CLOUDINARY_SEARCH_FOLDERS` | `expression`, `max_results` |
| List folder assets | `CLOUDINARY_GET_RESOURCES_BY_ASSET_FOLDER` | folder path |
| Create upload preset | `CLOUDINARY_CREATE_UPLOAD_PRESET` | `name`, `folder`, `allowed_formats`, `tags` |
| Get asset details | `CLOUDINARY_GET_RESOURCE_BY_PUBLIC_ID` | `public_id`, `resource_type`, `type` |
| List transformations | `CLOUDINARY_GET_TRANSFORMATIONS` | `max_results`, `next_cursor` |
| Update/transform asset | `CLOUDINARY_EXPLICIT_RESOURCE` | `public_id`, `eager`, `tags` |
| Delete derived assets | `CLOUDINARY_DELETE_DERIVED_RESOURCES` | `derived_resource_ids` |
| Get usage | `CLOUDINARY_GET_USAGE` | (none) |
| Get config | `CLOUDINARY_GET_CONFIG` | `settings` |
| List tags | `CLOUDINARY_GET_TAGS` | resource_type |
| Create webhook | `CLOUDINARY_CREATE_TRIGGER` | event type, URL |
---
*Powered by [Composio](https://composio.dev)*

135
coinbase-automation/SKILL.md
View File

@@ -1,91 +1,110 @@
---
name: coinbase-automation
description: "Automate Coinbase tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Coinbase Automation
description: "Coinbase Automation: list and manage cryptocurrency wallets, accounts, and portfolio data via Coinbase CDP SDK"
requires:
mcp: [rube]
---
# Coinbase Automation via Rube MCP
# Coinbase Automation
Automate Coinbase operations through Composio's Coinbase toolkit via Rube MCP.
Automate Coinbase operations including listing cryptocurrency wallets, paginating through wallet collections, and retrieving portfolio data.
**Toolkit docs**: [composio.dev/toolkits/coinbase](https://composio.dev/toolkits/coinbase)
**Toolkit docs:** [composio.dev/toolkits/coinbase](https://composio.dev/toolkits/coinbase)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Coinbase connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `coinbase`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `coinbase`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure an active connection exists for the `coinbase` toolkit. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
---
Always discover available tools before executing workflows:
## Core Workflows
### 1. List All Wallets
Retrieve all wallets from Coinbase with pagination support.
**Tool:** `COINBASE_LIST_WALLETS`
**Key Parameters:**
- `limit` -- Results per page (1--100, default: 25)
- `order` -- Sort order: `"asc"` (ascending) or `"desc"` (descending, default)
- `starting_after` -- Cursor for forward pagination: ID of the last wallet from the previous page
- `ending_before` -- Cursor for backward pagination: ID of the first wallet from the previous page
**Example (first page):**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Coinbase operations", known_fields: ""}]
session: {generate_id: true}
Tool: COINBASE_LIST_WALLETS
Arguments:
limit: 50
order: "desc"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
**Example (next page):**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Coinbase task"}]
session: {id: "existing_session_id"}
Tool: COINBASE_LIST_WALLETS
Arguments:
limit: 50
order: "desc"
starting_after: "wallet_abc123_last_id_from_prev_page"
```
### Step 2: Check Connection
---
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["coinbase"]
session_id: "your_session_id"
```
### 2. Paginate Through All Wallets
### Step 3: Execute Tools
To retrieve a complete wallet inventory, iterate through pages.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Steps:**
1. Call `COINBASE_LIST_WALLETS` with desired `limit` and `order`
2. If the response contains more results, note the ID of the last wallet returned
3. Call `COINBASE_LIST_WALLETS` again with `starting_after` set to that last wallet ID
4. Repeat until no more results are returned
---
### 3. Audit Wallet Portfolio
Retrieve wallet data for portfolio analysis and reporting.
**Steps:**
1. Call `COINBASE_LIST_WALLETS` with `limit: 100` to maximize per-page results
2. Collect wallet balances and metadata from each page
3. Aggregate data across all pages for a complete portfolio view
---
### 4. Monitor Wallet Changes
Periodically list wallets to detect new additions or changes.
**Steps:**
1. Call `COINBASE_LIST_WALLETS` with `order: "desc"` to get newest wallets first
2. Compare against previously stored wallet IDs to identify new entries
3. Schedule periodic checks for continuous monitoring
---
## 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
| Pitfall | Detail |
|---------|--------|
| **Pagination required** | Wallet lists are paginated. Always check for additional pages using cursor-based pagination (`starting_after`/`ending_before`). |
| **Limit bounds** | The `limit` parameter accepts 1--100. Values outside this range cause errors. Default is 25. |
| **Cursor-based pagination** | Uses wallet IDs as cursors, not page numbers. You must extract the last/first wallet ID from each response to navigate pages. |
| **CDP SDK scope** | This tool uses the Coinbase CDP SDK. Available operations depend on the API key permissions granted during connection setup. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Coinbase-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `coinbase` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `COINBASE_LIST_WALLETS` | List cryptocurrency wallets with pagination |
---
*Powered by [Composio](https://composio.dev)*

135
contentful-automation/SKILL.md
View File

@@ -1,91 +1,106 @@
---
name: contentful-automation
description: "Automate Contentful tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Contentful Automation
description: "Automate headless CMS operations in Contentful -- list spaces, retrieve space metadata, and update space configurations through the Composio Contentful integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Contentful Automation via Rube MCP
# Contentful Automation
Automate Contentful operations through Composio's Contentful toolkit via Rube MCP.
Manage your **Contentful** headless CMS spaces directly from Claude Code. List spaces, retrieve metadata, and update space configurations without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/contentful](https://composio.dev/toolkits/contentful)
**Toolkit docs:** [composio.dev/toolkits/contentful](https://composio.dev/toolkits/contentful)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Contentful connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `contentful`
- 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. Add the Composio MCP server to your configuration:
```
https://rube.app/mcp
```
2. Connect your Contentful account when prompted. The agent will provide an authentication link. Ensure your access token has space management scopes.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `contentful`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List All Spaces
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Contentful operations", known_fields: ""}]
session: {generate_id: true}
```
Discover all Contentful spaces accessible to your authenticated account. This is typically the first operation since most other actions require a `space_id`.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `CONTENTFUL_LIST_SPACES`
## Core Workflow Pattern
Key parameters:
- `limit` (1-1000) -- maximum number of spaces to return (default: 100)
- `skip` -- number of spaces to skip for pagination
- `order` -- sort by field, e.g., `sys.createdAt` or `-sys.createdAt` for descending
### Step 1: Discover Available Tools
Example prompt: *"List all my Contentful spaces"*
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Contentful task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Get Space Details
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["contentful"]
session_id: "your_session_id"
```
Retrieve detailed metadata for a specific space including its current `sys.version`, which is required for updates.
### Step 3: Execute Tools
**Tool:** `CONTENTFUL_GET_SPACE`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
Key parameters:
- `space_id` (required) -- the ID of the space to retrieve (alphanumeric, 1-64 chars)
Example prompt: *"Get details for Contentful space abc123def"*
---
### 3. Update Space Name
Update the name of a specific space. Requires the current version number for optimistic locking to prevent concurrent modification conflicts.
**Tool:** `CONTENTFUL_UPDATE_SPACE`
Key parameters:
- `space_id` (required) -- ID of the space to update
- `name` (required) -- new name for the space (1-255 chars)
- `version` (required) -- current space version from `sys.version` (must be > 0)
Example prompt: *"Rename Contentful space abc123def to 'Production Content Hub'"*
---
### 4. Audit Space Inventory
Combine space listing and detail retrieval to audit your organization's Contentful spaces.
**Tools:** `CONTENTFUL_LIST_SPACES` then `CONTENTFUL_GET_SPACE`
Workflow:
1. List all spaces to get IDs and names
2. Fetch details for each space to get version info, creation dates, and metadata
Example prompt: *"Audit all Contentful spaces -- list them with their creation dates and current versions"*
---
## 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
- **Version conflicts on update:** `CONTENTFUL_UPDATE_SPACE` requires the latest `sys.version` from `CONTENTFUL_GET_SPACE`. If someone else modified the space between your read and write, the update will fail with a version conflict. Always fetch the space immediately before updating.
- **Pagination for many spaces:** `CONTENTFUL_LIST_SPACES` uses `limit` and `skip` parameters. When you have many spaces, iterate by incrementing `skip` until no more results are returned to avoid missing spaces.
- **Scope limitations:** These tools only manage space-level metadata (names). They cannot create or modify entries, content types, or assets within a space.
- **Auth/permissions mismatch:** Updates via `CONTENTFUL_UPDATE_SPACE` will fail if your token lacks space management scopes, even if reads via `CONTENTFUL_GET_SPACE` succeed. Verify your token has write permissions.
- **Space ID format:** The `space_id` must match the pattern `^[a-zA-Z0-9-_.]{1,64}$`. Invalid characters will be rejected.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Contentful-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `contentful` |
| 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` |
| Tool Slug | Description |
|---|---|
| `CONTENTFUL_LIST_SPACES` | List all spaces accessible to your account |
| `CONTENTFUL_GET_SPACE` | Retrieve detailed metadata for a single space |
| `CONTENTFUL_UPDATE_SPACE` | Update the name of a space (requires version) |
---
*Powered by [Composio](https://composio.dev)*

174
customerio-automation/SKILL.md
View File

@@ -1,91 +1,153 @@
---
name: customerio-automation
description: "Automate Customerio tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Customer.io Automation
description: "Automate customer engagement workflows including broadcast triggers, message analytics, segment management, and newsletter tracking through Customer.io via Composio"
requires:
mcp: [rube]
mcp:
- rube
---
# Customerio Automation via Rube MCP
# Customer.io Automation
Automate Customerio operations through Composio's Customerio toolkit via Rube MCP.
Automate customer engagement operations -- trigger targeted broadcasts, retrieve delivery metrics, manage audience segments, list newsletters and transactional templates, and inspect trigger execution history -- all orchestrated through the Composio MCP integration.
**Toolkit docs**: [composio.dev/toolkits/customerio](https://composio.dev/toolkits/customerio)
**Toolkit docs:** [composio.dev/toolkits/customerio](https://composio.dev/toolkits/customerio)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Customerio connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `customerio`
- 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. Connect your Customer.io account through the Composio MCP server at `https://rube.app/mcp`
2. The agent will prompt you with an authentication link if no active connection exists
3. Once connected, all `CUSTOMERIO_*` tools become available for execution
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `customerio`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Trigger a Broadcast
Manually fire a pre-configured broadcast to a specific audience with personalization data.
**Tool:** `CUSTOMERIO_TRIGGER_BROADCAST`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `broadcast_id` | integer | Yes | Broadcast ID from Customer.io Triggering Details |
| `ids` | array | No | List of customer IDs to target |
| `emails` | array | No | List of email addresses to target |
| `recipients` | object | No | Complex filter with `and`/`or`/`not`/`segment` operators |
| `per_user_data` | array | No | Per-user personalization with `id`/`email` + `data` |
| `data` | object | No | Global key-value data for Liquid template personalization |
| `data_file_url` | string | No | URL to JSON file with per-line user data |
| `email_add_duplicates` | boolean | No | Allow duplicate recipients (default: false) |
| `email_ignore_missing` | boolean | No | Skip people without emails (default: false) |
| `id_ignore_missing` | boolean | No | Skip people without customer IDs (default: false) |
**Important:** Provide exactly ONE audience option: `recipients`, `ids`, `emails`, `per_user_data`, or `data_file_url`. Rate limit: 1 request per 10 seconds per broadcast.
---
### 2. Retrieve Message Delivery Metrics
Fetch paginated delivery metrics for messages with filtering by campaign, type, and time window.
**Tool:** `CUSTOMERIO_GET_MESSAGES`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `type` | string | No | Message type: `email`, `webhook`, `twilio`, `slack`, `push`, `in_app` |
| `metric` | string | No | Metric: `attempted`, `sent`, `delivered`, `opened`, `clicked`, `converted` |
| `campaign_id` | integer | No | Filter by campaign ID |
| `newsletter_id` | integer | No | Filter by newsletter ID |
| `action_id` | integer | No | Filter by action ID |
| `start_ts` | integer | No | Start of time window (Unix timestamp) |
| `end_ts` | integer | No | End of time window (Unix timestamp) |
| `limit` | integer | No | Results per page, 1-1000 (default: 50) |
| `start` | string | No | Pagination token from previous response `next` value |
| `drafts` | boolean | No | Return draft messages instead of active/sent |
---
### 3. List Audience Segments
Retrieve all segments defined in your workspace for audience analysis and broadcast targeting.
**Tool:** `CUSTOMERIO_GET_SEGMENTS`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Customerio operations", known_fields: ""}]
session: {generate_id: true}
No parameters required -- returns all segments with IDs and metadata.
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Use segment IDs when targeting broadcasts via the `recipients.segment.id` filter.
## Core Workflow Pattern
---
### Step 1: Discover Available Tools
### 4. List Newsletters
Paginate through all newsletter metadata for tracking and analysis.
**Tool:** `CUSTOMERIO_LIST_NEWSLETTERS`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `limit` | integer | No | Max per page, 1-100 |
| `sort` | string | No | `asc` (chronological) or `desc` (reverse) |
| `start` | string | No | Pagination cursor from previous response `next` value |
---
### 5. Discover Transactional Message Templates
List all transactional message templates to find IDs for sending via the API.
**Tool:** `CUSTOMERIO_LIST_TRANSACTIONAL_MESSAGES`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Customerio task"}]
session: {id: "existing_session_id"}
No parameters required -- returns template IDs and trigger names.
```
### Step 2: Check Connection
---
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["customerio"]
session_id: "your_session_id"
```
### 6. Inspect Broadcast Trigger History
Review all trigger executions for a broadcast and inspect individual trigger details.
### Step 3: Execute Tools
**Tools:** `CUSTOMERIO_GET_TRIGGERS` and `CUSTOMERIO_GET_TRIGGER`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**List all triggers for a broadcast:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `broadcast_id` | integer | Yes | The broadcast/campaign ID |
**Get a specific trigger:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `broadcast_id` | integer | Yes | The campaign/broadcast ID |
| `trigger_id` | string | Yes | Trigger identifier (e.g., `456` or `5-37`) |
---
## 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
| Pitfall | Details |
|---------|---------|
| **Mutually exclusive audience params** | `CUSTOMERIO_TRIGGER_BROADCAST` requires exactly ONE of `recipients`, `ids`, `emails`, `per_user_data`, or `data_file_url` -- providing multiple causes errors |
| **Rate limiting on broadcasts** | Broadcasts are limited to 1 trigger request per 10 seconds per broadcast ID |
| **Unix timestamp format** | `start_ts` and `end_ts` in `CUSTOMERIO_GET_MESSAGES` must be Unix timestamps, not ISO strings |
| **Pagination tokens** | Messages and newsletters use cursor-based pagination via the `start` parameter -- use the `next` value from previous responses |
| **Segment ID resolution** | To target a segment in a broadcast, first fetch segment IDs via `CUSTOMERIO_GET_SEGMENTS`, then reference by ID in `recipients.segment.id` |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Customerio-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `customerio` |
| 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` |
| Tool Slug | Purpose |
|-----------|---------|
| `CUSTOMERIO_TRIGGER_BROADCAST` | Trigger a broadcast to a defined audience |
| `CUSTOMERIO_GET_MESSAGES` | Retrieve message delivery metrics with filters |
| `CUSTOMERIO_GET_SEGMENTS` | List all audience segments |
| `CUSTOMERIO_GET_SEGMENT_DETAILS` | Get details for a specific segment |
| `CUSTOMERIO_LIST_NEWSLETTERS` | Paginate through newsletters |
| `CUSTOMERIO_LIST_TRANSACTIONAL_MESSAGES` | List transactional message templates |
| `CUSTOMERIO_GET_TRIGGERS` | List all trigger executions for a broadcast |
| `CUSTOMERIO_GET_TRIGGER` | Inspect a specific trigger execution |
---
*Powered by [Composio](https://composio.dev)*

151
docker-hub-automation/SKILL.md
View File

@@ -1,91 +1,136 @@
---
name: docker-hub-automation
description: "Automate Docker Hub tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Docker Hub Automation
description: "Automate Docker Hub operations -- manage organizations, repositories, teams, members, and webhooks via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Docker Hub Automation via Rube MCP
# Docker Hub Automation
Automate Docker Hub operations through Composio's Docker Hub toolkit via Rube MCP.
Automate your Docker Hub workflows -- create and manage organizations, repositories, teams, add members, set up image push webhooks, and list container images.
**Toolkit docs**: [composio.dev/toolkits/docker_hub](https://composio.dev/toolkits/docker_hub)
**Toolkit docs:** [composio.dev/toolkits/docker_hub](https://composio.dev/toolkits/docker_hub)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Docker Hub connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `docker_hub`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your Docker Hub account when prompted (JWT/token authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `docker_hub`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List Organizations
Use `DOCKER_HUB_LIST_ORGANIZATIONS` to discover which organizations the authenticated user belongs to.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Docker Hub operations", known_fields: ""}]
session: {generate_id: true}
Tool: DOCKER_HUB_LIST_ORGANIZATIONS
Inputs:
- page: integer (1-indexed, default 1)
- page_size: integer (1-100, default 25)
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
### 2. Create an Organization
## Core Workflow Pattern
### Step 1: Discover Available Tools
Use `DOCKER_HUB_CREATE_ORGANIZATION` to programmatically create a new Docker Hub organization.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Docker Hub task"}]
session: {id: "existing_session_id"}
Tool: DOCKER_HUB_CREATE_ORGANIZATION
Inputs:
- orgname: string (required) -- lowercase, letters/numbers/._- only, min 2 chars
- company: string (optional) -- company name associated with the org
```
### Step 2: Check Connection
**Note:** Requires JWT authentication obtained via `/v2/users/login` and may have restricted access.
### 3. Get Organization Details and Repositories
Use `DOCKER_HUB_GET_ORGANIZATION` to retrieve namespace info and its repositories. Works with any public namespace.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["docker_hub"]
session_id: "your_session_id"
Tool: DOCKER_HUB_GET_ORGANIZATION
Inputs:
- organization: string (required) -- e.g., "docker", "bitnami", "library"
```
### Step 3: Execute Tools
### 4. Create a Repository
Use `DOCKER_HUB_CREATE_REPOSITORY` to create public or private repositories under a namespace.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: DOCKER_HUB_CREATE_REPOSITORY
Inputs:
- namespace: string (required) -- Docker Hub username or org name
- name: string (required) -- lowercase; letters, numbers, ._- allowed
- description: string (optional) -- max 100 characters
- full_description: string (optional) -- Markdown README content
- is_private: boolean (default false) -- private repos require paid plan
```
### 5. List Repositories with Filtering
Use `DOCKER_HUB_LIST_REPOSITORIES` to enumerate repos within a namespace with sorting and content-type filtering.
```
Tool: DOCKER_HUB_LIST_REPOSITORIES
Inputs:
- namespace: string (required) -- e.g., "library", "myorg"
- ordering: "name" | "last_updated" | "pull_count" (prefix with - for descending)
- page: integer (default 1)
- page_size: integer (1-100, default 25)
- content_types: string (comma-separated, e.g., "image,artifact")
```
### 6. Manage Teams, Members, and Webhooks
Use `DOCKER_HUB_LIST_TEAMS` to list teams within an org, `DOCKER_HUB_ADD_ORG_MEMBER` to invite users, and `DOCKER_HUB_CREATE_WEBHOOK` for push notifications.
```
Tool: DOCKER_HUB_LIST_TEAMS
- Lists all teams/groups within a Docker Hub organization
Tool: DOCKER_HUB_ADD_ORG_MEMBER
- Invite a user to join an organization by Docker ID or email
- Requires owner or admin permissions
Tool: DOCKER_HUB_CREATE_WEBHOOK
- Create a webhook on a repository for image push notifications
- Two-step process: create webhook, then add hook URL
- Requires admin permissions on the repository
```
---
## 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
| Pitfall | Detail |
|---------|--------|
| JWT authentication | `DOCKER_HUB_CREATE_ORGANIZATION` requires JWT auth from `/v2/users/login` -- standard API tokens may not suffice. |
| Private repo limits | Creating private repos (`is_private: true`) requires a paid Docker Hub plan. |
| Org name constraints | Organization names must be lowercase, at least 2 characters, containing only letters, numbers, `.`, `_`, or `-`. |
| Webhook two-step | `DOCKER_HUB_CREATE_WEBHOOK` is a two-step process: first create the webhook with a name, then add a hook URL to it. |
| Pagination | All list endpoints use page-based pagination -- iterate pages until results are exhausted. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Docker Hub-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `docker_hub` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `DOCKER_HUB_LIST_ORGANIZATIONS` | List orgs the user belongs to |
| `DOCKER_HUB_CREATE_ORGANIZATION` | Create a new Docker Hub organization |
| `DOCKER_HUB_GET_ORGANIZATION` | Get org details and repository list |
| `DOCKER_HUB_CREATE_REPOSITORY` | Create a repository under a namespace |
| `DOCKER_HUB_LIST_REPOSITORIES` | List repos with filtering and sorting |
| `DOCKER_HUB_LIST_TEAMS` | List teams/groups within an org |
| `DOCKER_HUB_ADD_ORG_MEMBER` | Invite a user to an organization |
| `DOCKER_HUB_CREATE_WEBHOOK` | Create push-notification webhook on a repo |
---
*Powered by [Composio](https://composio.dev)*

248
dynamics365-automation/SKILL.md
View File

@@ -1,91 +1,237 @@
---
name: dynamics365-automation
description: "Automate Dynamics365 tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Dynamics 365 Automation
description: "Dynamics 365 Automation: manage CRM contacts, accounts, leads, opportunities, sales orders, invoices, and cases via the Dynamics CRM Web API"
requires:
mcp: [rube]
---
# Dynamics365 Automation via Rube MCP
# Dynamics 365 Automation
Automate Dynamics365 operations through Composio's Dynamics365 toolkit via Rube MCP.
Automate Microsoft Dynamics 365 CRM operations including creating and updating contacts, accounts, leads, opportunities, sales orders, invoices, and support cases.
**Toolkit docs**: [composio.dev/toolkits/dynamics365](https://composio.dev/toolkits/dynamics365)
**Toolkit docs:** [composio.dev/toolkits/dynamics365](https://composio.dev/toolkits/dynamics365)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Dynamics365 connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `dynamics365`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `dynamics365`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure an active connection exists for the `dynamics365` toolkit. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
---
Always discover available tools before executing workflows:
## Core Workflows
### 1. Manage Leads
Create, update, retrieve, and list lead records.
**Tools:**
- `DYNAMICS365_DYNAMICSCRM_CREATE_LEAD` -- Create a new lead
- `DYNAMICS365_DYNAMICSCRM_UPDATE_LEAD` -- Update an existing lead
- `DYNAMICS365_DYNAMICSCRM_GET_A_LEAD` -- Retrieve a lead by GUID
- `DYNAMICS365_DYNAMICSCRM_GET_ALL_LEADS` -- List/filter all leads
**Key Parameters for `DYNAMICS365_DYNAMICSCRM_CREATE_LEAD`:**
- `firstname` -- First name of the lead
- `lastname` -- Last name of the lead
- `emailaddress1` -- Primary email address
- `telephone1` -- Primary phone number
- `companyname` -- Associated company name
- `subject` -- Brief title/description
**Key Parameters for `DYNAMICS365_DYNAMICSCRM_GET_ALL_LEADS`:**
- `filter` -- OData filter, e.g., `"contains(fullname,'John')"`
- `select` -- Fields to return, e.g., `"fullname,emailaddress1"`
- `orderby` -- Sort expression, e.g., `"createdon desc"`
- `top` -- Max number of results
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Dynamics365 operations", known_fields: ""}]
session: {generate_id: true}
Tool: DYNAMICS365_DYNAMICSCRM_CREATE_LEAD
Arguments:
firstname: "Jane"
lastname: "Smith"
emailaddress1: "jane.smith@example.com"
companyname: "Acme Corp"
subject: "Interested in Enterprise plan"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
---
## Core Workflow Pattern
### 2. Manage Accounts
### Step 1: Discover Available Tools
Create and organize account (company) records in the CRM.
**Tool:** `DYNAMICS365_DYNAMICSCRM_CREATE_ACCOUNT`
**Key Parameters:**
- `name` -- Account/company name
- `description` -- Description of the account
- `revenue` -- Revenue amount (number)
- `accountcategorycode` -- Category code (integer, default: 1)
- `creditonhold` -- Whether account is on credit hold (boolean)
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Dynamics365 task"}]
session: {id: "existing_session_id"}
Tool: DYNAMICS365_DYNAMICSCRM_CREATE_ACCOUNT
Arguments:
name: "Contoso Ltd"
description: "Strategic partner for cloud services"
revenue: 5000000
creditonhold: false
```
### Step 2: Check Connection
---
### 3. Manage Contacts
Create detailed contact records with address and phone information.
**Tool:** `DYNAMICS365_DYNAMICSCRM_CREATE_CONTACT`
**Key Parameters:**
- `firstname`, `lastname` -- Contact name
- `emailaddress1` -- Primary email
- `telephone1` -- Primary phone
- `mobilephone` -- Mobile phone
- `jobtitle` -- Job title
- `address1_city`, `address1_stateorprovince`, `address1_postalcode`, `address1_country` -- Address fields
**Example:**
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["dynamics365"]
session_id: "your_session_id"
Tool: DYNAMICS365_DYNAMICSCRM_CREATE_CONTACT
Arguments:
firstname: "Bob"
lastname: "Johnson"
emailaddress1: "bob.johnson@example.com"
jobtitle: "VP of Engineering"
address1_city: "Seattle"
address1_stateorprovince: "WA"
```
### Step 3: Execute Tools
---
### 4. Manage Opportunities
Create and update sales opportunities with estimated values and close dates.
**Tools:**
- `DYNAMICS365_DYNAMICSCRM_CREATE_OPPORTUNITY` -- Create a new opportunity
- `DYNAMICS365_DYNAMICSCRM_UPDATE_OPPORTUNITY` -- Update an existing opportunity
**Key Parameters for `DYNAMICS365_DYNAMICSCRM_CREATE_OPPORTUNITY`:**
- `name` (required) -- Opportunity title
- `description` -- Brief description
- `estimatedvalue` -- Anticipated revenue (number)
- `estimatedclosedate` -- Expected close date in `YYYY-MM-DD` format
- `customer_account_id` -- GUID of the related account (no curly braces)
- `customer_contact_id` -- GUID of the related contact (no curly braces)
**Key Parameters for `DYNAMICS365_DYNAMICSCRM_UPDATE_OPPORTUNITY`:**
- `opportunity_id` (required) -- GUID of the opportunity
- `opportunityratingcode` -- 1 (Cold), 2 (Warm), 3 (Hot)
- `salesstagecode` -- 1 (Qualify), 2 (Develop), 3 (Propose)
**Example:**
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: DYNAMICS365_DYNAMICSCRM_CREATE_OPPORTUNITY
Arguments:
name: "Enterprise Cloud Migration"
estimatedvalue: 250000
estimatedclosedate: "2026-06-30"
description: "Full cloud migration project for Contoso"
```
---
### 5. Manage Sales Orders and Invoices
Create and update sales orders; generate invoices for billing.
**Tools:**
- `DYNAMICS365_DYNAMICSCRM_CREATE_SALES_ORDER` -- Create a new sales order
- `DYNAMICS365_DYNAMICSCRM_UPDATE_SALES_ORDER` -- Update an existing sales order
- `DYNAMICS365_DYNAMICSCRM_CREATE_INVOICE` -- Create a new invoice
**Key Parameters for `DYNAMICS365_DYNAMICSCRM_CREATE_SALES_ORDER`:**
- `name` -- Sales order name
- `description` -- Description
- `account_id` -- Reference to account, format: `"/accounts(GUID)"`
- `currency_id` -- Currency reference, format: `"/transactioncurrencies(GUID)"`
- `price_level_id` -- Price list reference, format: `"/pricelevels(GUID)"`
**Key Parameters for `DYNAMICS365_DYNAMICSCRM_UPDATE_SALES_ORDER`:**
- `salesorder_id` (required) -- GUID of the sales order
- `name` -- Updated name
- `discountamount` -- Updated discount
- `freightamount` -- Updated shipping cost
**Key Parameters for `DYNAMICS365_DYNAMICSCRM_CREATE_INVOICE`:**
- `name` -- Invoice name/number, e.g., `"Invoice #12345"`
- `description` -- Invoice description
- `account_id` -- Related account reference
- `currency_id` -- Currency reference
- `price_level_id` -- Price list reference
---
### 6. Create Support Cases
Create incident/case records for customer support tracking.
**Tool:** `DYNAMICS365_DYNAMICSCRM_CREATE_CASE`
**Key Parameters:**
- `title` -- Subject/title of the case
- `description` -- Detailed description
- `prioritycode` -- 1 (Low), 2 (Normal), 3 (High)
- `caseorigincode` -- 1 (Phone), 2 (Email), 3 (Web)
- `account_id` -- Related account, format: `"/accounts(GUID)"`
- `contact_id` -- Related contact, format: `"/contacts(GUID)"`
**Example:**
```
Tool: DYNAMICS365_DYNAMICSCRM_CREATE_CASE
Arguments:
title: "Login issue reported by customer"
description: "Customer unable to access portal since Feb 10"
prioritycode: 3
caseorigincode: 2
```
---
## 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
| Pitfall | Detail |
|---------|--------|
| **GUID format** | All entity IDs are GUIDs (e.g., `"00000000-0000-0000-0000-000000000000"`). Do not include curly braces for opportunity/contact references. |
| **Reference format** | Related entity references use the format `"/entityset(GUID)"` (e.g., `"/accounts(abc-123)"`). Missing the leading slash or parentheses causes errors. |
| **OData filter syntax** | Use Dynamics 365 OData syntax for `filter` (e.g., `contains(fullname,'John')`). Incorrect syntax returns empty or error responses. |
| **user_id default** | Most tools default `user_id` to `"me"` for the authenticated user. Override only when acting on behalf of another user. |
| **Required fields** | `CREATE_OPPORTUNITY` requires `name`. Other create tools have no strict required fields but will create empty records without data. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Dynamics365-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `dynamics365` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `DYNAMICS365_DYNAMICSCRM_CREATE_LEAD` | Create a new lead record |
| `DYNAMICS365_DYNAMICSCRM_UPDATE_LEAD` | Update an existing lead |
| `DYNAMICS365_DYNAMICSCRM_GET_A_LEAD` | Retrieve a lead by GUID |
| `DYNAMICS365_DYNAMICSCRM_GET_ALL_LEADS` | List/filter all leads |
| `DYNAMICS365_DYNAMICSCRM_CREATE_ACCOUNT` | Create a new account |
| `DYNAMICS365_DYNAMICSCRM_CREATE_CONTACT` | Create a new contact |
| `DYNAMICS365_DYNAMICSCRM_CREATE_OPPORTUNITY` | Create a new opportunity |
| `DYNAMICS365_DYNAMICSCRM_UPDATE_OPPORTUNITY` | Update an existing opportunity |
| `DYNAMICS365_DYNAMICSCRM_CREATE_SALES_ORDER` | Create a new sales order |
| `DYNAMICS365_DYNAMICSCRM_UPDATE_SALES_ORDER` | Update an existing sales order |
| `DYNAMICS365_DYNAMICSCRM_CREATE_INVOICE` | Create a new invoice |
| `DYNAMICS365_DYNAMICSCRM_CREATE_CASE` | Create a support case/incident |
---
*Powered by [Composio](https://composio.dev)*

144
elevenlabs-automation/SKILL.md
View File

@@ -1,91 +1,131 @@
---
name: elevenlabs-automation
description: "Automate Elevenlabs tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: ElevenLabs Automation
description: "Automate ElevenLabs text-to-speech workflows -- generate speech from text, browse and inspect voices, check subscription limits, list models, stream audio, and retrieve history via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Elevenlabs Automation via Rube MCP
# ElevenLabs Automation
Automate Elevenlabs operations through Composio's Elevenlabs toolkit via Rube MCP.
Automate your ElevenLabs text-to-speech workflows -- convert text to natural speech, browse the voice library, inspect voice details, check subscription credits, select TTS models, stream audio for low-latency delivery, and retrieve previously generated audio from history.
**Toolkit docs**: [composio.dev/toolkits/elevenlabs](https://composio.dev/toolkits/elevenlabs)
**Toolkit docs:** [composio.dev/toolkits/elevenlabs](https://composio.dev/toolkits/elevenlabs)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Elevenlabs connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `elevenlabs`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your ElevenLabs account when prompted (API key authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `elevenlabs`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Generate Speech from Text
Use `ELEVENLABS_TEXT_TO_SPEECH` to convert text into a downloadable audio file.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Elevenlabs operations", known_fields: ""}]
session: {generate_id: true}
Tool: ELEVENLABS_TEXT_TO_SPEECH
Inputs:
- voice_id: string (required) -- obtain from ELEVENLABS_GET_VOICES
- text: string (required) -- max ~10,000 chars (most models), 30,000 (Flash/Turbo v2), 40,000 (v2.5)
- model_id: string (default "eleven_monolingual_v1") -- e.g., "eleven_multilingual_v2"
- output_format: string (default "mp3_44100_128") -- see formats below
- optimize_streaming_latency: integer (0-4; NOT supported with eleven_v3)
- seed: integer (optional, for reproducibility -- not guaranteed)
- pronunciation_dictionary_locators: array (optional, up to 3 dictionaries)
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Output formats:**
- MP3: `mp3_22050_32`, `mp3_44100_32`, `mp3_44100_64`, `mp3_44100_96`, `mp3_44100_128`, `mp3_44100_192` (Creator+)
- PCM: `pcm_16000`, `pcm_22050`, `pcm_24000`, `pcm_44100` (Pro+)
- uLaw: `ulaw_8000` (for Twilio)
## Core Workflow Pattern
**Important:** Output is a file object with a presigned download link at `data.file.s3url` (expires in ~1 hour). Download promptly.
### Step 1: Discover Available Tools
### 2. Browse Available Voices
Use `ELEVENLABS_GET_VOICES` to list all voices with their attributes and settings.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Elevenlabs task"}]
session: {id: "existing_session_id"}
Tool: ELEVENLABS_GET_VOICES
Inputs: (none)
```
### Step 2: Check Connection
Returns an array at `data.voices[]` with `voice_id`, `name`, `labels` (gender, accent, use_case), and settings.
### 3. Inspect a Specific Voice
Use `ELEVENLABS_GET_VOICE` to get detailed metadata for a candidate voice before synthesis.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["elevenlabs"]
session_id: "your_session_id"
Tool: ELEVENLABS_GET_VOICE
Inputs:
- voice_id: string (required) -- e.g., "21m00Tcm4TlvDq8ikWAM"
- with_settings: boolean (default false) -- include detailed voice settings
```
### Step 3: Execute Tools
### 4. Check Subscription and Credits
Use `ELEVENLABS_GET_USER_SUBSCRIPTION_INFO` to verify plan limits and remaining credits before bulk generation.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: ELEVENLABS_GET_USER_SUBSCRIPTION_INFO
Inputs: (none)
```
### 5. List Available TTS Models
Use `ELEVENLABS_GET_MODELS` to discover compatible models and filter by `can_do_text_to_speech: true`.
```
Tool: ELEVENLABS_GET_MODELS
Inputs: (none)
```
### 6. Stream Audio and Retrieve History
Use `ELEVENLABS_TEXT_TO_SPEECH_STREAM` for low-latency streamed delivery, and `ELEVENLABS_GET_AUDIO_FROM_HISTORY_ITEM` to re-download previously generated audio.
```
Tool: ELEVENLABS_TEXT_TO_SPEECH_STREAM
- Same core inputs as TEXT_TO_SPEECH but returns a stream for low-latency playback
Tool: ELEVENLABS_GET_AUDIO_FROM_HISTORY_ITEM
- history_item_id: string (required) -- ID from a previous generation
```
---
## 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
| Pitfall | Detail |
|---------|--------|
| Text length limits | Most models cap at ~10,000-20,000 chars per request. Oversized input returns HTTP 400. Split long text into chunks (~5000 chars) and generate per chunk. |
| Output is a presigned URL | `ELEVENLABS_TEXT_TO_SPEECH` returns `data.file.s3url` with a ~1 hour expiry (X-Amz-Expires=3600). Download the audio file promptly. |
| Quota and credit errors | HTTP 401 with `quota_exceeded` or HTTP 402 `payment_required` means insufficient credits or tier restrictions. Check with `ELEVENLABS_GET_USER_SUBSCRIPTION_INFO` before bulk jobs. |
| Voice permissions | HTTP 401 with `missing_permissions` means the API key lacks `voices_read` scope. Verify key permissions. |
| Model compatibility | Not all models support TTS. Use `ELEVENLABS_GET_MODELS` and filter by `can_do_text_to_speech: true`. The `optimize_streaming_latency` parameter is NOT supported with `eleven_v3`. |
| Large voice list truncation | `ELEVENLABS_GET_VOICES` may return a large list. Select from the full `data.voices[]` payload -- previews may appear truncated. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Elevenlabs-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `elevenlabs` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `ELEVENLABS_TEXT_TO_SPEECH` | Convert text to speech, returns downloadable audio file |
| `ELEVENLABS_GET_VOICES` | List all available voices with attributes |
| `ELEVENLABS_GET_VOICE` | Get detailed info for a specific voice |
| `ELEVENLABS_GET_USER_SUBSCRIPTION_INFO` | Check subscription plan and remaining credits |
| `ELEVENLABS_GET_MODELS` | List available TTS models and capabilities |
| `ELEVENLABS_TEXT_TO_SPEECH_STREAM` | Stream audio for low-latency delivery |
| `ELEVENLABS_GET_AUDIO_FROM_HISTORY_ITEM` | Re-download audio from generation history |
---
*Powered by [Composio](https://composio.dev)*

177
eventbrite-automation/SKILL.md
View File

@@ -1,91 +1,148 @@
---
name: eventbrite-automation
description: "Automate Eventbrite tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Eventbrite Automation
description: "Automate Eventbrite event management, attendee tracking, organization discovery, and category browsing through natural language commands"
requires:
mcp: [rube]
mcp:
- rube
---
# Eventbrite Automation via Rube MCP
# Eventbrite Automation
Automate Eventbrite operations through Composio's Eventbrite toolkit via Rube MCP.
Automate Eventbrite event management workflows -- list organization events, track attendees, browse categories and formats, and manage organizations -- all through natural language.
**Toolkit docs**: [composio.dev/toolkits/eventbrite](https://composio.dev/toolkits/eventbrite)
**Toolkit docs:** [composio.dev/toolkits/eventbrite](https://composio.dev/toolkits/eventbrite)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Eventbrite connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `eventbrite`
- 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. Add the Rube MCP server to your environment: `https://rube.app/mcp`
2. Connect your Eventbrite account when prompted (OAuth flow via Composio)
3. Start issuing natural language commands for Eventbrite automation
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `eventbrite`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Discover Your Organizations
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Eventbrite operations", known_fields: ""}]
session: {generate_id: true}
```
Retrieve the organizations the authenticated user belongs to. This is a prerequisite for most other Eventbrite operations since `organization_id` is required.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `EVENTBRITE_LIST_USER_ORGANIZATIONS`
## Core Workflow Pattern
No parameters required. Returns organization IDs, names, and metadata.
### Step 1: Discover Available Tools
> Always call this first to obtain the `organization_id` needed by event and attendee endpoints.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Eventbrite task"}]
session: {id: "existing_session_id"}
```
Example prompt:
> "List my Eventbrite organizations"
### Step 2: Check Connection
---
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["eventbrite"]
session_id: "your_session_id"
```
### 2. List and Search Organization Events
### Step 3: Execute Tools
Browse events owned by a specific organization with filtering by status, time period, and pagination.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Tool:** `EVENTBRITE_LIST_ORGANIZATION_EVENTS`
Key parameters:
- `organization_id` -- the organization whose events to list (required; get from `EVENTBRITE_LIST_USER_ORGANIZATIONS`)
- `status` -- filter by `live`, `draft`, `canceled`, `started`, `ended`, `completed`, or `all`
- `time_filter` -- filter by `current_future` or `past`
- `order_by` -- sort by `start_asc`, `start_desc`, `created_asc`, `created_desc`, `name_asc`, `name_desc`
- `page_size` -- number of events per page
- `continuation` -- pagination token from previous response
- `expand` -- comma-separated fields to expand: `organizer`, `venue`, `ticket_classes`
Example prompt:
> "Show me all live events for my organization, sorted by start date"
---
### 3. Track Event Attendees
Retrieve the attendee list for any event, with optional status filtering and pagination.
**Tool:** `EVENTBRITE_LIST_EVENT_ATTENDEES`
Key parameters:
- `event_id` -- the event to retrieve attendees for (required)
- `status` -- filter by `attending`, `not_attending`, or `cancelled`
- `changed_since` -- ISO 8601 timestamp to get only recently changed attendees
- `continuation` -- pagination token for subsequent pages
Example prompt:
> "Get all attending attendees for event 123456789 who changed since January 1st"
---
### 4. Browse Event Categories
Retrieve available event categories for use when creating or filtering events.
**Tool:** `EVENTBRITE_GET_EVENT_CATEGORIES`
Key parameters:
- `locale` -- BCP-47 locale for localized names (e.g., `en_US`, `es_ES`)
Follow up with `EVENTBRITE_GET_EVENT_SUBCATEGORIES` to get subcategories within a selected category.
Example prompt:
> "List all Eventbrite event categories in English"
---
### 5. List Event Formats
Retrieve all available event format types (conference, seminar, workshop, etc.).
**Tool:** `EVENTBRITE_GET_EVENT_FORMATS`
No parameters required. Returns format IDs and display names.
Example prompt:
> "What event formats are available on Eventbrite?"
---
### 6. Browse Event Subcategories
Retrieve subcategories for more granular event classification.
**Tool:** `EVENTBRITE_GET_EVENT_SUBCATEGORIES`
Key parameters:
- `locale` -- BCP-47 locale for localized names (e.g., `en_US`)
Example prompt:
> "List all Eventbrite event subcategories"
---
## 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
| Pitfall | Details |
|---------|---------|
| Organization ID required | Most event operations require `organization_id` -- always call `EVENTBRITE_LIST_USER_ORGANIZATIONS` first |
| Pagination via continuation | Results use continuation-token pagination, not page numbers -- pass the `continuation` value from the previous response to get the next page |
| Event ID discovery | You need to list events first via `EVENTBRITE_LIST_ORGANIZATION_EVENTS` to get `event_id` values for attendee queries |
| Status values are specific | Event status values (`live`, `draft`, `canceled`, `started`, `ended`, `completed`) must match exactly |
| Expand fields are comma-separated | The `expand` parameter takes a comma-separated string, not an array (e.g., `"organizer,venue"`) |
| changed_since format | The `changed_since` parameter must be in ISO 8601 format (e.g., `2024-01-01T00:00:00Z`) |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Eventbrite-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `eventbrite` |
| 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` |
| Action | Tool Slug | Key Params |
|--------|-----------|------------|
| List organizations | `EVENTBRITE_LIST_USER_ORGANIZATIONS` | (none) |
| List events | `EVENTBRITE_LIST_ORGANIZATION_EVENTS` | `organization_id`, `status`, `time_filter` |
| List attendees | `EVENTBRITE_LIST_EVENT_ATTENDEES` | `event_id`, `status`, `changed_since` |
| Get categories | `EVENTBRITE_GET_EVENT_CATEGORIES` | `locale` |
| Get subcategories | `EVENTBRITE_GET_EVENT_SUBCATEGORIES` | `locale` |
| Get formats | `EVENTBRITE_GET_EVENT_FORMATS` | (none) |
---
*Powered by [Composio](https://composio.dev)*

214
excel-automation/SKILL.md
View File

@@ -1,91 +1,203 @@
---
name: excel-automation
description: "Automate Excel tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Excel Automation
description: "Excel Automation: create workbooks, manage worksheets, read/write cell data, and format spreadsheets via Microsoft Excel and Google Sheets integration"
requires:
mcp: [rube]
---
# Excel Automation via Rube MCP
# Excel Automation
Automate Excel operations through Composio's Excel toolkit via Rube MCP.
Automate spreadsheet operations including creating workbooks, writing data, formatting cells, upserting rows, and managing worksheets. Works with Microsoft Excel (OneDrive) and Google Sheets.
**Toolkit docs**: [composio.dev/toolkits/excel](https://composio.dev/toolkits/excel)
**Toolkit docs:** [composio.dev/toolkits/excel](https://composio.dev/toolkits/excel)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Excel connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `excel`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `excel`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure an active connection exists for the `excel` (and optionally `googlesheets`) toolkit. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
---
Always discover available tools before executing workflows:
## Core Workflows
### 1. Create a New Excel Workbook
Use `EXCEL_CREATE_WORKBOOK` to generate a new `.xlsx` file and upload it to OneDrive.
**Tool:** `EXCEL_CREATE_WORKBOOK`
**Steps:**
1. Call `EXCEL_CREATE_WORKBOOK` with worksheet names and data
2. The tool creates a `.xlsx` file and uploads it to OneDrive
3. Use the returned file path/URL for subsequent operations
---
### 2. Write Data to a Spreadsheet
Use `GOOGLESHEETS_BATCH_UPDATE` to write values to a specific range or append rows.
**Tool:** `GOOGLESHEETS_BATCH_UPDATE`
**Key Parameters:**
- `spreadsheet_id` (required) -- The spreadsheet ID from the URL (44-char alphanumeric string)
- `sheet_name` (required) -- Tab name, e.g., `"Sheet1"`, `"Sales Data"`
- `values` (required) -- 2D array of cell values, e.g., `[["Name","Amount"],["Alice",100]]`
- `first_cell_location` -- Starting cell in A1 notation (e.g., `"A1"`, `"D3"`). Omit to append rows
- `valueInputOption` -- `"USER_ENTERED"` (default, parses formulas) or `"RAW"` (stores as-is)
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Excel operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLESHEETS_BATCH_UPDATE
Arguments:
spreadsheet_id: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
sheet_name: "Sheet1"
values: [["Item","Cost","Stocked"],["Wheel",20.50,true],["Screw",0.50,true]]
first_cell_location: "A1"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
---
## Core Workflow Pattern
### 3. Upsert Rows by Key Column
### Step 1: Discover Available Tools
Use `GOOGLESHEETS_UPSERT_ROWS` to update existing rows by matching a key column, or append new rows if no match is found. Ideal for CRM syncs, inventory updates, and deduplication.
**Tool:** `GOOGLESHEETS_UPSERT_ROWS`
**Key Parameters:**
- `spreadsheetId` (required) -- The spreadsheet ID
- `sheetName` (required) -- Tab name
- `rows` (required) -- 2D array of data rows (min 1 row). If `headers` is omitted, the first row is treated as headers
- `headers` -- Column names for the data, e.g., `["Email","Phone","Status"]`
- `keyColumn` -- Column header to match on, e.g., `"Email"`, `"SKU"`, `"Lead ID"`
- `strictMode` -- `true` (default) errors on mismatched columns; `false` truncates silently
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Excel task"}]
session: {id: "existing_session_id"}
Tool: GOOGLESHEETS_UPSERT_ROWS
Arguments:
spreadsheetId: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
sheetName: "Contacts"
keyColumn: "Email"
headers: ["Email","Phone","Status"]
rows: [["john@example.com","555-0101","Active"],["jane@example.com","555-0102","Pending"]]
```
### Step 2: Check Connection
---
### 4. Format Cells
Use `GOOGLESHEETS_FORMAT_CELL` to apply bold, italic, font size, and background colors to ranges.
**Tool:** `GOOGLESHEETS_FORMAT_CELL`
**Key Parameters:**
- `spreadsheet_id` (required) -- The spreadsheet ID
- `range` -- Cell range in A1 notation, e.g., `"A1:D1"`, `"B2:B10"` (recommended over index-based)
- `sheet_name` -- Worksheet name, e.g., `"Sheet1"`
- `bold` -- `true`/`false`
- `italic` -- `true`/`false`
- `fontSize` -- Font size in points, e.g., `12`
- `red`, `green`, `blue` -- Background color components (0.0--1.0 float scale, NOT 0--255)
**Example (bold header row with blue background):**
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["excel"]
session_id: "your_session_id"
Tool: GOOGLESHEETS_FORMAT_CELL
Arguments:
spreadsheet_id: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
range: "A1:D1"
sheet_name: "Sheet1"
bold: true
fontSize: 12
red: 0.2
green: 0.4
blue: 0.9
```
### Step 3: Execute Tools
---
### 5. Add New Worksheet Tabs
Use `GOOGLESHEETS_ADD_SHEET` to create new tabs within an existing spreadsheet.
**Tool:** `GOOGLESHEETS_ADD_SHEET`
**Key Parameters:**
- `spreadsheetId` (required) -- The spreadsheet ID
- `title` -- Name for the new tab, e.g., `"Q4 Report"`
- `forceUnique` -- `true` (default) auto-appends suffix if name exists
**Example:**
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: GOOGLESHEETS_ADD_SHEET
Arguments:
spreadsheetId: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
title: "Q4 Report"
forceUnique: true
```
---
### 6. Read Data and Verify Content
Use `GOOGLESHEETS_BATCH_GET` to retrieve data from specified cell ranges for validation or further processing.
**Tool:** `GOOGLESHEETS_BATCH_GET`
**Steps:**
1. Call `GOOGLESHEETS_BATCH_GET` with the spreadsheet ID and target ranges
2. Validate headers and data alignment
3. Use results to inform subsequent write or update operations
**Supporting Tools:**
- `GOOGLESHEETS_GET_SHEET_NAMES` -- List all tab names in a spreadsheet
- `GOOGLESHEETS_GET_SPREADSHEET_INFO` -- Get metadata (sheet IDs, properties)
- `GOOGLESHEETS_FIND_WORKSHEET_BY_TITLE` -- Check if a specific tab exists
---
## Recommended Execution Plan
1. **Create or locate the spreadsheet** using `GOOGLESHEETS_CREATE_GOOGLE_SHEET1` or reuse an existing `spreadsheetId`
2. **Confirm the destination tab** using `GOOGLESHEETS_GET_SHEET_NAMES` or `GOOGLESHEETS_FIND_WORKSHEET_BY_TITLE`; create it with `GOOGLESHEETS_ADD_SHEET` if missing
3. **Read existing headers** (optional) using `GOOGLESHEETS_BATCH_GET` to align columns
4. **Write or upsert data** using `GOOGLESHEETS_BATCH_UPDATE` or `GOOGLESHEETS_UPSERT_ROWS`
5. **Apply formatting** (optional) using `GOOGLESHEETS_FORMAT_CELL`
6. **Verify results** (optional) using `GOOGLESHEETS_BATCH_GET`
7. **Fallback:** If Google Sheets creation is blocked (HTTP 403), use `EXCEL_CREATE_WORKBOOK` for local `.xlsx` output
---
## 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
| Pitfall | Detail |
|---------|--------|
| **HTTP 403 on sheet creation** | `GOOGLESHEETS_CREATE_GOOGLE_SHEET1` fails when Drive create scope is missing. Reuse an existing `spreadsheetId` or fall back to `EXCEL_CREATE_WORKBOOK`. |
| **Cell limit and rate throttling** | Google Sheets has a ~5,000,000 cell limit per spreadsheet. Excessive write frequency triggers HTTP 429. Batch changes and chunk large writes (~500 rows/call). |
| **Format range off-by-one** | `GOOGLESHEETS_FORMAT_CELL` uses 0-based, endIndex-exclusive ranges when using index mode. Background color uses 0--1 float RGB, NOT 0--255 integer RGB. |
| **Sheet title uniqueness** | Sheet titles are not guaranteed unique across API responses. Prefer operating by numeric `sheetId` and verify the resolved tab before writing. |
| **Upsert payload shape** | `GOOGLESHEETS_UPSERT_ROWS` requires headers + 2D rows array. Sending list-of-dicts or empty `rows` causes validation errors. Ensure at least 1 data row. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Excel-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `excel` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `EXCEL_CREATE_WORKBOOK` | Create a new `.xlsx` workbook and upload to OneDrive |
| `GOOGLESHEETS_BATCH_UPDATE` | Write values to a range or append new rows |
| `GOOGLESHEETS_UPSERT_ROWS` | Update existing rows by key or append new ones |
| `GOOGLESHEETS_FORMAT_CELL` | Apply text/background formatting to cell ranges |
| `GOOGLESHEETS_ADD_SHEET` | Add a new worksheet tab to a spreadsheet |
| `GOOGLESHEETS_CREATE_GOOGLE_SHEET1` | Create a new Google Spreadsheet in Drive |
| `GOOGLESHEETS_GET_SHEET_NAMES` | List all worksheet names in a spreadsheet |
| `GOOGLESHEETS_GET_SPREADSHEET_INFO` | Retrieve spreadsheet metadata |
| `GOOGLESHEETS_FIND_WORKSHEET_BY_TITLE` | Check if a worksheet exists by title |
| `GOOGLESHEETS_BATCH_GET` | Read data from specified cell ranges |
---
*Powered by [Composio](https://composio.dev)*

193
facebook-automation/SKILL.md
View File

@@ -1,91 +1,164 @@
---
name: facebook-automation
description: "Automate Facebook tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Facebook Automation
description: "Automate Facebook Page management including post creation, scheduling, video uploads, Messenger conversations, and audience engagement via Composio"
requires:
mcp: [rube]
mcp:
- rube
---
# Facebook Automation via Rube MCP
# Facebook Automation
Automate Facebook operations through Composio's Facebook toolkit via Rube MCP.
Automate Facebook Page operations -- create and schedule posts, upload videos, manage Messenger conversations, retrieve page insights, and handle scheduled content -- all orchestrated through the Composio MCP integration.
**Toolkit docs**: [composio.dev/toolkits/facebook](https://composio.dev/toolkits/facebook)
**Toolkit docs:** [composio.dev/toolkits/facebook](https://composio.dev/toolkits/facebook)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Facebook connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `facebook`
- 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. Connect your Facebook account through the Composio MCP server at `https://rube.app/mcp`
2. The agent will prompt you with an authentication link if no active connection exists
3. Once connected, all `FACEBOOK_*` tools become available for execution
4. **Note:** This toolkit supports Facebook Pages only, not personal Facebook accounts
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `facebook`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Discover Managed Pages
List all Facebook Pages you manage to get page IDs and access tokens for subsequent operations.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Facebook operations", known_fields: ""}]
session: {generate_id: true}
```
**Tool:** `FACEBOOK_LIST_MANAGED_PAGES`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `fields` | string | No | Comma-separated fields (default: `id,name,access_token,category,tasks,about,link,picture`) |
| `limit` | integer | No | Max pages per request (default: 25) |
| `user_id` | string | No | User ID (default: `me`) |
## Core Workflow Pattern
**Always run this first** to cache `page_id` values. Avoid repeating discovery calls -- cache the results.
### Step 1: Discover Available Tools
---
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Facebook task"}]
session: {id: "existing_session_id"}
```
### 2. Create & Schedule Posts
Publish or schedule text posts with optional links on a Facebook Page.
### Step 2: Check Connection
**Tool:** `FACEBOOK_CREATE_POST`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["facebook"]
session_id: "your_session_id"
```
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `page_id` | string | Yes | Numeric Page ID from managed pages |
| `message` | string | Yes | Text content of the post |
| `published` | boolean | No | `true` to publish immediately, `false` for draft/scheduled (default: true) |
| `scheduled_publish_time` | integer | No | Unix UTC timestamp; must be at least 10 minutes in the future |
| `link` | string | No | URL to include in the post |
| `targeting` | object | No | Audience targeting specifications |
### Step 3: Execute Tools
**When scheduling:** Set `published=false` and provide `scheduled_publish_time` as a Unix UTC timestamp.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
---
### 3. Create & Schedule Video Posts
Upload and schedule video content on a Facebook Page.
**Tool:** `FACEBOOK_CREATE_VIDEO_POST`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `page_id` | string | Yes | Numeric Page ID |
| `file_url` | string | Conditional | URL of the video file (provide `file_url` or `video`) |
| `video` | object | Conditional | Local file upload with `name`, `mimetype`, `s3key` |
| `title` | string | No | Video title |
| `description` | string | No | Video description |
| `published` | boolean | No | Publish immediately (default: true) |
| `scheduled_publish_time` | integer | No | Unix timestamp for scheduled publishing |
---
### 4. Manage Scheduled Posts
Review, reschedule, update, or publish scheduled content.
**Tools:**
- **`FACEBOOK_GET_SCHEDULED_POSTS`** -- List scheduled/unpublished posts for a page
- `page_id` (required), `fields`, `limit` (max 100)
- **`FACEBOOK_RESCHEDULE_POST`** -- Change the scheduled publish time
- **`FACEBOOK_UPDATE_POST`** -- Edit caption/text on an existing post
- **`FACEBOOK_PUBLISH_SCHEDULED_POST`** -- Publish a scheduled post immediately
---
### 5. Read Page Messenger Conversations
Retrieve inbox conversations and message threads between users and your Page.
**Tool:** `FACEBOOK_GET_PAGE_CONVERSATIONS`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `page_id` | string | Yes | The Facebook Page ID |
| `fields` | string | No | Fields to return (default: `participants,updated_time,id`) |
| `limit` | integer | No | Conversations to return, max 25 |
Then retrieve full message threads:
**Tool:** `FACEBOOK_GET_CONVERSATION_MESSAGES`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `page_id` | string | Yes | Page ID that owns the conversation |
| `conversation_id` | string | Yes | Conversation ID in `t_` format (e.g., `t_3638640842939952`) |
| `fields` | string | No | Default: `id,created_time,from,to,message` |
| `limit` | integer | No | Messages to return, max 25 |
---
### 6. Send Messages & Mark as Seen
Respond to users via Messenger and mark messages as read.
**Tools:**
- **`FACEBOOK_SEND_MESSAGE`** -- Send a text message from the Page to a user via Messenger
- **`FACEBOOK_MARK_MESSAGE_SEEN`** -- Mark a user's message as seen by the Page
**Warning:** Both tools cause user-visible side effects. Only call after explicit confirmation.
---
## 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
| Pitfall | Details |
|---------|---------|
| **Scheduling too close to now** | `FACEBOOK_CREATE_POST` with `scheduled_publish_time` less than ~10 minutes in the future returns HTTP 400 -- enforce a larger buffer for bulk runs |
| **Unix UTC timestamps required** | `scheduled_publish_time` must be Unix UTC -- timezone conversion mistakes cause off-by-hours scheduling or validation failures |
| **Cursor-based pagination** | `FACEBOOK_GET_SCHEDULED_POSTS` and `FACEBOOK_GET_PAGE_CONVERSATIONS` return subsets -- follow paging cursors to get complete data |
| **Large conversation payloads** | Requesting embedded messages in conversations creates huge payloads -- use `FACEBOOK_GET_CONVERSATION_MESSAGES` for full threads instead |
| **Video processing delays** | Uploaded videos may remain in processing state -- only schedule via `FACEBOOK_CREATE_VIDEO_POST` after the upload is usable |
| **Cache page IDs** | Repeating `FACEBOOK_LIST_MANAGED_PAGES` calls adds latency -- cache `page_id` per workspace/run |
| **Pages only** | This toolkit does not support personal Facebook accounts -- only Facebook Pages |
| **Write operations need confirmation** | `FACEBOOK_SEND_MESSAGE` and `FACEBOOK_MARK_MESSAGE_SEEN` cause user-visible side effects -- only call after explicit user confirmation |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Facebook-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `facebook` |
| 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` |
| Tool Slug | Purpose |
|-----------|---------|
| `FACEBOOK_LIST_MANAGED_PAGES` | List Pages you manage with access tokens |
| `FACEBOOK_GET_PAGE_DETAILS` | Get detailed info about a specific Page |
| `FACEBOOK_CREATE_POST` | Create or schedule a text/link post |
| `FACEBOOK_CREATE_VIDEO_POST` | Create or schedule a video post |
| `FACEBOOK_GET_SCHEDULED_POSTS` | List scheduled/unpublished posts |
| `FACEBOOK_RESCHEDULE_POST` | Change scheduled publish time |
| `FACEBOOK_UPDATE_POST` | Edit an existing post |
| `FACEBOOK_PUBLISH_SCHEDULED_POST` | Publish a scheduled post immediately |
| `FACEBOOK_UPLOAD_VIDEO` | Upload a video file to a Page |
| `FACEBOOK_GET_PAGE_CONVERSATIONS` | List Messenger inbox conversations |
| `FACEBOOK_GET_CONVERSATION_MESSAGES` | Retrieve messages from a conversation |
| `FACEBOOK_SEND_MESSAGE` | Send a Messenger message from the Page |
| `FACEBOOK_MARK_MESSAGE_SEEN` | Mark a message as seen |
| `FACEBOOK_GET_PAGE_POSTS` | Retrieve posts from a Page feed |
| `FACEBOOK_GET_USER_PAGES` | List Pages with tasks and tokens |
---
*Powered by [Composio](https://composio.dev)*

206
firecrawl-automation/SKILL.md
View File

@@ -1,91 +1,177 @@
---
name: firecrawl-automation
description: "Automate Firecrawl tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Firecrawl Automation
description: "Automate web crawling and data extraction with Firecrawl -- scrape pages, crawl sites, extract structured data, batch scrape URLs, and map website structures through the Composio Firecrawl integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Firecrawl Automation via Rube MCP
# Firecrawl Automation
Automate Firecrawl operations through Composio's Firecrawl toolkit via Rube MCP.
Run **Firecrawl** web crawling and extraction directly from Claude Code. Scrape individual pages, crawl entire sites, extract structured data with AI, batch process URL lists, and map website structures without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/firecrawl](https://composio.dev/toolkits/firecrawl)
**Toolkit docs:** [composio.dev/toolkits/firecrawl](https://composio.dev/toolkits/firecrawl)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Firecrawl connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `firecrawl`
- 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. Add the Composio MCP server to your configuration:
```
https://rube.app/mcp
```
2. Connect your Firecrawl account when prompted. The agent will provide an authentication link.
3. Be mindful of credit consumption -- scope your crawls tightly and test on small URL sets before scaling.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `firecrawl`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Scrape a Single Page
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Firecrawl operations", known_fields: ""}]
session: {generate_id: true}
```
Fetch content from a URL in multiple formats with optional browser actions for dynamic pages.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `FIRECRAWL_SCRAPE`
## Core Workflow Pattern
Key parameters:
- `url` (required) -- fully qualified URL to scrape
- `formats` -- output formats: `markdown` (default), `html`, `rawHtml`, `links`, `screenshot`, `json`
- `onlyMainContent` (default true) -- extract main content only, excluding nav/footer/ads
- `waitFor` -- milliseconds to wait for JS rendering (default 0)
- `timeout` -- max wait in ms (default 30000)
- `actions` -- browser actions before scraping (click, write, wait, press, scroll)
- `includeTags` / `excludeTags` -- filter by HTML tags
- `jsonOptions` -- for structured extraction with `schema` and/or `prompt`
### Step 1: Discover Available Tools
Example prompt: *"Scrape the main content from https://example.com/pricing as markdown"*
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Firecrawl task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Crawl an Entire Site
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["firecrawl"]
session_id: "your_session_id"
```
Discover and scrape multiple pages from a website with configurable depth, path filters, and concurrency.
### Step 3: Execute Tools
**Tool:** `FIRECRAWL_CRAWL_V2`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
Key parameters:
- `url` (required) -- starting URL for the crawl
- `limit` (default 10) -- max pages to crawl
- `maxDiscoveryDepth` -- depth limit from the root page
- `includePaths` / `excludePaths` -- regex patterns for URL paths
- `allowSubdomains` -- include subdomains (default false)
- `crawlEntireDomain` -- follow sibling/parent links, not just children (default false)
- `sitemap` -- `include` (default), `skip`, or `only`
- `prompt` -- natural language to auto-configure crawler settings
- `scrapeOptions_formats` -- output format for each page
- `scrapeOptions_onlyMainContent` -- main content extraction per page
Example prompt: *"Crawl the docs section of firecrawl.dev, max 50 pages, only paths matching docs"*
---
### 3. Extract Structured Data
Extract structured JSON data from web pages using AI with a natural language prompt or JSON schema.
**Tool:** `FIRECRAWL_EXTRACT`
Key parameters:
- `urls` (required) -- array of URLs to extract from (max 10 in beta). Supports wildcards like `https://example.com/blog/*`
- `prompt` -- natural language description of what to extract
- `schema` -- JSON Schema defining the desired output structure
- `enable_web_search` -- allow crawling links outside initial domains (default false)
At least one of `prompt` or `schema` must be provided.
Check extraction status with `FIRECRAWL_EXTRACT_GET` using the returned job `id`.
Example prompt: *"Extract company name, pricing tiers, and feature lists from https://example.com/pricing"*
---
### 4. Batch Scrape Multiple URLs
Scrape many URLs concurrently with shared configuration for efficient bulk data collection.
**Tool:** `FIRECRAWL_BATCH_SCRAPE`
Key parameters:
- `urls` (required) -- array of URLs to scrape
- `formats` -- output format for all pages (default `markdown`)
- `onlyMainContent` (default true) -- main content extraction
- `maxConcurrency` -- parallel scrape limit
- `ignoreInvalidURLs` (default true) -- skip bad URLs instead of failing the batch
- `location` -- geolocation settings with `country` code
- `actions` -- browser actions applied to each page
- `blockAds` (default true) -- block advertisements
Example prompt: *"Batch scrape these 20 product page URLs as markdown with ad blocking"*
---
### 5. Map Website Structure
Discover all URLs on a website from a starting URL, useful for planning crawls or auditing site structure.
**Tool:** `FIRECRAWL_MAP_MULTIPLE_URLS_BASED_ON_OPTIONS`
Key parameters:
- `url` (required) -- starting URL (must be `https://` or `http://`)
- `search` -- guide URL discovery toward specific page types
- `limit` (default 5000, max 100000) -- max URLs to return
- `includeSubdomains` (default true) -- include subdomains
- `ignoreQueryParameters` (default true) -- dedupe URLs differing only by query params
- `sitemap` -- `include`, `skip`, or `only`
Example prompt: *"Map all URLs on docs.example.com, focusing on API reference pages"*
---
### 6. Monitor and Manage Crawl Jobs
Track crawl progress, retrieve results, and cancel runaway jobs.
**Tools:** `FIRECRAWL_CRAWL_GET`, `FIRECRAWL_GET_THE_STATUS_OF_A_CRAWL_JOB`, `FIRECRAWL_CANCEL_A_CRAWL_JOB`
- `FIRECRAWL_CRAWL_GET` -- get status, progress, credits used, and crawled page data
- `FIRECRAWL_CANCEL_A_CRAWL_JOB` -- stop an active or queued crawl
Both require the crawl job `id` (UUID) returned when the crawl was initiated.
Example prompt: *"Check the status of crawl job 019b0806-b7a1-7652-94c1-e865b5d2e89a"*
---
## 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
- **Rate limiting:** Firecrawl can trigger "Rate limit exceeded" errors (429). Prefer `FIRECRAWL_BATCH_SCRAPE` over many individual `FIRECRAWL_SCRAPE` calls, and implement backoff on 429/5xx responses.
- **Credit consumption:** `FIRECRAWL_EXTRACT` can fail with "Insufficient credits." Scope tightly and avoid broad homepage URLs that yield sparse fields. Test on small URL sets first.
- **Nested error responses:** Per-page failures may be nested in `response.data.code` (e.g., `SCRAPE_DNS_RESOLUTION_ERROR`) even when the outer API call succeeds. Always validate inner status/error fields.
- **JS-heavy pages:** Non-rendered fetches may miss key content. Use `waitFor` (e.g., 1000-5000ms) for dynamic pages, or configure `scrapeOptions_actions` to interact with the page before scraping.
- **Extraction schema precision:** Vague or shifting schemas/prompts produce noisy, inconsistent output. Freeze your schema and test on a small sample before scaling to many URLs.
- **Crawl jobs are async:** `FIRECRAWL_CRAWL_V2` returns immediately with a job ID. Use `FIRECRAWL_CRAWL_GET` to poll for results. Cancel stuck crawls with `FIRECRAWL_CANCEL_A_CRAWL_JOB` to avoid wasting credits.
- **Extract job polling:** `FIRECRAWL_EXTRACT` is also async for larger jobs. Retrieve final output with `FIRECRAWL_EXTRACT_GET`.
- **URL batching for extract:** Keep extract URL batches small (~10 URLs) to avoid 429 rate limit errors.
- **Deeply nested responses:** Results are often nested under `data.data` or deeper. Inspect the returned shape rather than assuming flat keys.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Firecrawl-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `firecrawl` |
| 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` |
| Tool Slug | Description |
|---|---|
| `FIRECRAWL_SCRAPE` | Scrape a single URL with format/action options |
| `FIRECRAWL_CRAWL_V2` | Crawl a website with depth/path control |
| `FIRECRAWL_EXTRACT` | Extract structured data with AI prompt/schema |
| `FIRECRAWL_BATCH_SCRAPE` | Batch scrape multiple URLs concurrently |
| `FIRECRAWL_MAP_MULTIPLE_URLS_BASED_ON_OPTIONS` | Discover/map all URLs on a site |
| `FIRECRAWL_CRAWL_GET` | Get crawl job status and results |
| `FIRECRAWL_GET_THE_STATUS_OF_A_CRAWL_JOB` | Check crawl job progress |
| `FIRECRAWL_CANCEL_A_CRAWL_JOB` | Cancel an active crawl job |
| `FIRECRAWL_EXTRACT_GET` | Get extraction job status and results |
| `FIRECRAWL_CRAWL_PARAMS_PREVIEW` | Preview crawl parameters before starting |
| `FIRECRAWL_SEARCH` | Web search + scrape top results |
---
*Powered by [Composio](https://composio.dev)*

155
freshbooks-automation/SKILL.md
View File

@@ -1,91 +1,140 @@
---
name: freshbooks-automation
description: "Automate Freshbooks tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: FreshBooks Automation
description: "FreshBooks Automation: manage businesses, projects, time tracking, and billing in FreshBooks cloud accounting"
requires:
mcp: [rube]
---
# Freshbooks Automation via Rube MCP
# FreshBooks Automation
Automate Freshbooks operations through Composio's Freshbooks toolkit via Rube MCP.
Automate FreshBooks operations including listing businesses, managing projects, tracking time, and monitoring budgets for small and medium-sized business accounting.
**Toolkit docs**: [composio.dev/toolkits/freshbooks](https://composio.dev/toolkits/freshbooks)
**Toolkit docs:** [composio.dev/toolkits/freshbooks](https://composio.dev/toolkits/freshbooks)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Freshbooks connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `freshbooks`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `freshbooks`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure an active connection exists for the `freshbooks` toolkit. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
---
Always discover available tools before executing workflows:
## Core Workflows
### 1. List Businesses
Retrieve all businesses associated with the authenticated user. The `business_id` from this response is required for most other FreshBooks API calls.
**Tool:** `FRESHBOOKS_LIST_BUSINESSES`
**Parameters:** None required.
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Freshbooks operations", known_fields: ""}]
session: {generate_id: true}
Tool: FRESHBOOKS_LIST_BUSINESSES
Arguments: {}
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Output:** Returns business membership information including all businesses the user has access to, along with their role in each business.
## Core Workflow Pattern
> **Important:** Always call this first to obtain a valid `business_id` before performing project-specific operations.
### Step 1: Discover Available Tools
---
### 2. List and Filter Projects
Retrieve all projects for a business with comprehensive filtering and sorting options.
**Tool:** `FRESHBOOKS_LIST_PROJECTS`
**Key Parameters:**
- `business_id` (required) -- Business ID obtained from `FRESHBOOKS_LIST_BUSINESSES`
- `active` -- Filter by active status: `true` (active only), `false` (inactive only), omit for all
- `complete` -- Filter by completion: `true` (completed), `false` (incomplete), omit for all
- `sort_by` -- Sort order: `"created_at"`, `"due_date"`, or `"title"`
- `updated_since` -- UTC datetime in RFC3339 format, e.g., `"2026-01-01T00:00:00Z"`
- `include_logged_duration` -- `true` to include total logged time (in seconds) per project
- `skip_group` -- `true` to omit team member/invitation data (reduces response size)
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Freshbooks task"}]
session: {id: "existing_session_id"}
Tool: FRESHBOOKS_LIST_PROJECTS
Arguments:
business_id: 123456
active: true
complete: false
sort_by: "due_date"
include_logged_duration: true
```
### Step 2: Check Connection
**Use Cases:**
- Get all projects for time tracking or invoicing
- Find projects by client, status, or date range
- Monitor project completion and budget tracking
- Retrieve team assignments and project groups
---
### 3. Monitor Active Projects
Track project progress and budgets by filtering for active, incomplete projects.
**Steps:**
1. Call `FRESHBOOKS_LIST_BUSINESSES` to get `business_id`
2. Call `FRESHBOOKS_LIST_PROJECTS` with `active: true`, `complete: false`, `include_logged_duration: true`
3. Analyze logged duration vs. budget for each project
---
### 4. Review Recently Updated Projects
Check for recent project activity using the `updated_since` filter.
**Steps:**
1. Call `FRESHBOOKS_LIST_BUSINESSES` to get `business_id`
2. Call `FRESHBOOKS_LIST_PROJECTS` with `updated_since` set to your cutoff datetime
3. Review returned projects for recent changes
**Example:**
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["freshbooks"]
session_id: "your_session_id"
Tool: FRESHBOOKS_LIST_PROJECTS
Arguments:
business_id: 123456
updated_since: "2026-02-01T00:00:00Z"
sort_by: "created_at"
```
### 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"
```
## Recommended Execution Plan
1. **Get the business ID** by calling `FRESHBOOKS_LIST_BUSINESSES`
2. **List projects** using `FRESHBOOKS_LIST_PROJECTS` with the obtained `business_id`
3. **Filter as needed** using `active`, `complete`, `updated_since`, and `sort_by` parameters
---
## 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
| Pitfall | Detail |
|---------|--------|
| **business_id required** | Most FreshBooks operations require a `business_id`. Always call `FRESHBOOKS_LIST_BUSINESSES` first to obtain it. |
| **Date format** | The `updated_since` parameter must be in RFC3339 format: `"2026-01-01T00:00:00Z"`. Other formats will fail. |
| **Paginated results** | Project list responses are paginated. Check for additional pages in the response. |
| **Empty results** | Returns an empty list if no projects exist or match the applied filters. This is not an error. |
| **Logged duration units** | When `include_logged_duration` is true, the duration is returned in seconds. Convert to hours (divide by 3600) for display. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Freshbooks-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `freshbooks` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `FRESHBOOKS_LIST_BUSINESSES` | List all businesses for the authenticated user |
| `FRESHBOOKS_LIST_PROJECTS` | List projects with filtering and sorting for a business |
---
*Powered by [Composio](https://composio.dev)*

201
gong-automation/SKILL.md
View File

@@ -1,91 +1,172 @@
---
name: gong-automation
description: "Automate Gong tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Gong Automation
description: "Automate Gong conversation intelligence -- retrieve call recordings, transcripts, detailed analytics, speaker stats, and workspace data -- using natural language through the Composio MCP integration."
category: conversation-intelligence
requires:
mcp: [rube]
mcp:
- rube
---
# Gong Automation via Rube MCP
# Gong Automation
Automate Gong operations through Composio's Gong toolkit via Rube MCP.
Unlock insights from your sales calls -- retrieve transcripts, analyze call data by date range, access detailed conversation analytics with topics and trackers, and manage workspaces -- all through natural language commands.
**Toolkit docs**: [composio.dev/toolkits/gong](https://composio.dev/toolkits/gong)
**Toolkit docs:** [composio.dev/toolkits/gong](https://composio.dev/toolkits/gong)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Gong connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `gong`
- 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. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Connect your Gong account when prompted (OAuth / Bearer token authentication).
3. Start issuing natural language commands to analyze your call data.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `gong`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Retrieve Call Transcripts by Date Range
Get transcripts for all calls within a specified time period, with optional filtering by specific call IDs or workspace.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Gong operations", known_fields: ""}]
session: {generate_id: true}
```
**Tool:** `GONG_RETRIEVE_TRANSCRIPTS_OF_CALLS_V2_CALLS_TRANSCRIPT`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Example prompt:**
> "Get Gong transcripts for all calls from February 1-10, 2025"
## Core Workflow Pattern
**Key parameters:**
- `filter__fromDateTime` -- ISO-8601 start date (e.g., `2025-02-01T00:00:00Z`)
- `filter__toDateTime` -- ISO-8601 end date (e.g., `2025-02-10T23:59:59Z`)
- `filter__callIds` -- Optional array of specific call IDs to filter
- `filter__workspaceId` -- Optional workspace ID filter
- `cursor` -- Pagination cursor from previous response
### Step 1: Discover Available Tools
**Required scope:** `api:calls:read:transcript`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Gong task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Get Transcript for Specific Calls
Retrieve transcripts with speaker information, timestamps, and topic categorization using a filter object.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["gong"]
session_id: "your_session_id"
```
**Tool:** `GONG_GET_CALL_TRANSCRIPT`
### Step 3: Execute Tools
**Example prompt:**
> "Get the Gong transcript for call ID 555785916001072125"
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Key parameters (filter required):**
- `filter.callIds` -- Array of specific call IDs (e.g., `["555785916001072125"]`)
- `filter.fromDateTime` -- ISO-8601 start date
- `filter.toDateTime` -- ISO-8601 end date
- `filter.workspaceId` -- Optional workspace filter
- `cursor` -- Pagination cursor
---
### 3. List Calls by Date Range
Retrieve basic call metadata (participants, duration, timing) for calls within a date range.
**Tool:** `GONG_RETRIEVE_CALL_DATA_BY_DATE_RANGE_V2_CALLS`
**Example prompt:**
> "List all Gong calls from last week"
**Key parameters (both required):**
- `fromDateTime` -- ISO-8601 start date (e.g., `2025-02-03T00:00:00Z`)
- `toDateTime` -- ISO-8601 end date (e.g., `2025-02-10T00:00:00Z`)
- `workspaceId` -- Optional workspace filter
- `cursor` -- Pagination cursor
**Required scope:** `api:calls:read:basic`
---
### 4. Get Detailed Call Analytics
Retrieve extensive call details including highlights, key points, topics, trackers, speaker stats, questions, and media URLs.
**Tool:** `GONG_RETRIEVE_FILTERED_CALL_DETAILS`
**Example prompt:**
> "Get detailed analytics for Gong calls this week including topics, key points, and speaker stats"
**Key parameters:**
- `filter__fromDateTime` / `filter__toDateTime` -- Date range filter
- `filter__callIds` -- Specific call IDs
- `filter__primaryUserIds` -- Filter by call host user IDs
- Content selectors (all boolean):
- `contentSelector__exposedFields__content__keyPoints` -- Key points of the call
- `contentSelector__exposedFields__content__topics` -- Topic durations
- `contentSelector__exposedFields__content__highlights` -- Call highlights
- `contentSelector__exposedFields__content__outline` -- Call outline
- `contentSelector__exposedFields__content__brief` -- Spotlight call brief
- `contentSelector__exposedFields__content__callOutcome` -- Call outcome
- `contentSelector__exposedFields__content__trackers` -- Smart/keyword trackers
- `contentSelector__exposedFields__content__trackerOccurrences` -- Tracker timing and speaker (requires trackers=true)
- `contentSelector__exposedFields__interaction__speakers` -- Time each participant spoke
- `contentSelector__exposedFields__interaction__questions` -- Question counts
- `contentSelector__exposedFields__interaction__personInteractionStats` -- Host statistics
- `contentSelector__exposedFields__media` -- Audio/video URLs (valid 8 hours)
- `contentSelector__exposedFields__parties` -- Party information
- `contentSelector__exposedFields__collaboration__publicComments` -- Public comments
- `contentSelector__context` -- "Basic", "Extended", or "None" for CRM/external system links
**Required scope:** `api:calls:read:extensive` (plus `api:calls:read:media-url` for media)
---
### 5. Get a Specific Call by ID
Retrieve basic data for a single call using its unique Gong ID.
**Tool:** `GONG_RETRIEVE_DATA_FOR_A_SPECIFIC_CALL_V2_CALLS_ID`
**Example prompt:**
> "Get details for Gong call 1223781272986876929"
**Key parameters (required):**
- `id` -- Gong's unique numeric identifier for the call (up to 20 digits)
**Required scope:** `api:calls:read:basic`
---
### 6. List Company Workspaces
Retrieve all workspaces in your Gong organization to get workspace IDs for filtering.
**Tool:** `GONG_LIST_ALL_COMPANY_WORKSPACES_V2_WORKSPACES`
**Example prompt:**
> "List all Gong workspaces in my company"
**Key parameters:** None required.
**Required scope:** `api:workspaces:read`
---
## 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
- **ISO-8601 date format is mandatory**: All date parameters must use ISO-8601 format with timezone: `2025-02-01T00:00:00Z` or `2025-02-01T02:30:00-07:00`. Plain dates will fail.
- **Date range is exclusive on toDateTime**: The `toDateTime` parameter returns calls started UP TO BUT EXCLUDING the specified time. To include calls on a specific day, set `toDateTime` to the next day.
- **Pagination is required for large result sets**: All list endpoints return paginated results. Use the `cursor` value from the previous response to fetch the next page. Continue until no cursor is returned.
- **Scope requirements vary by endpoint**: Different endpoints require different API scopes. Transcript access needs `api:calls:read:transcript`, basic call data needs `api:calls:read:basic`, and detailed analytics need `api:calls:read:extensive`.
- **Media URLs expire after 8 hours**: Audio and video URLs returned by the detailed call endpoint are temporary and expire after 8 hours.
- **Tracker occurrence data availability**: Tracker occurrence data (timing and speaker ID) is only available for calls recorded since January 1, 2023. Contact Gong support for backfill.
- **Web-conference vs. regular calls**: For web-conference calls recorded by Gong, the date represents the scheduled time. For other calls, it represents the actual start time.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Gong-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `gong` |
| 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` |
| Action | Tool Slug | Required Params |
|---|---|---|
| Get transcripts by date | `GONG_RETRIEVE_TRANSCRIPTS_OF_CALLS_V2_CALLS_TRANSCRIPT` | None (date range recommended) |
| Get call transcript | `GONG_GET_CALL_TRANSCRIPT` | `filter` object |
| List calls by date | `GONG_RETRIEVE_CALL_DATA_BY_DATE_RANGE_V2_CALLS` | `fromDateTime`, `toDateTime` |
| Get detailed call analytics | `GONG_RETRIEVE_FILTERED_CALL_DETAILS` | None (date range or call IDs recommended) |
| Get specific call | `GONG_RETRIEVE_DATA_FOR_A_SPECIFIC_CALL_V2_CALLS_ID` | `id` |
| List workspaces | `GONG_LIST_ALL_COMPANY_WORKSPACES_V2_WORKSPACES` | None |
---
*Powered by [Composio](https://composio.dev)*

151
google-admin-automation/SKILL.md
View File

@@ -1,24 +1,23 @@
---
name: google-admin-automation
description: "Automate Google Admin tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google Workspace Admin tasks via Rube MCP (Composio): manage users, groups, memberships, suspend accounts, create users, add aliases. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google Admin Automation via Rube MCP
# Google Workspace Admin Automation via Rube MCP
Automate Google Admin operations through Composio's Google Admin toolkit via Rube MCP.
Manage Google Workspace users, groups, memberships, and organizational settings programmatically using Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/google_admin](https://composio.dev/toolkits/google_admin)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Admin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `google_admin`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `google_admin`
- Google Workspace admin privileges for the authenticated account
- 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
@@ -26,66 +25,122 @@ Automate Google Admin operations through Composio's Google Admin toolkit via Rub
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:
## Core Workflows
### 1. List All Users
Use `GOOGLE_ADMIN_LIST_USERS` to retrieve Google Workspace users with optional filtering and pagination.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google Admin operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLE_ADMIN_LIST_USERS
Parameters:
- customer: Customer ID or "my_customer" (default)
- domain: Domain to list users from
- query: Filter string (e.g., "orgName=Engineering", "isSuspended=false")
- max_results: Maximum results (1-500, default 100)
- order_by: Sort by "email", "givenName", or "familyName"
- sort_order: "ASCENDING" or "DESCENDING"
- page_token: Pagination token
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Create a New User
Use `GOOGLE_ADMIN_CREATE_USER` to provision a new Google Workspace account.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google Admin task"}]
session: {id: "existing_session_id"}
Tool: GOOGLE_ADMIN_CREATE_USER
Parameters:
- primary_email (required): User's email (e.g., "john.doe@company.com")
- given_name (required): First name
- family_name (required): Last name
- password (required): Password meeting domain requirements
- org_unit_path: Organizational unit (default: "/")
- change_password_at_next_login: Force password change (default: true)
- recovery_email: Recovery email address
- recovery_phone: Recovery phone number
- suspended: Whether account starts suspended (default: false)
```
### Step 2: Check Connection
### 3. List and Manage Groups
Use `GOOGLE_ADMIN_LIST_GROUPS` to list groups, and `GOOGLE_ADMIN_CREATE_GROUP` to create new ones.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["google_admin"]
session_id: "your_session_id"
Tool: GOOGLE_ADMIN_LIST_GROUPS
Parameters:
- customer: "my_customer" (default)
- domain: Filter by domain
- query: Filter (e.g., "name=Engineering*")
- max_results: Max results (1-200)
- order_by: Sort by "email"
- page_token: Pagination token
Tool: GOOGLE_ADMIN_CREATE_GROUP
Parameters:
- email (required): Group email address (e.g., "engineering@company.com")
- name (required): Display name (e.g., "Engineering Team")
- description: Group purpose description
```
### Step 3: Execute Tools
### 4. Add Users to Groups
Use `GOOGLE_ADMIN_ADD_USER_TO_GROUP` to manage group membership.
```
Tool: GOOGLE_ADMIN_ADD_USER_TO_GROUP
Parameters:
- group_key (required): Group email or ID
- user_key (required): User email or ID to add
- role: "MEMBER" (default), "MANAGER", or "OWNER"
```
### 5. Suspend or Unsuspend Users
Use `GOOGLE_ADMIN_SUSPEND_USER` to toggle user account suspension.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: GOOGLE_ADMIN_SUSPEND_USER
Parameters:
- user_key (required): User's email or unique ID
- suspended: true to suspend, false to unsuspend (default: true)
- suspension_reason: Reason for suspension (optional)
```
### 6. Get User or Group Details
Use `GOOGLE_ADMIN_GET_USER` or `GOOGLE_ADMIN_GET_GROUP` to retrieve detailed information.
```
Tool: GOOGLE_ADMIN_GET_USER
Parameters:
- user_key (required): User's email or unique ID
Tool: GOOGLE_ADMIN_GET_GROUP
Parameters:
- group_key (required): Group's email or unique ID
```
## Common Patterns
- **Onboarding workflow**: Use `GOOGLE_ADMIN_CREATE_USER` to provision the account, then `GOOGLE_ADMIN_ADD_USER_TO_GROUP` to add them to relevant groups.
- **Offboarding workflow**: Use `GOOGLE_ADMIN_SUSPEND_USER` to disable access, or `GOOGLE_ADMIN_DELETE_USER` for permanent removal.
- **Audit group membership**: Use `GOOGLE_ADMIN_LIST_GROUPS` to find groups, then `GOOGLE_ADMIN_LIST_GROUP_MEMBERS` to review members.
- **Bulk user management**: List users with `GOOGLE_ADMIN_LIST_USERS` and filter queries, then iterate for updates.
- **Add email aliases**: Use `GOOGLE_ADMIN_ADD_USER_ALIAS` to add alternative email addresses for a user.
- **Look up user details**: Use `GOOGLE_ADMIN_GET_USER` to retrieve full profile information before making changes.
## 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
- **Admin privileges required**: All tools require the authenticated user to have Google Workspace administrator privileges. Non-admin accounts will receive permission errors.
- **Delete is permanent**: `GOOGLE_ADMIN_DELETE_USER` permanently removes a user account. This action cannot be undone.
- **user_key accepts email or ID**: The `user_key` parameter accepts both the user's primary email address and their unique numeric user ID.
- **Group membership replaces**: When adding to groups, the `role` parameter controls the member's role. There is no "update role" -- remove and re-add to change roles.
- **Customer ID**: Use `"my_customer"` as the `customer` parameter for the authenticated user's organization. Specific customer IDs look like `C01abc123`.
- **Pagination**: Both user and group list endpoints may return paginated results. Always check for `page_token` in responses for complete results.
- **Password requirements**: `GOOGLE_ADMIN_CREATE_USER` requires a password that meets the domain's password policy. Weak passwords will be rejected.
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Admin-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `google_admin` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| List users | `GOOGLE_ADMIN_LIST_USERS` | `customer`, `domain`, `query`, `max_results` |
| Get user details | `GOOGLE_ADMIN_GET_USER` | `user_key` |
| Create user | `GOOGLE_ADMIN_CREATE_USER` | `primary_email`, `given_name`, `family_name`, `password` |
| Delete user | `GOOGLE_ADMIN_DELETE_USER` | `user_key` |
| Suspend user | `GOOGLE_ADMIN_SUSPEND_USER` | `user_key`, `suspended` |
| Add user alias | `GOOGLE_ADMIN_ADD_USER_ALIAS` | (see full schema via RUBE_SEARCH_TOOLS) |
| List groups | `GOOGLE_ADMIN_LIST_GROUPS` | `customer`, `domain`, `query` |
| Get group details | `GOOGLE_ADMIN_GET_GROUP` | `group_key` |
| Create group | `GOOGLE_ADMIN_CREATE_GROUP` | `email`, `name`, `description` |
| Add to group | `GOOGLE_ADMIN_ADD_USER_TO_GROUP` | `group_key`, `user_key`, `role` |
| List group members | `GOOGLE_ADMIN_LIST_GROUP_MEMBERS` | (see full schema via RUBE_SEARCH_TOOLS) |
---
*Powered by [Composio](https://composio.dev)*

141
google-maps-automation/SKILL.md
View File

@@ -1,24 +1,22 @@
---
name: google-maps-automation
description: "Automate Google Maps tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google Maps tasks via Rube MCP (Composio): geocode addresses, search places, get directions, compute route matrices, reverse geocode, autocomplete, get place details. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google Maps Automation via Rube MCP
Automate Google Maps operations through Composio's Google Maps toolkit via Rube MCP.
Geocode addresses, search places, get directions, compute distance matrices, and retrieve place details using Google Maps via Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/google_maps](https://composio.dev/toolkits/google_maps)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Maps connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `google_maps`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `google_maps`
- 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
@@ -26,66 +24,115 @@ Automate Google Maps operations through Composio's Google Maps toolkit via Rube
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:
## Core Workflows
### 1. Geocode an Address
Use `GOOGLE_MAPS_GEOCODING_API` to convert a street address into geographic coordinates (latitude/longitude).
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google Maps operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLE_MAPS_GEOCODING_API
Parameters:
- address: Street address or plus code to geocode
- latlng: Lat/lng for reverse geocoding (e.g., "40.714224,-73.961452")
- place_id: Place ID for place geocoding
- language: Language for results
- region: Region bias (ccTLD code)
- bounds: Bounding box for viewport bias
- components: Component filter (e.g., "postal_code:94043|country:US")
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Search for Places
Use `GOOGLE_MAPS_TEXT_SEARCH` to find places using a free-text query.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google Maps task"}]
session: {id: "existing_session_id"}
Tool: GOOGLE_MAPS_TEXT_SEARCH
Parameters:
- textQuery (required): Search text (e.g., "restaurants in London")
- fieldMask: Fields to return (e.g., "displayName,formattedAddress,rating")
- maxResultCount: Max results (1-20, default 10)
```
### Step 2: Check Connection
### 3. Get Directions Between Two Locations
Use `GOOGLE_MAPS_GET_ROUTE` to calculate routes with distance and duration.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["google_maps"]
session_id: "your_session_id"
Tool: GOOGLE_MAPS_GET_ROUTE
Parameters:
- origin_address (required): Starting point (address or "lat,lng")
- destination_address (required): End point (address or "lat,lng")
- travelMode: DRIVE, BICYCLE, WALK, TWO_WHEELER, or TRANSIT
- routingPreference: TRAFFIC_UNAWARE, TRAFFIC_AWARE, TRAFFIC_AWARE_OPTIMAL
- computeAlternativeRoutes: Return alternative routes (boolean)
- units: METRIC or IMPERIAL
- languageCode: BCP-47 language code
- routeModifiers_avoidTolls / avoidHighways / avoidFerries: Route preferences
```
### Step 3: Execute Tools
### 4. Compute Distance Matrix
Use `GOOGLE_MAPS_COMPUTE_ROUTE_MATRIX` to calculate distances and durations between multiple origins and destinations.
```
Tool: GOOGLE_MAPS_COMPUTE_ROUTE_MATRIX
Parameters:
- origins (required): Array of origin locations (address strings or lat/lng objects)
- destinations (required): Array of destination locations
- travelMode: DRIVE, BICYCLE, WALK, TWO_WHEELER, or TRANSIT
- routingPreference: TRAFFIC_UNAWARE, TRAFFIC_AWARE, TRAFFIC_AWARE_OPTIMAL
- fieldMask: Response fields to include
- units: METRIC or IMPERIAL
```
### 5. Get Place Details
Use `GOOGLE_MAPS_GET_PLACE_DETAILS` to retrieve comprehensive information about a specific place.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: GOOGLE_MAPS_GET_PLACE_DETAILS
Description: Retrieves comprehensive details for a place using its resource
name (places/{place_id} format). Returns hours, contacts, reviews, etc.
Note: Call RUBE_SEARCH_TOOLS to get the full schema for this tool.
```
### 6. Search Nearby Places
Use `GOOGLE_MAPS_NEARBY_SEARCH` to find places within a circular area around a point.
```
Tool: GOOGLE_MAPS_NEARBY_SEARCH
Parameters:
- latitude (required): Center latitude (-90 to 90)
- longitude (required): Center longitude (-180 to 180)
- radius (required): Search radius in meters (max 50000)
- includedTypes: Place types to include (e.g., ["restaurant", "cafe"])
- excludedTypes: Place types to exclude
- fieldMask: Fields to return
- maxResultCount: Max results (1-20)
```
## Common Patterns
- **Geocode then route**: Use `GOOGLE_MAPS_GEOCODING_API` to convert addresses to coordinates, then `GOOGLE_MAPS_GET_ROUTE` for directions between them.
- **Search then detail**: Use `GOOGLE_MAPS_TEXT_SEARCH` to find places, then `GOOGLE_MAPS_GET_PLACE_DETAILS` for richer metadata (hours, contacts, reviews).
- **Autocomplete UX**: Use `GOOGLE_MAPS_AUTOCOMPLETE` for type-ahead search suggestions as users type addresses or place names.
- **Reverse geocode**: Use `GOOGLE_MAPS_GEOCODE_LOCATION` to convert coordinates back to a human-readable address.
- **Batch distance calculation**: Use `GOOGLE_MAPS_COMPUTE_ROUTE_MATRIX` for many-to-many distance calculations instead of calling `GOOGLE_MAPS_GET_ROUTE` repeatedly.
- **Embed maps**: Use `GOOGLE_MAPS_MAPS_EMBED_API` to generate embeddable map URLs for places, directions, or search results.
## 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
- **Route matrix results structure**: `GOOGLE_MAPS_COMPUTE_ROUTE_MATRIX` returns results under `data.elements` with `originIndex` and `destinationIndex` plus `distanceMeters` and `duration` -- not a `routes[]` structure.
- **Duration format**: `GOOGLE_MAPS_GET_ROUTE` returns durations as strings like `"937s"` inside `data.response_data.routes`. You must parse these before numeric comparisons.
- **Place IDs for chaining**: Use place identifiers returned from `GOOGLE_MAPS_TEXT_SEARCH` when calling `GOOGLE_MAPS_GET_PLACE_DETAILS` for richer fields.
- **Reverse geocoding input**: `GOOGLE_MAPS_GEOCODE_LOCATION` is coordinate-driven. Ensure you pass lat/lng (not an address string) to avoid mismatched lookups.
- **Routing preference restrictions**: `routingPreference` cannot be set when `travelMode` is WALK, BICYCLE, or TRANSIT -- it must be omitted for these modes.
- **Nearby search type validity**: `"food"` is NOT a valid type for `GOOGLE_MAPS_NEARBY_SEARCH` (it is Table B). Use specific types like `restaurant`, `cafe`, `bakery`, `fast_food_restaurant` instead.
- **Embed API uses API keys only**: `GOOGLE_MAPS_MAPS_EMBED_API` requires an API key and does not support OAuth2.
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Maps-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `google_maps` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| Geocode address | `GOOGLE_MAPS_GEOCODING_API` | `address` or `latlng` or `place_id` |
| Reverse geocode | `GOOGLE_MAPS_GEOCODE_LOCATION` | (see full schema via RUBE_SEARCH_TOOLS) |
| Text search | `GOOGLE_MAPS_TEXT_SEARCH` | `textQuery`, `fieldMask`, `maxResultCount` |
| Nearby search | `GOOGLE_MAPS_NEARBY_SEARCH` | `latitude`, `longitude`, `radius`, `includedTypes` |
| Get directions | `GOOGLE_MAPS_GET_ROUTE` | `origin_address`, `destination_address`, `travelMode` |
| Distance matrix | `GOOGLE_MAPS_COMPUTE_ROUTE_MATRIX` | `origins`, `destinations`, `travelMode` |
| Place details | `GOOGLE_MAPS_GET_PLACE_DETAILS` | (see full schema via RUBE_SEARCH_TOOLS) |
| Autocomplete | `GOOGLE_MAPS_AUTOCOMPLETE` | `input`, `includedRegionCodes`, `locationBias` |
| Place photo | `GOOGLE_MAPS_PLACE_PHOTO` | (see full schema via RUBE_SEARCH_TOOLS) |
| Embed map | `GOOGLE_MAPS_MAPS_EMBED_API` | `mode`, plus mode-specific params |
---
*Powered by [Composio](https://composio.dev)*

126
google-search-console-automation/SKILL.md
View File

@@ -1,24 +1,23 @@
---
name: google-search-console-automation
description: "Automate Google Search Console tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google Search Console tasks via Rube MCP (Composio): query search analytics, list sites, inspect URLs, submit sitemaps, monitor search performance. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google Search Console Automation via Rube MCP
Automate Google Search Console operations through Composio's Google Search Console toolkit via Rube MCP.
Query search analytics, inspect URLs, manage sitemaps, and monitor search performance using Google Search Console via Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/google_search_console](https://composio.dev/toolkits/google_search_console)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Search Console connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `google_search_console`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `google_search_console`
- Verified site ownership or appropriate permissions in Google Search Console
- 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
@@ -26,66 +25,99 @@ Automate Google Search Console operations through Composio's Google Search Conso
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:
## Core Workflows
### 1. List All Verified Sites
Use `GOOGLE_SEARCH_CONSOLE_LIST_SITES` to retrieve all sites the authenticated user owns or has access to.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google Search Console operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLE_SEARCH_CONSOLE_LIST_SITES
Parameters: (none required)
Returns: List of site entries with siteUrl and permissionLevel
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Query Search Analytics
Use `GOOGLE_SEARCH_CONSOLE_SEARCH_ANALYTICS_QUERY` to get search performance data including clicks, impressions, CTR, and position.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google Search Console task"}]
session: {id: "existing_session_id"}
Tool: GOOGLE_SEARCH_CONSOLE_SEARCH_ANALYTICS_QUERY
Parameters:
- site_url (required): Site URL (e.g., "https://www.example.com/" or "sc-domain:example.com")
- start_date (required): Start date in YYYY-MM-DD format
- end_date (required): End date in YYYY-MM-DD format
- dimensions: Group by ["query", "page", "country", "device", "date", "searchAppearance"]
- search_type: "web" (default), "image", "video", "news", "discover", "googleNews"
- dimension_filter_groups: Filters for dimensions (operator: equals, notEquals, contains, notContains, includingRegex, excludingRegex)
- row_limit: Max rows (1-25000, default 1000)
- start_row: Pagination offset (default 0)
- aggregation_type: "auto", "byPage", "byProperty", "byNewsShowcasePanel"
- data_state: "final" (default), "all", "hourly_all"
```
### Step 2: Check Connection
### 3. Inspect a URL
Use `GOOGLE_SEARCH_CONSOLE_INSPECT_URL` to check the indexing status and issues for a specific URL.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["google_search_console"]
session_id: "your_session_id"
Tool: GOOGLE_SEARCH_CONSOLE_INSPECT_URL
Parameters:
- inspection_url (required): Full URL to inspect (e.g., "https://www.example.com/page")
- site_url (required): Property URL (e.g., "https://www.example.com/")
- language_code: BCP-47 language (default: "en-US")
```
### Step 3: Execute Tools
### 4. List Sitemaps
Use `GOOGLE_SEARCH_CONSOLE_LIST_SITEMAPS` to retrieve all sitemaps submitted for a site.
```
Tool: GOOGLE_SEARCH_CONSOLE_LIST_SITEMAPS
Parameters:
- site_url (required): Site URL (e.g., "https://www.example.com/")
- sitemap_index: Specific sitemap index URL to list sitemaps from
```
### 5. Submit a Sitemap
Use `GOOGLE_SEARCH_CONSOLE_SUBMIT_SITEMAP` to register or resubmit a sitemap for indexing.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: GOOGLE_SEARCH_CONSOLE_SUBMIT_SITEMAP
Parameters:
- site_url (required): Site URL or domain property (e.g., "sc-domain:example.com")
- feedpath (required): Full sitemap URL (e.g., "https://www.example.com/sitemap.xml")
```
### 6. Get Sitemap Details
Use `GOOGLE_SEARCH_CONSOLE_GET_SITEMAP` to retrieve information about a specific submitted sitemap.
```
Tool: GOOGLE_SEARCH_CONSOLE_GET_SITEMAP
Parameters:
- site_url (required): Site URL
- feedpath (required): Sitemap URL to retrieve details for
```
## Common Patterns
- **Performance monitoring**: Use `GOOGLE_SEARCH_CONSOLE_SEARCH_ANALYTICS_QUERY` with `dimensions: ["date"]` over a date range to track daily search performance trends.
- **Top queries report**: Use `GOOGLE_SEARCH_CONSOLE_SEARCH_ANALYTICS_QUERY` with `dimensions: ["query"]` to find the most clicked search terms.
- **Page-level analysis**: Use `dimensions: ["page"]` to identify top-performing pages, then `dimensions: ["query", "page"]` to see which queries drive traffic to each page.
- **Indexing audit**: Use `GOOGLE_SEARCH_CONSOLE_INSPECT_URL` to check the indexing status of important pages.
- **Sitemap management**: Use `GOOGLE_SEARCH_CONSOLE_LIST_SITEMAPS` to verify submitted sitemaps, then `GOOGLE_SEARCH_CONSOLE_SUBMIT_SITEMAP` to submit new or updated ones.
- **Country/device breakdown**: Use `dimensions: ["country", "device"]` to understand geographic and device-type distribution of search traffic.
- **Filter for specific queries**: Use `dimension_filter_groups` with `contains` or `includingRegex` operators to focus on specific keyword groups.
## 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
- **Site URL format matters**: URL-prefix properties use the full URL with protocol and trailing slash (e.g., `https://www.example.com/`). Domain properties use the `sc-domain:` prefix (e.g., `sc-domain:example.com`). Using the wrong format will return empty results or errors.
- **Date range limits**: Data is typically available with a 2-3 day delay. `data_state: "all"` includes fresher data that may still change. `hourly_all` only works for dates within the last 3 days.
- **Row limit pagination**: The API returns top results sorted by clicks (or by date when grouping by date). For complete data, paginate using `start_row` with the `row_limit`.
- **Max 25,000 rows per request**: Even with pagination, each request returns at most 25,000 rows. For very large datasets, narrow your date range or add dimension filters.
- **Inspection URL must match site**: The `inspection_url` must be a page under the `site_url` property. Cross-property inspections will fail.
- **Sitemap must be accessible**: `GOOGLE_SEARCH_CONSOLE_SUBMIT_SITEMAP` requires the sitemap file to be publicly accessible at the specified URL and properly formatted as XML.
- **Results sorted by clicks**: By default, analytics results are sorted by click count descending, except when grouping by `date` (which sorts by date ascending).
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Search Console-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `google_search_console` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| List sites | `GOOGLE_SEARCH_CONSOLE_LIST_SITES` | (none) |
| Search analytics | `GOOGLE_SEARCH_CONSOLE_SEARCH_ANALYTICS_QUERY` | `site_url`, `start_date`, `end_date`, `dimensions` |
| Inspect URL | `GOOGLE_SEARCH_CONSOLE_INSPECT_URL` | `inspection_url`, `site_url` |
| List sitemaps | `GOOGLE_SEARCH_CONSOLE_LIST_SITEMAPS` | `site_url` |
| Submit sitemap | `GOOGLE_SEARCH_CONSOLE_SUBMIT_SITEMAP` | `site_url`, `feedpath` |
| Get sitemap info | `GOOGLE_SEARCH_CONSOLE_GET_SITEMAP` | `site_url`, `feedpath` |
---
*Powered by [Composio](https://composio.dev)*

127
googleads-automation/SKILL.md
View File

@@ -1,91 +1,124 @@
---
name: googleads-automation
description: "Automate Google Ads tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google Ads analytics tasks via Rube MCP (Composio): list Google Ads links, run GA4 reports, check compatibility, list properties and accounts. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google Ads Automation via Rube MCP
Automate Google Ads operations through Composio's Google Ads toolkit via Rube MCP.
Access Google Ads data through Google Analytics integration, run performance reports, list linked Ads accounts, and analyze campaign metrics using Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/googleads](https://composio.dev/toolkits/googleads)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Ads connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googleads`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `google_analytics`
- 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 `googleads`
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `google_analytics`
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
> **Note**: Google Ads data is accessed through the Google Analytics toolkit integration. The tools below use GA4 properties linked to Google Ads accounts.
Always discover available tools before executing workflows:
## Core Workflows
### 1. List Google Ads Links for a Property
Use `GOOGLE_ANALYTICS_ANALYTICS_ADMIN_PROPERTIES_GOOGLE_ADS` to retrieve all Google Ads account links configured for a GA4 property.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google Ads operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLE_ANALYTICS_ANALYTICS_ADMIN_PROPERTIES_GOOGLE_ADS
Parameters:
- parent (required): Property resource name (format: "properties/{propertyId}")
- pageSize: Max results (1-200, default 50)
- pageToken: Pagination token
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Run a GA4 Performance Report
Use `GOOGLE_ANALYTICS_RUN_REPORT` to run customized reports with dimensions, metrics, date ranges, and filters.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google Ads task"}]
session: {id: "existing_session_id"}
Tool: GOOGLE_ANALYTICS_RUN_REPORT
Parameters:
- property (required): Property resource (format: "properties/{property_id}")
- dimensions: Array of dimension objects (e.g., [{"name": "sessionCampaignName"}, {"name": "date"}])
- metrics: Array of metric objects (e.g., [{"name": "sessions"}, {"name": "totalRevenue"}])
- dateRanges: Array with startDate and endDate (e.g., [{"startDate": "2025-01-01", "endDate": "2025-01-31"}])
- dimensionFilter: Filter by dimension values
- metricFilter: Filter by metric values (applied after aggregation)
- orderBys: Sort results
- limit: Max rows to return (1-250000)
```
### Step 2: Check Connection
### 3. Check Dimension/Metric Compatibility
Use `GOOGLE_ANALYTICS_CHECK_COMPATIBILITY` to validate dimension and metric combinations before running a report.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["googleads"]
session_id: "your_session_id"
Tool: GOOGLE_ANALYTICS_CHECK_COMPATIBILITY
Description: Validates compatibility of chosen dimensions or metrics
before running a report.
Note: Call RUBE_SEARCH_TOOLS to get the full schema for this tool.
```
### Step 3: Execute Tools
### 4. List GA4 Accounts
Use `GOOGLE_ANALYTICS_LIST_ACCOUNTS` to enumerate all accessible Google Analytics accounts.
```
Tool: GOOGLE_ANALYTICS_LIST_ACCOUNTS
Parameters:
- pageSize: Max accounts to return
- pageToken: Pagination token
- showDeleted: Include soft-deleted accounts
```
### 5. List GA4 Properties Under an Account
Use `GOOGLE_ANALYTICS_LIST_PROPERTIES` to list properties for a specific GA4 account.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: GOOGLE_ANALYTICS_LIST_PROPERTIES
Parameters:
- account (required): Account resource name (format: "accounts/{account_id}")
- pageSize: Max properties (1-200)
- pageToken: Pagination token
- showDeleted: Include trashed properties
```
### 6. Get Available Dimensions and Metrics
Use `GOOGLE_ANALYTICS_GET_METADATA` to discover all available fields for building reports.
```
Tool: GOOGLE_ANALYTICS_GET_METADATA
Description: Gets metadata for dimensions, metrics, and comparisons
for a GA4 property.
Note: Call RUBE_SEARCH_TOOLS to get the full schema for this tool.
```
## Common Patterns
- **Discover then report**: Use `GOOGLE_ANALYTICS_LIST_ACCOUNTS` to find account IDs, then `GOOGLE_ANALYTICS_LIST_PROPERTIES` to find property IDs, then `GOOGLE_ANALYTICS_RUN_REPORT` to pull data.
- **Validate before querying**: Use `GOOGLE_ANALYTICS_CHECK_COMPATIBILITY` to validate dimension/metric combinations before running reports to avoid 400 errors.
- **Campaign performance**: Run reports with dimensions like `sessionCampaignName`, `sessionSource`, `sessionMedium` and metrics like `sessions`, `activeUsers`, `totalRevenue`.
- **Ads link discovery**: Use `GOOGLE_ANALYTICS_ANALYTICS_ADMIN_PROPERTIES_GOOGLE_ADS` to find which Google Ads accounts are linked to each GA4 property.
- **Field discovery**: Use `GOOGLE_ANALYTICS_GET_METADATA` to list all available dimensions and metrics before constructing complex reports.
## 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
- **Dimension/metric compatibility**: The GA4 API has strict compatibility rules. Not all dimensions can be combined with all metrics. Demographic dimensions (e.g., `userAgeBracket`, `userGender`) are often incompatible with session-scoped dimensions/filters (e.g., `sessionCampaignName`, `sessionSource`).
- **`dateRange` is NOT a dimension**: Do not include `dateRange` in the dimensions array. Use `date`, `dateHour`, `year`, `month`, or `week` instead.
- **`exits` is NOT valid**: Neither `exits` as a dimension nor as a metric is valid in GA4.
- **Property ID format**: Must be `properties/{numeric_id}` (e.g., `properties/123456789`). Do not use Google Account IDs (long OAuth IDs).
- **Account ID format**: Must be `accounts/{numeric_id}` where the numeric ID is 6-10 digits.
- **Filter separation**: Use `dimensionFilter` only for dimension fields and `metricFilter` only for metric fields. Mixing them will cause errors.
- **Max 9 dimensions and 10 metrics** per report request.
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Ads-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `googleads` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| List Ads links | `GOOGLE_ANALYTICS_ANALYTICS_ADMIN_PROPERTIES_GOOGLE_ADS` | `parent` |
| Run report | `GOOGLE_ANALYTICS_RUN_REPORT` | `property`, `dimensions`, `metrics`, `dateRanges` |
| Check compatibility | `GOOGLE_ANALYTICS_CHECK_COMPATIBILITY` | (see full schema via RUBE_SEARCH_TOOLS) |
| List accounts | `GOOGLE_ANALYTICS_LIST_ACCOUNTS` | `pageSize` |
| List properties | `GOOGLE_ANALYTICS_LIST_PROPERTIES` | `account`, `pageSize` |
| Get metadata | `GOOGLE_ANALYTICS_GET_METADATA` | (see full schema via RUBE_SEARCH_TOOLS) |
---
*Powered by [Composio](https://composio.dev)*

131
googlebigquery-automation/SKILL.md
View File

@@ -1,91 +1,128 @@
---
name: googlebigquery-automation
description: "Automate Google BigQuery tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google BigQuery tasks via Rube MCP (Composio): run SQL queries, explore datasets and metadata, execute MBQL queries via Metabase integration. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google BigQuery Automation via Rube MCP
Automate Google BigQuery operations through Composio's Google BigQuery toolkit via Rube MCP.
Run SQL queries, explore database schemas, and analyze datasets through the Metabase integration using Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/googlebigquery](https://composio.dev/toolkits/googlebigquery)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google BigQuery connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googlebigquery`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `metabase`
- A Metabase instance connected to your BigQuery data source
- 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 `googlebigquery`
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `metabase`
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
> **Note**: BigQuery data is accessed through Metabase, a business intelligence tool that connects to BigQuery as a data source. The tools below execute queries and retrieve metadata through Metabase's API.
Always discover available tools before executing workflows:
## Core Workflows
### 1. Run a Native SQL Query
Use `METABASE_POST_API_DATASET` with type `native` to execute raw SQL queries against your BigQuery database.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google BigQuery operations", known_fields: ""}]
session: {generate_id: true}
Tool: METABASE_POST_API_DATASET
Parameters:
- database (required): Metabase database ID (integer)
- type (required): "native" for SQL queries
- native (required): Object with "query" string
- query: Raw SQL string (e.g., "SELECT * FROM users LIMIT 10")
- template_tags: Parameterized query variables (optional)
- constraints: { "max-results": 1000 } (optional)
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Run a Structured MBQL Query
Use `METABASE_POST_API_DATASET` with type `query` for Metabase Query Language queries with built-in aggregation and filtering.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google BigQuery task"}]
session: {id: "existing_session_id"}
Tool: METABASE_POST_API_DATASET
Parameters:
- database (required): Metabase database ID
- type (required): "query" for MBQL
- query (required): Object with:
- source-table: Table ID (integer)
- aggregation: e.g., [["count"]] or [["sum", ["field", 5, null]]]
- breakout: Group-by fields
- filter: Filter conditions
- limit: Max rows
- order-by: Sort fields
```
### Step 2: Check Connection
### 3. Get Query Metadata
Use `METABASE_POST_API_DATASET_QUERY_METADATA` to retrieve metadata about databases, tables, and fields available for querying.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["googlebigquery"]
session_id: "your_session_id"
Tool: METABASE_POST_API_DATASET_QUERY_METADATA
Parameters:
- database (required): Metabase database ID
- type (required): "query" or "native"
- query (required): Query object (e.g., {"source-table": 1})
```
### Step 3: Execute Tools
### 4. Convert Query to Native SQL
Use `METABASE_POST_API_DATASET_NATIVE` to convert an MBQL query into its native SQL representation.
```
Tool: METABASE_POST_API_DATASET_NATIVE
Parameters:
- database (required): Metabase database ID
- type (required): "native"
- native (required): Object with "query" and optional "template_tags"
- parameters: Query parameter values (optional)
```
### 5. List Available Databases
Use `METABASE_GET_API_DATABASE` to discover all database connections configured in Metabase.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: METABASE_GET_API_DATABASE
Description: Retrieves a list of all Database instances configured in Metabase.
Note: Call RUBE_SEARCH_TOOLS to get the full schema for this tool.
```
### 6. Get Database Schema Metadata
Use `METABASE_GET_API_DATABASE_ID_METADATA` to retrieve complete table and field information for a specific database.
```
Tool: METABASE_GET_API_DATABASE_ID_METADATA
Description: Retrieves complete metadata for a specific database including
all tables and fields.
Note: Call RUBE_SEARCH_TOOLS to get the full schema for this tool.
```
## Common Patterns
- **Discover then query**: Use `METABASE_GET_API_DATABASE` to find database IDs, then `METABASE_GET_API_DATABASE_ID_METADATA` to explore tables and fields, then `METABASE_POST_API_DATASET` to run queries.
- **SQL-first approach**: Use `METABASE_POST_API_DATASET` with `type: "native"` and write standard SQL queries for maximum flexibility.
- **Parameterized queries**: Use `template_tags` in native queries for safe parameterization (e.g., `SELECT * FROM users WHERE id = {{user_id}}`).
- **Schema exploration**: Use `METABASE_POST_API_DATASET_QUERY_METADATA` to understand table structures before building complex queries.
- **Get parameter values**: Use `METABASE_POST_API_DATASET_PARAMETER_VALUES` to retrieve possible values for filter dropdowns.
## 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
- The `database` parameter is a Metabase-internal **integer ID**, not the BigQuery project or dataset name. Use `METABASE_GET_API_DATABASE` to find valid database IDs first.
- `source-table` in MBQL queries is also a Metabase-internal integer, not the BigQuery table name. Discover table IDs via metadata tools.
- Native SQL queries use BigQuery SQL dialect (Standard SQL). Ensure your syntax is BigQuery-compatible.
- `max-results` in constraints defaults can limit returned rows. Set explicitly for large result sets.
- Responses from `METABASE_POST_API_DATASET` contain results nested under `data` -- parse carefully as the structure may be deeply nested.
- Metabase field IDs used in MBQL `aggregation`, `breakout`, and `filter` arrays must be integers obtained from metadata responses.
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google BigQuery-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `googlebigquery` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| Run SQL query | `METABASE_POST_API_DATASET` | `database`, `type: "native"`, `native.query` |
| Run MBQL query | `METABASE_POST_API_DATASET` | `database`, `type: "query"`, `query` |
| Get query metadata | `METABASE_POST_API_DATASET_QUERY_METADATA` | `database`, `type`, `query` |
| Convert to SQL | `METABASE_POST_API_DATASET_NATIVE` | `database`, `type`, `native` |
| Get parameter values | `METABASE_POST_API_DATASET_PARAMETER_VALUES` | `parameter`, `field_ids` |
| List databases | `METABASE_GET_API_DATABASE` | (see full schema via RUBE_SEARCH_TOOLS) |
| Get database metadata | `METABASE_GET_API_DATABASE_ID_METADATA` | (see full schema via RUBE_SEARCH_TOOLS) |
---
*Powered by [Composio](https://composio.dev)*

127
googledocs-automation/SKILL.md
View File

@@ -1,24 +1,22 @@
---
name: googledocs-automation
description: "Automate Google Docs tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google Docs tasks via Rube MCP (Composio): create, edit, search, export, copy, and update documents. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google Docs Automation via Rube MCP
Automate Google Docs operations through Composio's Google Docs toolkit via Rube MCP.
Create, edit, search, export, and manage Google Docs documents programmatically using Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/googledocs](https://composio.dev/toolkits/googledocs)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Docs connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googledocs`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googledocs`
- 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
@@ -26,66 +24,101 @@ Automate Google Docs operations through Composio's Google Docs toolkit via Rube
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:
## Core Workflows
### 1. Create a New Document
Use `GOOGLEDOCS_CREATE_DOCUMENT` to create a new Google Doc with a title and initial text content.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google Docs operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLEDOCS_CREATE_DOCUMENT
Parameters:
- title (required): Document filename/title
- text (required): Initial text content to insert into the document
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Search for Documents
Use `GOOGLEDOCS_SEARCH_DOCUMENTS` to find Google Docs by name, content, date, or sharing status.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google Docs task"}]
session: {id: "existing_session_id"}
Tool: GOOGLEDOCS_SEARCH_DOCUMENTS
Parameters:
- query: Search query string
- max_results: Limit number of results
- modified_after / created_after: Filter by date
- shared_with_me: Filter shared documents
- starred_only: Filter starred documents
- include_shared_drives: Search shared drives
- order_by: Sort results
- page_token: Pagination token
```
### Step 2: Check Connection
### 3. Update Document Content with Markdown
Use `GOOGLEDOCS_UPDATE_DOCUMENT_MARKDOWN` to replace the entire content of a document with Markdown-formatted text.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["googledocs"]
session_id: "your_session_id"
Tool: GOOGLEDOCS_UPDATE_DOCUMENT_MARKDOWN
Parameters:
- id (required): Document ID
- markdown (required): Markdown content to replace entire document body
```
### Step 3: Execute Tools
### 4. Find and Replace Text
Use `GOOGLEDOCS_REPLACE_ALL_TEXT` to replace all occurrences of a string in a document.
```
Tool: GOOGLEDOCS_REPLACE_ALL_TEXT
Parameters:
- document_id (required): Target document ID
- find_text (required): Text to search for
- replace_text (required): Replacement text
- match_case: Case-sensitive matching (boolean)
- search_by_regex: Use regex for find_text
- tab_ids: Specific tabs to search
```
### 5. Export Document as PDF
Use `GOOGLEDOCS_EXPORT_DOCUMENT_AS_PDF` to export a Google Doc to PDF format.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: GOOGLEDOCS_EXPORT_DOCUMENT_AS_PDF
Parameters:
- file_id (required): Document file ID
- filename: Output PDF filename
```
### 6. Copy a Document
Use `GOOGLEDOCS_COPY_DOCUMENT` to duplicate an existing Google Doc.
```
Tool: GOOGLEDOCS_COPY_DOCUMENT
Parameters:
- document_id (required): Source document ID to copy
- title: Title for the new copy
- include_shared_drives: Search shared drives for the source
```
## Common Patterns
- **Search then edit**: Use `GOOGLEDOCS_SEARCH_DOCUMENTS` to find a document by name, then use the returned document ID with `GOOGLEDOCS_UPDATE_DOCUMENT_MARKDOWN` or `GOOGLEDOCS_REPLACE_ALL_TEXT` to modify it.
- **Create from template**: Use `GOOGLEDOCS_COPY_DOCUMENT` to duplicate a template, then `GOOGLEDOCS_REPLACE_ALL_TEXT` to fill in placeholder text.
- **Retrieve then update**: Use `GOOGLEDOCS_GET_DOCUMENT_BY_ID` to read current content, then apply edits with `GOOGLEDOCS_UPDATE_EXISTING_DOCUMENT`.
- **Batch text insertion**: Use `GOOGLEDOCS_INSERT_TEXT_ACTION` to insert text at specific positions (by index) or append to the end of a document.
- **Share documents**: Combine with `GOOGLEDRIVE_ADD_FILE_SHARING_PREFERENCE` (googledrive toolkit) to share documents after creation.
## 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
- `GOOGLEDOCS_UPDATE_DOCUMENT_MARKDOWN` replaces the **entire** document content -- it does not append. Use it for full rewrites only.
- `GOOGLEDOCS_INSERT_TEXT_ACTION` requires a precise `insertion_index` (character position). Set `append_to_end: true` to safely add text at the end.
- `GOOGLEDOCS_UPDATE_EXISTING_DOCUMENT` requires constructing an `editDocs` request body with raw Google Docs API batch update requests -- consult the API documentation for the correct structure.
- Document IDs and file IDs are the same value for Google Docs, but parameter names differ across tools (`id`, `document_id`, `file_id`).
- `GOOGLEDOCS_SEARCH_DOCUMENTS` uses Google Drive search syntax for the `query` parameter (e.g., `name contains 'report'`).
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Docs-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `googledocs` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| Create document | `GOOGLEDOCS_CREATE_DOCUMENT` | `title`, `text` |
| Search documents | `GOOGLEDOCS_SEARCH_DOCUMENTS` | `query`, `max_results`, `modified_after` |
| Get document by ID | `GOOGLEDOCS_GET_DOCUMENT_BY_ID` | `id` |
| Update with Markdown | `GOOGLEDOCS_UPDATE_DOCUMENT_MARKDOWN` | `id`, `markdown` |
| Programmatic edits | `GOOGLEDOCS_UPDATE_EXISTING_DOCUMENT` | `document_id`, `editDocs` |
| Insert text | `GOOGLEDOCS_INSERT_TEXT_ACTION` | `document_id`, `text_to_insert`, `insertion_index` |
| Find and replace | `GOOGLEDOCS_REPLACE_ALL_TEXT` | `document_id`, `find_text`, `replace_text` |
| Export as PDF | `GOOGLEDOCS_EXPORT_DOCUMENT_AS_PDF` | `file_id`, `filename` |
| Copy document | `GOOGLEDOCS_COPY_DOCUMENT` | `document_id`, `title` |
---
*Powered by [Composio](https://composio.dev)*

119
googlemeet-automation/SKILL.md
View File

@@ -1,91 +1,108 @@
---
name: googlemeet-automation
description: "Automate Google Meet tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google Meet tasks via Rube MCP (Composio): create Meet spaces, schedule video conferences via Calendar events, manage meeting access. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google Meet Automation via Rube MCP
Automate Google Meet operations through Composio's Google Meet toolkit via Rube MCP.
Create Google Meet video conferences, schedule meetings with Meet links, and manage meeting spaces using Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/googlemeet](https://composio.dev/toolkits/googlemeet)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Meet connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googlemeet`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googlemeet`
- For scheduling meetings with attendees, also connect the `googlecalendar` toolkit
- 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 `googlemeet`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
3. Optionally also connect `googlecalendar` for scheduling meetings with calendar events
4. If connection is not ACTIVE, follow the returned auth link to complete setup
5. Confirm connection status shows ACTIVE before running any workflows
## Tool Discovery
Always discover available tools before executing workflows:
## Core Workflows
### 1. Create a Standalone Meet Space
Use `GOOGLEMEET_CREATE_MEET` to create a new Google Meet meeting space with optional access configuration.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google Meet operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLEMEET_CREATE_MEET
Description: Creates a new Google Meet space, optionally configuring
its access type and entry points.
Note: Call RUBE_SEARCH_TOOLS to get the full schema for this tool.
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Schedule a Meeting with Google Meet Link
Use `GOOGLECALENDAR_CREATE_EVENT` to create a calendar event that automatically generates a Google Meet link (enabled by default).
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google Meet task"}]
session: {id: "existing_session_id"}
Tool: GOOGLECALENDAR_CREATE_EVENT
Parameters:
- start_datetime (required): ISO 8601 format (e.g., "2025-01-16T13:00:00")
- summary: Meeting title
- attendees: List of email addresses
- timezone: IANA timezone (e.g., "America/New_York")
- event_duration_hour: Duration hours (default: 0)
- event_duration_minutes: Duration minutes (default: 30, max: 59)
- create_meeting_room: true (default) -- generates Meet link
- description: Meeting agenda/notes
- location: Physical or virtual location
```
### Step 2: Check Connection
### 3. Find Available Time Slots
Use `GOOGLECALENDAR_FIND_FREE_SLOTS` before scheduling to find when participants are available.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["googlemeet"]
session_id: "your_session_id"
Tool: GOOGLECALENDAR_FIND_FREE_SLOTS
Parameters:
- items: List of calendar IDs to check (e.g., ["primary", "user@example.com"])
- time_min: Start of time window (ISO format)
- time_max: End of time window (ISO format)
- timezone: IANA timezone
```
### Step 3: Execute Tools
### 4. Update an Existing Meeting
Use `GOOGLECALENDAR_PATCH_EVENT` to modify meeting details, reschedule, or update attendees.
```
Tool: GOOGLECALENDAR_PATCH_EVENT
Parameters:
- calendar_id (required): Calendar ID (use "primary")
- event_id (required): Event ID (from search/list)
- summary: Updated title
- start_time / end_time: Rescheduled times
- attendees: Updated attendee list (replaces existing)
- send_updates: Notification preference ("all", "externalOnly", "none")
```
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
## Common Patterns
- **Quick meeting link**: Use `GOOGLEMEET_CREATE_MEET` for an instant meeting space without a calendar event.
- **Scheduled meeting with attendees**: Use `GOOGLECALENDAR_CREATE_EVENT` with `create_meeting_room: true` (default) to create a calendar event with an embedded Meet link. Workspace accounts get a Meet link automatically.
- **Check availability first**: Use `GOOGLECALENDAR_FIND_FREE_SLOTS` to find open time slots before scheduling with `GOOGLECALENDAR_CREATE_EVENT`.
- **Resolve names to emails**: Use `GMAIL_SEARCH_PEOPLE` (gmail toolkit) to look up email addresses from names before adding attendees.
- **Get current time**: Use `GOOGLECALENDAR_GET_CURRENT_DATE_TIME` with a timezone to get the current date/time for scheduling relative to "now".
## 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
- **Attendees must be email addresses**: `GOOGLECALENDAR_CREATE_EVENT` only accepts email addresses for attendees, not names. Use `GMAIL_SEARCH_PEOPLE` to resolve names to emails first.
- **Personal Gmail vs Workspace**: The `create_meeting_room` feature works best with Google Workspace accounts. Personal Gmail accounts will gracefully fallback to creating an event without a Meet link.
- **start_datetime format**: Must be exact ISO 8601 (e.g., `2025-01-16T13:00:00`). Natural language like "tomorrow at 3pm" is NOT supported.
- **Duration limits**: `event_duration_minutes` max is 59. For 1+ hour meetings, use `event_duration_hour` combined with `event_duration_minutes`.
- **Timezone is critical**: Always provide `timezone` as a valid IANA identifier (e.g., `America/New_York`). Abbreviations like "EST" or "PST" are NOT valid.
- **Event IDs are opaque**: To update or delete events, you must first retrieve the event ID using a search or list tool.
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Meet-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `googlemeet` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| Create Meet space | `GOOGLEMEET_CREATE_MEET` | (see full schema via RUBE_SEARCH_TOOLS) |
| Schedule meeting | `GOOGLECALENDAR_CREATE_EVENT` | `start_datetime`, `summary`, `attendees`, `timezone` |
| Find free slots | `GOOGLECALENDAR_FIND_FREE_SLOTS` | `items`, `time_min`, `time_max`, `timezone` |
| Update meeting | `GOOGLECALENDAR_PATCH_EVENT` | `calendar_id`, `event_id`, `summary`, `start_time` |
| Get current time | `GOOGLECALENDAR_GET_CURRENT_DATE_TIME` | `timezone` |
| Look up contacts | `GMAIL_SEARCH_PEOPLE` | `query` |
---
*Powered by [Composio](https://composio.dev)*

127
googlephotos-automation/SKILL.md
View File

@@ -1,24 +1,22 @@
---
name: googlephotos-automation
description: "Automate Google Photos tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google Photos tasks via Rube MCP (Composio): upload media, manage albums, search photos, batch add items, create and update albums. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google Photos Automation via Rube MCP
Automate Google Photos operations through Composio's Google Photos toolkit via Rube MCP.
Upload photos, manage albums, search media items, and batch-organize content in Google Photos using Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/googlephotos](https://composio.dev/toolkits/googlephotos)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Photos connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googlephotos`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googlephotos`
- 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
@@ -26,66 +24,101 @@ Automate Google Photos operations through Composio's Google Photos toolkit via R
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:
## Core Workflows
### 1. List Albums
Use `GOOGLEPHOTOS_LIST_ALBUMS` to retrieve all albums visible in the user's Albums tab.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google Photos operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLEPHOTOS_LIST_ALBUMS
Parameters:
- pageSize: Number of albums per page
- pageToken: Pagination token
- excludeNonAppCreatedData: Only show albums created by this app
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Create a New Album
Use `GOOGLEPHOTOS_CREATE_ALBUM` to create a new album in Google Photos.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google Photos task"}]
session: {id: "existing_session_id"}
Tool: GOOGLEPHOTOS_CREATE_ALBUM
Parameters:
- title (required): Album title
```
### Step 2: Check Connection
### 3. Upload Media
Use `GOOGLEPHOTOS_UPLOAD_MEDIA` to upload an image or video file to Google Photos.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["googlephotos"]
session_id: "your_session_id"
Tool: GOOGLEPHOTOS_UPLOAD_MEDIA
Parameters:
- file_to_upload: Local file path to upload
- url: URL of file to upload (alternative to file_to_upload)
- file_name: Name for the uploaded file
- description: Description/caption for the media item
```
### Step 3: Execute Tools
### 4. Batch Upload and Create Media Items
Use `GOOGLEPHOTOS_BATCH_CREATE_MEDIA_ITEMS` to upload multiple files and create media items in one operation.
```
Tool: GOOGLEPHOTOS_BATCH_CREATE_MEDIA_ITEMS
Parameters:
- files: Local file paths to upload
- urls: URLs of files to upload
- media_files: Mixed input (files and URLs)
- albumId: Album to add items to
- albumPosition: Position within the album
```
### 5. Search Media Items
Use `GOOGLEPHOTOS_SEARCH_MEDIA_ITEMS` to search the user's photo library with filters.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: GOOGLEPHOTOS_SEARCH_MEDIA_ITEMS
Parameters:
- albumId: Filter by album
- filters: Search filters (date ranges, content categories, media types)
- orderBy: Sort order
- pageSize: Results per page
- pageToken: Pagination token
```
### 6. Add Items to an Album
Use `GOOGLEPHOTOS_BATCH_ADD_MEDIA_ITEMS` to add existing media items to an album.
```
Tool: GOOGLEPHOTOS_BATCH_ADD_MEDIA_ITEMS
Parameters:
- albumId (required): Target album ID
- mediaItemIds (required): Array of media item IDs to add
```
## Common Patterns
- **Create album then upload**: Use `GOOGLEPHOTOS_CREATE_ALBUM` to create an album, then `GOOGLEPHOTOS_BATCH_CREATE_MEDIA_ITEMS` with the album ID to upload and organize photos in one step.
- **List then organize**: Use `GOOGLEPHOTOS_SEARCH_MEDIA_ITEMS` or `GOOGLEPHOTOS_LIST_MEDIA_ITEMS` to find media item IDs, then `GOOGLEPHOTOS_BATCH_ADD_MEDIA_ITEMS` to add them to albums.
- **Update album metadata**: Use `GOOGLEPHOTOS_UPDATE_ALBUM` to change an album's title or cover photo.
- **Get album details**: Use `GOOGLEPHOTOS_GET_ALBUM` with an album ID to retrieve full album information.
- **Add enrichments**: Use `GOOGLEPHOTOS_ADD_ENRICHMENT` to add text overlays, locations, or map enrichments to album positions.
- **Upload from URLs**: Use the `url` parameter in `GOOGLEPHOTOS_UPLOAD_MEDIA` or `urls` in `GOOGLEPHOTOS_BATCH_CREATE_MEDIA_ITEMS` to upload images directly from web URLs.
## 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
- `GOOGLEPHOTOS_LIST_MEDIA_ITEMS` is **deprecated** -- prefer `GOOGLEPHOTOS_SEARCH_MEDIA_ITEMS` for listing and filtering media.
- `GOOGLEPHOTOS_UPLOAD_MEDIA` supports images up to **200MB** and videos up to a larger limit. Exceeding these will fail.
- Album IDs must be obtained from `GOOGLEPHOTOS_LIST_ALBUMS` or `GOOGLEPHOTOS_CREATE_ALBUM` responses -- they are opaque strings.
- `GOOGLEPHOTOS_BATCH_ADD_MEDIA_ITEMS` can only add items to albums **created by the app** or albums the user owns.
- The `filters` parameter in `GOOGLEPHOTOS_SEARCH_MEDIA_ITEMS` uses a specific Google Photos API filter structure -- consult the schema for date range and content category formats.
- Media items created via the API may not immediately appear in the Google Photos web UI due to processing delays.
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Photos-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `googlephotos` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| List albums | `GOOGLEPHOTOS_LIST_ALBUMS` | `pageSize`, `pageToken` |
| Create album | `GOOGLEPHOTOS_CREATE_ALBUM` | `title` |
| Get album | `GOOGLEPHOTOS_GET_ALBUM` | `albumId` |
| Update album | `GOOGLEPHOTOS_UPDATE_ALBUM` | `albumId`, `title`, `coverPhotoMediaItemId` |
| Upload media | `GOOGLEPHOTOS_UPLOAD_MEDIA` | `file_to_upload` or `url`, `description` |
| Batch upload | `GOOGLEPHOTOS_BATCH_CREATE_MEDIA_ITEMS` | `files` or `urls`, `albumId` |
| Search media | `GOOGLEPHOTOS_SEARCH_MEDIA_ITEMS` | `albumId`, `filters`, `pageSize` |
| List media items | `GOOGLEPHOTOS_LIST_MEDIA_ITEMS` | `pageSize`, `pageToken` |
| Add items to album | `GOOGLEPHOTOS_BATCH_ADD_MEDIA_ITEMS` | `albumId`, `mediaItemIds` |
| Add enrichment | `GOOGLEPHOTOS_ADD_ENRICHMENT` | `albumId`, `newEnrichmentItem`, `albumPosition` |
---
*Powered by [Composio](https://composio.dev)*

119
googleslides-automation/SKILL.md
View File

@@ -1,24 +1,22 @@
---
name: googleslides-automation
description: "Automate Google Slides tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google Slides tasks via Rube MCP (Composio): create presentations, add slides from Markdown, batch update, copy from templates, get thumbnails. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google Slides Automation via Rube MCP
Automate Google Slides operations through Composio's Google Slides toolkit via Rube MCP.
Create, edit, and manage Google Slides presentations programmatically using Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/googleslides](https://composio.dev/toolkits/googleslides)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Slides connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googleslides`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googleslides`
- 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
@@ -26,66 +24,93 @@ Automate Google Slides operations through Composio's Google Slides toolkit via R
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:
## Core Workflows
### 1. Create a Blank Presentation
Use `GOOGLESLIDES_PRESENTATIONS_CREATE` to initialize a new blank presentation.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google Slides operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLESLIDES_PRESENTATIONS_CREATE
Parameters:
- title (required): Title for the new presentation
- presentationId (optional): Specific ID to assign (usually auto-generated)
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Create Slides from Markdown
Use `GOOGLESLIDES_CREATE_SLIDES_MARKDOWN` to generate a full presentation from Markdown text. Content is automatically split into slides.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google Slides task"}]
session: {id: "existing_session_id"}
Tool: GOOGLESLIDES_CREATE_SLIDES_MARKDOWN
Parameters:
- title (required): Presentation title
- markdown_text (required): Markdown content (auto-split into slides)
```
### Step 2: Check Connection
### 3. Batch Update a Presentation
Use `GOOGLESLIDES_PRESENTATIONS_BATCH_UPDATE` to apply updates to an existing presentation using Markdown or raw API requests.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["googleslides"]
session_id: "your_session_id"
Tool: GOOGLESLIDES_PRESENTATIONS_BATCH_UPDATE
Parameters:
- presentationId (required): Target presentation ID
- markdown_text: Markdown content to update slides
- requests: Raw Google Slides API batch update requests
- writeControl: Write control settings
```
### Step 3: Execute Tools
### 4. Copy from Template
Use `GOOGLESLIDES_PRESENTATIONS_COPY_FROM_TEMPLATE` to duplicate an existing presentation as a template.
```
Tool: GOOGLESLIDES_PRESENTATIONS_COPY_FROM_TEMPLATE
Parameters:
- template_presentation_id (required): Source template presentation ID
- new_title (required): Title for the new copy
- parent_folder_id (optional): Google Drive folder for the copy
```
### 5. Get Presentation Details
Use `GOOGLESLIDES_PRESENTATIONS_GET` to retrieve the current state of a presentation including all slides and elements.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: GOOGLESLIDES_PRESENTATIONS_GET
Parameters:
- presentationId (required): Presentation ID to retrieve
- fields (optional): Specific fields to return
```
### 6. Generate Slide Thumbnails
Use `GOOGLESLIDES_PRESENTATIONS_PAGES_GET_THUMBNAIL` to generate a thumbnail image URL for a specific slide.
```
Tool: GOOGLESLIDES_PRESENTATIONS_PAGES_GET_THUMBNAIL
Parameters:
- presentationId (required): Presentation ID
- pageObjectId (required): Page/slide object ID
- thumbnailProperties.mimeType: Image format (e.g., PNG)
- thumbnailProperties.thumbnailSize: Thumbnail size
```
## Common Patterns
- **Markdown-first workflow**: Use `GOOGLESLIDES_CREATE_SLIDES_MARKDOWN` to quickly generate presentations from structured text. The tool auto-splits content into separate slides.
- **Template-based generation**: Use `GOOGLESLIDES_PRESENTATIONS_COPY_FROM_TEMPLATE` to copy a styled template, then `GOOGLESLIDES_PRESENTATIONS_BATCH_UPDATE` to fill in content.
- **Retrieve then modify**: Use `GOOGLESLIDES_PRESENTATIONS_GET` to inspect slide structure and object IDs, then `GOOGLESLIDES_PRESENTATIONS_BATCH_UPDATE` to make targeted changes.
- **Export thumbnails**: Use `GOOGLESLIDES_PRESENTATIONS_PAGES_GET` to list page object IDs, then `GOOGLESLIDES_PRESENTATIONS_PAGES_GET_THUMBNAIL` to generate preview images.
- **Share presentations**: Combine with `GOOGLEDRIVE_ADD_FILE_SHARING_PREFERENCE` (googledrive toolkit) to share after creation.
## 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
- `GOOGLESLIDES_CREATE_SLIDES_MARKDOWN` creates a brand-new presentation each time -- it cannot append to an existing one.
- `GOOGLESLIDES_PRESENTATIONS_BATCH_UPDATE` with raw `requests` requires knowledge of the Google Slides API request format. Prefer `markdown_text` for simpler updates.
- Page object IDs must be obtained from `GOOGLESLIDES_PRESENTATIONS_GET` before using thumbnail or page-get tools.
- The `presentationId` is the long alphanumeric string from the Google Slides URL (between `/d/` and `/edit`).
- Copying from a template requires the authenticated user to have at least read access to the template presentation.
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Slides-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `googleslides` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| Create blank presentation | `GOOGLESLIDES_PRESENTATIONS_CREATE` | `title` |
| Create from Markdown | `GOOGLESLIDES_CREATE_SLIDES_MARKDOWN` | `title`, `markdown_text` |
| Batch update slides | `GOOGLESLIDES_PRESENTATIONS_BATCH_UPDATE` | `presentationId`, `markdown_text` or `requests` |
| Copy from template | `GOOGLESLIDES_PRESENTATIONS_COPY_FROM_TEMPLATE` | `template_presentation_id`, `new_title` |
| Get presentation | `GOOGLESLIDES_PRESENTATIONS_GET` | `presentationId` |
| Get page details | `GOOGLESLIDES_PRESENTATIONS_PAGES_GET` | `presentationId`, `pageObjectId` |
| Get slide thumbnail | `GOOGLESLIDES_PRESENTATIONS_PAGES_GET_THUMBNAIL` | `presentationId`, `pageObjectId` |
---
*Powered by [Composio](https://composio.dev)*

139
googletasks-automation/SKILL.md
View File

@@ -1,24 +1,22 @@
---
name: googletasks-automation
description: "Automate Google Tasks tasks via Rube MCP (Composio). Always search tools first for current schemas."
description: "Automate Google Tasks via Rube MCP (Composio): create, list, update, delete, move, and bulk-insert tasks and task lists. Always search tools first for current schemas."
requires:
mcp: [rube]
---
# Google Tasks Automation via Rube MCP
Automate Google Tasks operations through Composio's Google Tasks toolkit via Rube MCP.
Create, manage, organize, and bulk-operate on Google Tasks and task lists using Rube MCP (Composio).
**Toolkit docs**: [composio.dev/toolkits/googletasks](https://composio.dev/toolkits/googletasks)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Tasks connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googletasks`
- Active connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `googletasks`
- 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
@@ -26,66 +24,113 @@ Automate Google Tasks operations through Composio's Google Tasks toolkit via Rub
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:
## Core Workflows
### 1. List All Task Lists
Use `GOOGLETASKS_LIST_TASK_LISTS` to fetch all available task lists for the authenticated user.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Google Tasks operations", known_fields: ""}]
session: {generate_id: true}
Tool: GOOGLETASKS_LIST_TASK_LISTS
Parameters:
- maxResults: Maximum task lists to return
- pageToken: Pagination token for next page
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
## Core Workflow Pattern
### Step 1: Discover Available Tools
### 2. Create a New Task
Use `GOOGLETASKS_INSERT_TASK` to add a new task to a specific task list.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Google Tasks task"}]
session: {id: "existing_session_id"}
Tool: GOOGLETASKS_INSERT_TASK
Parameters:
- tasklist_id (required): ID of the target task list
- title (required): Task title
- notes: Task description/notes
- due: Due date in RFC3339 format (e.g., "2025-01-20T00:00:00.000Z")
- status: "needsAction" or "completed"
- task_parent: Parent task ID (to create subtask)
- task_previous: Previous task ID (for ordering)
```
### Step 2: Check Connection
### 3. List All Tasks Across Lists
Use `GOOGLETASKS_LIST_ALL_TASKS` to fetch tasks across all task lists with optional filters.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["googletasks"]
session_id: "your_session_id"
Tool: GOOGLETASKS_LIST_ALL_TASKS
Parameters:
- max_tasks_total: Maximum total tasks to return
- showCompleted: Include completed tasks
- showDeleted: Include deleted tasks
- showHidden: Include hidden tasks
- dueMin / dueMax: Filter by due date range
- completedMin / completedMax: Filter by completion date
- updatedMin: Filter by last update time
- showAssigned: Include assigned tasks
```
### Step 3: Execute Tools
### 4. Update an Existing Task
Use `GOOGLETASKS_UPDATE_TASK` to modify a task's title, notes, due date, or status.
```
Tool: GOOGLETASKS_UPDATE_TASK
Parameters:
- tasklist_id (required): Task list ID
- task_id (required): Task ID to update
- title: New title
- notes: Updated notes
- due: New due date (RFC3339)
- status: "needsAction" or "completed"
```
### 5. Bulk Insert Tasks
Use `GOOGLETASKS_BULK_INSERT_TASKS` to create multiple tasks at once in a single operation.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: GOOGLETASKS_BULK_INSERT_TASKS
Parameters:
- tasklist_id (required): Target task list ID
- tasks (required): Array of task objects (each with title, notes, due, status)
- batch_size: Number of tasks per batch request
```
### 6. Delete or Clear Tasks
Use `GOOGLETASKS_DELETE_TASK` to remove a specific task, or `GOOGLETASKS_CLEAR_TASKS` to permanently remove all completed tasks from a list.
```
Tool: GOOGLETASKS_DELETE_TASK
Parameters:
- tasklist_id (required): Task list ID
- task_id (required): Task ID to delete
Tool: GOOGLETASKS_CLEAR_TASKS
Parameters:
- tasklist (required): Task list ID to clear completed tasks from
```
## Common Patterns
- **Get task list ID first**: Always start with `GOOGLETASKS_LIST_TASK_LISTS` to discover available task lists and their IDs before creating or listing tasks.
- **List then update**: Use `GOOGLETASKS_LIST_ALL_TASKS` or `GOOGLETASKS_LIST_TASKS` to find task IDs, then use `GOOGLETASKS_UPDATE_TASK` to modify them.
- **Mark complete**: Update a task with `status: "completed"` using `GOOGLETASKS_UPDATE_TASK`.
- **Create subtasks**: Use `GOOGLETASKS_INSERT_TASK` with the `task_parent` parameter set to the parent task's ID.
- **Reorder tasks**: Use `GOOGLETASKS_MOVE_TASK` to change a task's position within its list or reparent it.
- **Batch creation**: Use `GOOGLETASKS_BULK_INSERT_TASKS` for creating many tasks at once (e.g., importing from another system).
## 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
- Both `tasklist_id` and `task_id` are **required** for `GOOGLETASKS_UPDATE_TASK`, `GOOGLETASKS_DELETE_TASK`, and `GOOGLETASKS_GET_TASK`. You cannot operate on a task without knowing which list it belongs to.
- All date/time strings must be in **RFC3339 format** (e.g., `2025-01-20T00:00:00.000Z`). Other formats will be rejected.
- `GOOGLETASKS_CLEAR_TASKS` permanently deletes all **completed** tasks from a list. This action is irreversible.
- `GOOGLETASKS_LIST_ALL_TASKS` fetches across all lists but results may be paginated -- check for pagination tokens.
- Task list IDs are not the same as task list names. Always resolve names to IDs using `GOOGLETASKS_LIST_TASK_LISTS`.
- The default task list is typically named "My Tasks" but its ID is an opaque string, not "default" or "primary".
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Tasks-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `googletasks` |
| 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` |
| Action | Tool | Key Parameters |
|--------|------|----------------|
| List task lists | `GOOGLETASKS_LIST_TASK_LISTS` | `maxResults`, `pageToken` |
| List all tasks | `GOOGLETASKS_LIST_ALL_TASKS` | `max_tasks_total`, `showCompleted`, `dueMin` |
| List tasks in a list | `GOOGLETASKS_LIST_TASKS` | `tasklist_id`, `maxResults`, `showCompleted` |
| Get single task | `GOOGLETASKS_GET_TASK` | `tasklist_id`, `task_id` |
| Create task | `GOOGLETASKS_INSERT_TASK` | `tasklist_id`, `title`, `notes`, `due` |
| Bulk create tasks | `GOOGLETASKS_BULK_INSERT_TASKS` | `tasklist_id`, `tasks` |
| Update task | `GOOGLETASKS_UPDATE_TASK` | `tasklist_id`, `task_id`, `title`, `status` |
| Delete task | `GOOGLETASKS_DELETE_TASK` | `tasklist_id`, `task_id` |
| Move/reorder task | `GOOGLETASKS_MOVE_TASK` | `tasklist_id`, `task_id` |
| Clear completed | `GOOGLETASKS_CLEAR_TASKS` | `tasklist` |
---
*Powered by [Composio](https://composio.dev)*

158
gorgias-automation/SKILL.md
View File

@@ -1,91 +1,145 @@
---
name: gorgias-automation
description: "Automate Gorgias tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Gorgias Automation
description: "Automate e-commerce customer support workflows in Gorgias -- manage tickets, customers, tags, and teams through natural language commands."
requires:
mcp: [rube]
mcp:
- rube
---
# Gorgias Automation via Rube MCP
# Gorgias Automation
Automate Gorgias operations through Composio's Gorgias toolkit via Rube MCP.
Automate your Gorgias helpdesk operations directly from Claude Code. Create, update, and triage support tickets, manage customers, and organize your support team -- all without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/gorgias](https://composio.dev/toolkits/gorgias)
**Toolkit docs:** [composio.dev/toolkits/gorgias](https://composio.dev/toolkits/gorgias)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Gorgias connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `gorgias`
- 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. Add the Rube MCP server to your Claude Code config with URL: `https://rube.app/mcp`
2. When prompted, authenticate your Gorgias account through the connection link provided
3. Start automating your support workflows with natural language
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `gorgias`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List and Filter Tickets
Retrieve tickets with filtering by status, channel, assignee, date range, and more.
**Tool:** `GORGIAS_LIST_TICKETS`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Gorgias operations", known_fields: ""}]
session: {generate_id: true}
List all open tickets from the email channel created in the last 7 days
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Key parameters:
- `status` -- filter by ticket status (e.g., "open", "closed")
- `channel` -- filter by channel (e.g., "email", "chat")
- `assignee_user_id` / `assignee_team_id` -- filter by assigned agent or team
- `created_from` / `created_to` -- ISO date range filters
- `limit` (max 100) / `offset` -- pagination controls
- `order_by` / `order_dir` -- sorting options
## Core Workflow Pattern
### 2. Create and Update Tickets
### Step 1: Discover Available Tools
Create new tickets or update existing ones with assignment, priority, and status changes.
**Tools:** `GORGIAS_CREATE_TICKET`, `GORGIAS_UPDATE_TICKET`, `GORGIAS_GET_TICKET`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Gorgias task"}]
session: {id: "existing_session_id"}
Create a high-priority ticket for customer 12345 about a missing order with subject "Order #9876 not delivered"
```
### Step 2: Check Connection
- `GORGIAS_CREATE_TICKET` requires `customer_id`; accepts `subject`, `status`, `priority`, `channel`, `messages`, `tags`
- `GORGIAS_UPDATE_TICKET` requires `ticket_id`; all other fields are optional partial updates
- `GORGIAS_GET_TICKET` retrieves full ticket details by `ticket_id`
### 3. Manage Ticket Tags
Add tags to tickets for categorization, routing, and reporting.
**Tools:** `GORGIAS_ADD_TICKET_TAGS`, `GORGIAS_LIST_TICKET_TAGS`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["gorgias"]
session_id: "your_session_id"
Add tags 101 and 202 to ticket 5678, then show me all tags on that ticket
```
### Step 3: Execute Tools
- `GORGIAS_ADD_TICKET_TAGS` requires `ticket_id` and `tag_ids` (array of integers)
- `GORGIAS_LIST_TICKET_TAGS` requires `ticket_id` to retrieve current tags
### 4. Customer Management
Create new customers or merge duplicate customer records.
**Tools:** `GORGIAS_CREATE_CUSTOMER`, `GORGIAS_MERGE_CUSTOMERS`, `GORGIAS_LIST_CUSTOMERS`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Create a new customer named "Jane Doe" with email jane@example.com and phone channel
```
- `GORGIAS_CREATE_CUSTOMER` requires `name`; accepts `email`, `channels` (array with `type` and `value`), `external_id`, `address`, `data`
- `GORGIAS_MERGE_CUSTOMERS` requires `source_customer_id` and `target_customer_id` -- source is merged into target
- `GORGIAS_LIST_CUSTOMERS` retrieves customers with filtering options
### 5. Team and Account Operations
List teams, retrieve account info, and inspect ticket custom fields.
**Tools:** `GORGIAS_LIST_TEAMS`, `GORGIAS_GET_TEAM`, `GORGIAS_GET_ACCOUNT`, `GORGIAS_LIST_TICKET_FIELD_VALUES`
```
Show me all support teams in our Gorgias account
```
- `GORGIAS_GET_ACCOUNT` returns account-level metrics and configuration
- `GORGIAS_LIST_TEAMS` / `GORGIAS_GET_TEAM` manage team lookup
- `GORGIAS_LIST_TICKET_FIELD_VALUES` returns custom field values for a given ticket
### 6. Activity and Event Tracking
Monitor ticket activity and customer event history.
**Tools:** `GORGIAS_LIST_EVENTS`
```
List recent events to see what activity has happened across our support queue
```
- `GORGIAS_LIST_EVENTS` provides an activity timeline with filtering options
---
## 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
- **Pagination required:** `GORGIAS_LIST_TICKETS` uses `limit`/`offset` pagination. Failing to loop through pages will miss older tickets and produce incomplete data.
- **Filter specificity:** Missing or overly broad filters on `GORGIAS_LIST_TICKETS` can overload the export or omit the desired reporting window. Always set `created_from`/`created_to` for time-bound queries.
- **Custom fields are separate:** Key business KPIs may only exist in custom fields. You must query `GORGIAS_LIST_TICKET_FIELD_VALUES` explicitly to include them.
- **Rate limits:** High-volume exports across `GORGIAS_LIST_TICKETS` and related endpoints can hit Gorgias rate limits. Add backoff and resume from the last offset.
- **Auth errors:** 401/403 responses on any Gorgias tool indicate token or permission issues. Do not treat partial data as a complete dataset.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Gorgias-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `gorgias` |
| 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` |
| Tool Slug | Description |
|---|---|
| `GORGIAS_LIST_TICKETS` | List tickets with filters (status, channel, date, assignee) |
| `GORGIAS_GET_TICKET` | Retrieve a specific ticket by ID |
| `GORGIAS_CREATE_TICKET` | Create a new ticket (requires `customer_id`) |
| `GORGIAS_UPDATE_TICKET` | Update ticket fields (requires `ticket_id`) |
| `GORGIAS_ADD_TICKET_TAGS` | Add tags to a ticket |
| `GORGIAS_LIST_TICKET_TAGS` | List all tags on a ticket |
| `GORGIAS_LIST_TICKET_FIELD_VALUES` | List custom field values for a ticket |
| `GORGIAS_CREATE_CUSTOMER` | Create a new customer (requires `name`) |
| `GORGIAS_MERGE_CUSTOMERS` | Merge two customer records |
| `GORGIAS_LIST_CUSTOMERS` | List customers with filters |
| `GORGIAS_LIST_TEAMS` | List all teams |
| `GORGIAS_GET_TEAM` | Retrieve a specific team |
| `GORGIAS_GET_ACCOUNT` | Retrieve account information |
| `GORGIAS_LIST_EVENTS` | List activity events with filters |
---
*Powered by [Composio](https://composio.dev)*

144
groqcloud-automation/SKILL.md
View File

@@ -1,91 +1,117 @@
---
name: groqcloud-automation
description: "Automate Groqcloud tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: GroqCloud Automation
description: "Automate AI inference, chat completions, audio translation, and TTS voice management through GroqCloud's high-performance API via Composio"
requires:
mcp: [rube]
mcp:
- rube
---
# Groqcloud Automation via Rube MCP
# GroqCloud Automation
Automate Groqcloud operations through Composio's Groqcloud toolkit via Rube MCP.
Automate AI inference workflows using GroqCloud's ultra-fast API -- chat completions, model discovery, audio translation, and TTS voice selection -- all orchestrated through the Composio MCP integration.
**Toolkit docs**: [composio.dev/toolkits/groqcloud](https://composio.dev/toolkits/groqcloud)
**Toolkit docs:** [composio.dev/toolkits/groqcloud](https://composio.dev/toolkits/groqcloud)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Groqcloud connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `groqcloud`
- 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. Connect your GroqCloud account through the Composio MCP server at `https://rube.app/mcp`
2. The agent will prompt you with an authentication link if no active connection exists
3. Once connected, all `GROQCLOUD_*` tools become available for execution
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `groqcloud`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Discover Available Models
List all models available on GroqCloud to find valid model IDs before running inference.
**Tool:** `GROQCLOUD_LIST_MODELS`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Groqcloud operations", known_fields: ""}]
session: {generate_id: true}
No parameters required -- returns all available models with metadata.
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Use this as a prerequisite before any chat completion call to ensure you reference a valid, non-deprecated model ID.
## Core Workflow Pattern
---
### Step 1: Discover Available Tools
### 2. Run Chat Completions
Generate AI responses for conversational prompts using a specified GroqCloud model.
**Tool:** `GROQCLOUD_GROQ_CREATE_CHAT_COMPLETION`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `model` | string | Yes | Model ID from `GROQCLOUD_LIST_MODELS` |
| `messages` | array | Yes | Ordered list of `{role, content}` objects (`system`, `user`, `assistant`) |
| `temperature` | number | No | Sampling temperature 0-2 (default: 1) |
| `max_completion_tokens` | integer | No | Max tokens to generate |
| `top_p` | number | No | Nucleus sampling 0-1 (default: 1) |
| `stop` | string/array | No | Up to 4 stop sequences |
| `stream` | boolean | No | Enable SSE streaming (default: false) |
---
### 3. Inspect Model Details
Retrieve detailed metadata for a specific model including context window and capabilities.
**Tool:** `GROQCLOUD_GROQ_RETRIEVE_MODEL`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `model` | string | Yes | Model identifier (e.g., `groq-1-large`) |
---
### 4. Translate Audio to English
Translate non-English audio files into English text using Whisper models.
**Tool:** `GROQCLOUD_GROQ_CREATE_AUDIO_TRANSLATION`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `file_path` | string | Yes | Local path, HTTP(S) URL, or base64 data URL for audio |
| `model` | string | No | Model ID (default: `whisper-large-v3`). Note: `whisper-large-v3-turbo` may not support translations |
| `response_format` | string | No | `json`, `verbose_json`, or `text` (default: `json`) |
| `temperature` | number | No | Sampling temperature 0-1 (default: 0) |
---
### 5. List TTS Voices
Enumerate available text-to-speech voices for Groq PlayAI models to drive voice selection UX.
**Tool:** `GROQCLOUD_LIST_VOICES`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Groqcloud task"}]
session: {id: "existing_session_id"}
Returns the set of supported TTS voices. Note: this is a static list maintained manually.
```
### Step 2: Check Connection
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["groqcloud"]
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
| Pitfall | Details |
|---------|---------|
| **Nested model list** | `GROQCLOUD_LIST_MODELS` response may be nested at `response['data']['data']` -- do not assume a flat top-level array |
| **Hard-coded model IDs break** | Always fetch model IDs dynamically via `GROQCLOUD_LIST_MODELS`; hard-coded names can break when models are deprecated or renamed |
| **Audio format validation** | `GROQCLOUD_GROQ_CREATE_AUDIO_TRANSLATION` rejects invalid or unsupported audio formats silently -- validate inputs before calling |
| **Model metadata drifts** | Data from `GROQCLOUD_GROQ_RETRIEVE_MODEL` (context window, features) can change as models update -- do not treat it as static |
| **TTS voice changes** | Voice sets from `GROQCLOUD_LIST_VOICES` may shrink or rename over time -- handle missing voices gracefully |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Groqcloud-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `groqcloud` |
| 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` |
| Tool Slug | Purpose |
|-----------|---------|
| `GROQCLOUD_LIST_MODELS` | List all available models and metadata |
| `GROQCLOUD_GROQ_CREATE_CHAT_COMPLETION` | Generate chat-based AI completions |
| `GROQCLOUD_GROQ_RETRIEVE_MODEL` | Get detailed info for a specific model |
| `GROQCLOUD_GROQ_CREATE_AUDIO_TRANSLATION` | Translate non-English audio to English text |
| `GROQCLOUD_LIST_VOICES` | Retrieve available TTS voices for PlayAI |
---
*Powered by [Composio](https://composio.dev)*

152
gumroad-automation/SKILL.md
View File

@@ -1,91 +1,123 @@
---
name: gumroad-automation
description: "Automate Gumroad tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Gumroad Automation
description: "Automate Gumroad product management, sales tracking, license verification, and webhook subscriptions using natural language through the Composio MCP integration."
category: e-commerce
requires:
mcp: [rube]
mcp:
- rube
---
# Gumroad Automation via Rube MCP
# Gumroad Automation
Automate Gumroad operations through Composio's Gumroad toolkit via Rube MCP.
Automate your Gumroad storefront -- list products, track sales, verify licenses, and manage real-time webhooks -- all through natural language commands.
**Toolkit docs**: [composio.dev/toolkits/gumroad](https://composio.dev/toolkits/gumroad)
**Toolkit docs:** [composio.dev/toolkits/gumroad](https://composio.dev/toolkits/gumroad)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Gumroad connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `gumroad`
- 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. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Connect your Gumroad account when prompted (API key authentication).
3. Start issuing natural language commands to manage your Gumroad store.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `gumroad`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List All Products
Retrieve every product in your authenticated Gumroad account to get product IDs for downstream operations.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Gumroad operations", known_fields: ""}]
session: {generate_id: true}
```
**Tool:** `GUMROAD_LIST_PRODUCTS`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Example prompt:**
> "List all my Gumroad products"
## Core Workflow Pattern
**Parameters:** None required -- returns all products for the authenticated account.
### Step 1: Discover Available Tools
---
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Gumroad task"}]
session: {id: "existing_session_id"}
```
### 2. Track Sales with Filters
Retrieve successful sales with optional filtering by email, date range, product, or pagination.
### Step 2: Check Connection
**Tool:** `GUMROAD_GET_SALES`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["gumroad"]
session_id: "your_session_id"
```
**Example prompt:**
> "Show me all Gumroad sales from January 2025 for product prod_ABC123"
### Step 3: Execute Tools
**Key parameters:**
- `after` -- ISO8601 date/time to filter sales after (e.g., `2025-01-01T00:00:00Z`)
- `before` -- ISO8601 date/time to filter sales before
- `email` -- Filter by customer email address
- `product_id` -- Filter by specific product ID
- `page` -- Page number for paginated results (minimum 1)
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
---
### 3. Verify License Keys
Check if a license key is valid against a specific product, inspect usage count, or verify membership entitlement.
**Tool:** `GUMROAD_VERIFY_LICENSE`
**Example prompt:**
> "Verify license key ABCD-EFGH-IJKL-MNOP for product prod_ABC123"
**Key parameters (all required):**
- `product_id` -- The product ID to verify against (required for products created on/after Jan 9, 2023)
- `license_key` -- The license key string (e.g., `ABCD-EFGH-IJKL-MNOP`)
- `increment_uses_count` -- Whether to increment usage count (defaults to true)
---
### 4. Subscribe to Webhook Events
Set up real-time event notifications by subscribing your endpoint URL to specific Gumroad resource events.
**Tool:** `GUMROAD_SUBSCRIBE_TO_RESOURCE`
**Example prompt:**
> "Subscribe my webhook https://example.com/hook to Gumroad sale events"
**Key parameters (all required):**
- `resource_name` -- One of: `sale`, `refund`, `dispute`, `dispute_won`, `cancellation`, `subscription_updated`, `subscription_ended`, `subscription_restarted`
- `post_url` -- Your endpoint URL that receives HTTP POST notifications
---
### 5. List Active Webhook Subscriptions
Review existing webhook subscriptions for a given resource type before adding new ones to avoid duplicates.
**Tool:** `GUMROAD_GET_RESOURCE_SUBSCRIPTIONS`
**Example prompt:**
> "Show all my active Gumroad webhook subscriptions for sale events"
**Key parameters (required):**
- `resource_name` -- One of the eight supported event types (e.g., `sale`, `refund`)
---
## 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
- **Product ID required for license verification**: Products created on or after January 9, 2023 require the `product_id` parameter. Older products may work without it but providing it is recommended.
- **Pagination on sales**: Sales results are paginated. Always check if more pages exist by incrementing the `page` parameter.
- **Webhook deduplication**: Before subscribing to a resource, use `GUMROAD_GET_RESOURCE_SUBSCRIPTIONS` to check for existing subscriptions and avoid duplicate webhooks.
- **ISO8601 date format**: Date filters on sales must use ISO8601 format (e.g., `2025-01-01T00:00:00Z`), not plain dates.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Gumroad-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `gumroad` |
| 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` |
| Action | Tool Slug | Required Params |
|---|---|---|
| List products | `GUMROAD_LIST_PRODUCTS` | None |
| Get sales | `GUMROAD_GET_SALES` | None (all optional filters) |
| Verify license | `GUMROAD_VERIFY_LICENSE` | `product_id`, `license_key` |
| Subscribe to events | `GUMROAD_SUBSCRIBE_TO_RESOURCE` | `resource_name`, `post_url` |
| List webhook subs | `GUMROAD_GET_RESOURCE_SUBSCRIPTIONS` | `resource_name` |
---
*Powered by [Composio](https://composio.dev)*

166
harvest-automation/SKILL.md
View File

@@ -1,91 +1,153 @@
---
name: harvest-automation
description: "Automate Harvest tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Harvest Automation
description: "Automate time tracking, project management, and invoicing workflows in Harvest -- log hours, manage projects, clients, and tasks through natural language commands."
requires:
mcp: [rube]
mcp:
- rube
---
# Harvest Automation via Rube MCP
# Harvest Automation
Automate Harvest operations through Composio's Harvest toolkit via Rube MCP.
Automate your Harvest time tracking operations directly from Claude Code. Log time entries, manage projects and clients, create tasks, and pull reporting data -- all without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/harvest](https://composio.dev/toolkits/harvest)
**Toolkit docs:** [composio.dev/toolkits/harvest](https://composio.dev/toolkits/harvest)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Harvest connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `harvest`
- 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. Add the Rube MCP server to your Claude Code config with URL: `https://rube.app/mcp`
2. When prompted, authenticate your Harvest account through the connection link provided
3. Start automating your time tracking workflows with natural language
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `harvest`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Log and Manage Time Entries
Create, list, update, and retrieve time entries for accurate billing and reporting.
**Tools:** `HARVEST_CREATE_TIME_ENTRY`, `HARVEST_LIST_TIME_ENTRIES`, `HARVEST_GET_TIME_ENTRY`, `HARVEST_UPDATE_TIME_ENTRY`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Harvest operations", known_fields: ""}]
session: {generate_id: true}
Log 3.5 hours of development work on project 12345, task 67890 for today
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Key parameters for `HARVEST_CREATE_TIME_ENTRY`:
- `project_id` (required) -- the project to log against
- `task_id` (required) -- the task must be assigned to the project
- `spent_date` (required) -- date in YYYY-MM-DD format
- `hours` -- total hours (for duration-based accounts)
- `started_time` / `ended_time` -- for timestamp-based accounts
- `notes` -- description of work performed
## Core Workflow Pattern
Key parameters for `HARVEST_LIST_TIME_ENTRIES`:
- `from_date` / `to` -- date range filters (YYYY-MM-DD)
- `project_id`, `client_id`, `task_id`, `user_id` -- entity filters
- `is_billed` / `is_running` -- status filters
- `page` / `per_page` (max 2000) -- pagination
### Step 1: Discover Available Tools
### 2. Manage Projects
Create new projects and list existing ones with client and billing configuration.
**Tools:** `HARVEST_CREATE_PROJECT`, `HARVEST_LIST_PROJECTS`, `HARVEST_GET_PROJECT`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Harvest task"}]
session: {id: "existing_session_id"}
Create a billable project called "Website Redesign" for client 456 with Tasks billing and project budget
```
### Step 2: Check Connection
Key parameters for `HARVEST_CREATE_PROJECT`:
- `name`, `client_id`, `is_billable`, `bill_by`, `budget_by` (all required)
- `bill_by` options: `"Project"`, `"Tasks"`, `"People"`, `"none"`
- `budget_by` options: `"project"`, `"project_cost"`, `"task"`, `"task_fees"`, `"person"`, `"none"`
- Optional: `budget`, `hourly_rate`, `starts_on`, `ends_on`, `is_fixed_fee`
### 3. Manage Clients
Create and list clients that projects are organized under.
**Tools:** `HARVEST_CREATE_CLIENT`, `HARVEST_LIST_CLIENTS`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["harvest"]
session_id: "your_session_id"
List all active clients in our Harvest account
```
### Step 3: Execute Tools
- `HARVEST_CREATE_CLIENT` requires `name`; accepts `address`, `currency`, `is_active`
- `HARVEST_LIST_CLIENTS` supports `is_active` filter and pagination (`per_page` max 2000)
### 4. Manage Tasks
Create and list reusable task types for time tracking.
**Tools:** `HARVEST_CREATE_TASK`, `HARVEST_LIST_TASKS`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Create a new billable task called "Code Review" with a default rate of $150/hr
```
- `HARVEST_CREATE_TASK` requires `name`; accepts `billable_by_default`, `default_hourly_rate`, `is_active`, `is_default`
- `HARVEST_LIST_TASKS` supports `is_active`, `is_default` filters and pagination (`per_page` max 100)
- Task names must be unique across all tasks (active and archived)
### 5. Time Entry Reporting
Pull time entries with date ranges and filters for billing summaries and utilization reports.
**Tools:** `HARVEST_LIST_TIME_ENTRIES`, `HARVEST_GET_TIME_ENTRY`
```
Show me all unbilled time entries for project 789 from January 2026
```
- Use `from_date` and `to` for date windowing
- Filter with `is_billed: false` for unbilled entries
- Combine `project_id`, `user_id`, `client_id` for cross-dimensional reporting
- Paginate with `page` and `per_page` to gather complete datasets
### 6. Update and Correct Time Entries
Modify existing time entries to fix hours, reassign projects, or update notes.
**Tools:** `HARVEST_UPDATE_TIME_ENTRY`
```
Update time entry 123456 to change the hours to 4.0 and add the note "Completed API integration"
```
- Requires `time_entry_id`
- Supports partial updates -- only include fields you want to change
- Can update `hours`, `notes`, `project_id`, `task_id`, `spent_date`, `started_time`, `ended_time`
---
## 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
- **Task assignment matters:** When creating time entries, the `task_id` must correspond to a task that is actually assigned to the specified `project_id`. Use project task assignments endpoint to verify, not just `HARVEST_LIST_TASKS` (which returns global tasks).
- **Duration vs. timestamp tracking:** Harvest accounts are configured for either duration-based or timestamp-based tracking. `hours` is ignored on timestamp accounts; `started_time`/`ended_time` are ignored on duration accounts.
- **Pagination limits vary:** `HARVEST_LIST_TIME_ENTRIES` and `HARVEST_LIST_CLIENTS` support up to 2000 per page, but `HARVEST_LIST_PROJECTS` and `HARVEST_LIST_TASKS` cap at 100 per page.
- **Date format consistency:** All date parameters must use `YYYY-MM-DD` format. ISO 8601 with timezone is used for `updated_since` filters.
- **Required fields for projects:** `HARVEST_CREATE_PROJECT` requires five fields: `name`, `client_id`, `is_billable`, `bill_by`, and `budget_by`. Missing any will cause a validation error.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Harvest-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `harvest` |
| 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` |
| Tool Slug | Description |
|---|---|
| `HARVEST_LIST_TIME_ENTRIES` | List time entries with date, project, client, user filters |
| `HARVEST_CREATE_TIME_ENTRY` | Log a new time entry (requires `project_id`, `task_id`, `spent_date`) |
| `HARVEST_GET_TIME_ENTRY` | Retrieve a specific time entry by ID |
| `HARVEST_UPDATE_TIME_ENTRY` | Update an existing time entry (requires `time_entry_id`) |
| `HARVEST_LIST_PROJECTS` | List projects with optional client filter |
| `HARVEST_CREATE_PROJECT` | Create a new project with billing config |
| `HARVEST_GET_PROJECT` | Retrieve a specific project by ID |
| `HARVEST_LIST_CLIENTS` | List clients with active/inactive filter |
| `HARVEST_CREATE_CLIENT` | Create a new client (requires `name`) |
| `HARVEST_LIST_TASKS` | List reusable task types |
| `HARVEST_CREATE_TASK` | Create a new task type (requires `name`) |
---
*Powered by [Composio](https://composio.dev)*

142
heygen-automation/SKILL.md
View File

@@ -1,91 +1,121 @@
---
name: heygen-automation
description: "Automate Heygen tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: HeyGen Automation
description: "Automate AI video generation, avatar browsing, template-based video creation, and video status tracking through HeyGen's platform via Composio"
requires:
mcp: [rube]
mcp:
- rube
---
# Heygen Automation via Rube MCP
# HeyGen Automation
Automate Heygen operations through Composio's Heygen toolkit via Rube MCP.
Automate AI-powered video creation workflows -- browse avatars and templates, generate personalized videos from templates, track processing status, and retrieve shareable URLs -- all orchestrated through the Composio MCP integration.
**Toolkit docs**: [composio.dev/toolkits/heygen](https://composio.dev/toolkits/heygen)
**Toolkit docs:** [composio.dev/toolkits/heygen](https://composio.dev/toolkits/heygen)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Heygen connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `heygen`
- 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. Connect your HeyGen account through the Composio MCP server at `https://rube.app/mcp`
2. The agent will prompt you with an authentication link if no active connection exists
3. Once connected, all `HEYGEN_*` tools become available for execution
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `heygen`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Browse Available Templates
Retrieve pre-designed avatar templates from the HeyGen library for video creation.
**Tool:** `HEYGEN_V2_TEMPLATES`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Heygen operations", known_fields: ""}]
session: {generate_id: true}
No parameters required -- returns template IDs, names, preview images, and customization options.
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Use this to discover templates before generating videos. Each template has a unique ID needed for generation.
## Core Workflow Pattern
---
### Step 1: Discover Available Tools
### 2. Inspect Template Details & Variables
Retrieve the full structure of a template including all variables, scene mappings, and customization options.
**Tool:** `HEYGEN_RETRIEVE_TEMPLATE_DETAILS_V3`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `template_id` | string | Yes | Template ID from `HEYGEN_V2_TEMPLATES` or the HeyGen dashboard |
This is a **required prerequisite** before generating videos -- it tells you exactly which variables must be populated.
---
### 3. Browse Available Avatars
List all realistic avatars available for video creation, useful for mapping characters to scenes.
**Tool:** `HEYGEN_V2_AVATARS`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Heygen task"}]
session: {id: "existing_session_id"}
No parameters required -- returns avatar identifiers, names, and preview images.
The list may be paginated; additional calls might be needed for the full set.
```
### Step 2: Check Connection
---
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["heygen"]
session_id: "your_session_id"
```
### 4. Generate Video from Template
Create a customized video by populating a template with your variables and content.
### Step 3: Execute Tools
**Tool:** `HEYGEN_V2_TEMPLATE_GENERATE`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
Provide a video title and all template variables discovered via `HEYGEN_RETRIEVE_TEMPLATE_DETAILS_V3`. Every required variable must be supplied with exact names and types.
---
### 5. Check Video Processing Status
Poll the processing status and retrieve metadata for a video being generated.
**Tool:** `HEYGEN_RETRIEVE_VIDEO_STATUS_DETAILS`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `video_id` | string | Yes | Video ID returned from the generation API |
Returned URLs expire after 7 days but can be regenerated by calling this endpoint again.
---
### 6. Get Shareable Video URL
Generate a public, shareable link that allows anyone to view the video without authentication.
**Tool:** `HEYGEN_RETRIEVE_SHARABLE_VIDEO_URL`
Provide the `video_id` to receive a public URL for distribution.
---
## 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
| Pitfall | Details |
|---------|---------|
| **All template variables required** | `HEYGEN_V2_TEMPLATE_GENERATE` demands every variable from `HEYGEN_RETRIEVE_TEMPLATE_DETAILS_V3` with exact names and types -- missing or misnamed fields break scenes or fail generation |
| **Always inspect templates first** | Never skip `HEYGEN_RETRIEVE_TEMPLATE_DETAILS_V3` before generation -- multi-scene templates have complex variable structures |
| **Video URLs expire** | URLs from `HEYGEN_RETRIEVE_VIDEO_STATUS_DETAILS` expire after 7 days; regenerate by calling the endpoint again |
| **Paginated avatar lists** | `HEYGEN_V2_AVATARS` may return paginated results -- additional calls may be needed for the full library |
| **Processing time varies** | Video generation is asynchronous; poll `HEYGEN_RETRIEVE_VIDEO_STATUS_DETAILS` until status is complete before using output URLs |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Heygen-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `heygen` |
| 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` |
| Tool Slug | Purpose |
|-----------|---------|
| `HEYGEN_V2_TEMPLATES` | List available video templates |
| `HEYGEN_RETRIEVE_TEMPLATE_DETAILS_V3` | Get template variables and scene structure |
| `HEYGEN_V2_AVATARS` | Browse available AI avatars |
| `HEYGEN_V2_TEMPLATE_GENERATE` | Generate video from a template |
| `HEYGEN_RETRIEVE_VIDEO_STATUS_DETAILS` | Check video processing status and get URLs |
| `HEYGEN_RETRIEVE_SHARABLE_VIDEO_URL` | Get a public shareable video link |
---
*Powered by [Composio](https://composio.dev)*

181
hunter-automation/SKILL.md
View File

@@ -1,91 +1,152 @@
---
name: hunter-automation
description: "Automate Hunter tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Hunter Automation
description: "Automate Hunter.io email intelligence -- search domains for email addresses, find specific contacts, verify email deliverability, manage leads, and monitor account usage -- using natural language through the Composio MCP integration."
category: email-intelligence
requires:
mcp: [rube]
mcp:
- rube
---
# Hunter Automation via Rube MCP
# Hunter Automation
Automate Hunter operations through Composio's Hunter toolkit via Rube MCP.
Power your outreach with Hunter.io -- discover email addresses by domain, find specific people's emails, verify deliverability, save leads, and track your API usage -- all through natural language commands.
**Toolkit docs**: [composio.dev/toolkits/hunter](https://composio.dev/toolkits/hunter)
**Toolkit docs:** [composio.dev/toolkits/hunter](https://composio.dev/toolkits/hunter)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Hunter connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `hunter`
- 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. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Connect your Hunter.io account when prompted (API key authentication).
3. Start issuing natural language commands to find and verify emails.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `hunter`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Search Domain for Email Addresses
Discover all publicly available email addresses for a given domain or company, with filtering by department, seniority, and type.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Hunter operations", known_fields: ""}]
session: {generate_id: true}
```
**Tool:** `HUNTER_DOMAIN_SEARCH`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Example prompt:**
> "Find all executive email addresses at stripe.com using Hunter"
## Core Workflow Pattern
**Key parameters:**
- `domain` -- Domain to search (e.g., "stripe.com"). Required if `company` not provided.
- `company` -- Company name to search (e.g., "Stripe"). Required if `domain` not provided.
- `type` -- Filter by "personal" or "generic" emails
- `seniority` -- Filter by levels: "junior", "senior", "executive" (array)
- `department` -- Filter by departments: "executive", "it", "finance", "sales", etc. (array)
- `required_field` -- Require specific fields: "full_name", "position", "phone_number" (array)
- `limit` -- Max results per request (1-100, default 10; free/basic plans limited to 10)
- `offset` -- Skip results for pagination (default 0)
### Step 1: Discover Available Tools
---
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Hunter task"}]
session: {id: "existing_session_id"}
```
### 2. Find a Specific Person's Email
Infer the most likely email address for a person given their name and domain or company.
### Step 2: Check Connection
**Tool:** `HUNTER_EMAIL_FINDER`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["hunter"]
session_id: "your_session_id"
```
**Example prompt:**
> "Find the email for Alexis Ohanian at reddit.com using Hunter"
### Step 3: Execute Tools
**Key parameters:**
- `domain` -- Target domain (e.g., "reddit.com"). Takes precedence over `company`.
- `company` -- Company name (e.g., "Reddit"). Used if domain not provided.
- Name (one of these combinations required):
- `first_name` + `last_name` (e.g., "Alexis" + "Ohanian")
- `full_name` (e.g., "Alexis Ohanian")
- `max_duration` -- Max request duration in seconds (3-20, default 10). Longer durations yield more accurate results.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
---
### 3. Verify Email Deliverability
Check whether an email address is valid, deliverable, and safe to send to.
**Tool:** `HUNTER_EMAIL_VERIFIER`
**Example prompt:**
> "Verify if john.doe@example.com is a valid email address"
**Key parameters:**
- `email` (required) -- The email address to verify (e.g., "john.doe@example.com")
**Response includes:** verification status, deliverability score, MX record validation, and risk assessment.
---
### 4. Get Email Volume Estimates
Check how many email addresses Hunter has for a domain or company -- this call is free and does not consume API credits.
**Tool:** `HUNTER_EMAIL_COUNT`
**Example prompt:**
> "How many email addresses does Hunter have for stripe.com?"
**Key parameters:**
- `domain` -- Domain to query (e.g., "stripe.com"). Required if `company` not provided.
- `company` -- Company name (min 3 characters). Required if `domain` not provided.
- `type` -- Filter count by "personal" or "generic" emails
**Returns:** Total count with breakdowns by type, department, and seniority level.
---
### 5. Save and Manage Leads
Create or update leads by email in a single upsert call -- no need to check existence first.
**Tool:** `HUNTER_UPSERT_LEAD`
**Example prompt:**
> "Save john@stripe.com as a lead in Hunter with name John Doe, position CTO"
**Key parameters:**
- `email` -- Lead's email address (primary identifier for upsert)
- Name, position, company, and other lead metadata
---
### 6. Check Account Usage and Limits
Review your Hunter account plan details, remaining searches, and verification quotas before running bulk operations.
**Tool:** `HUNTER_ACCOUNT_INFORMATION`
**Example prompt:**
> "How many Hunter API searches do I have left this month?"
**Key parameters:** None required.
---
## 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
- **HTTP 401 means invalid credentials**: `authentication_failed` errors indicate an invalid or expired API key. Fix before attempting bulk operations.
- **Email counts are estimates**: `HUNTER_EMAIL_COUNT` returns approximate numbers for sizing and prioritization, not guaranteed retrievable email counts.
- **Domain search uses offset pagination**: `HUNTER_DOMAIN_SEARCH` paginates via `limit`/`offset`. Do not assume the first page is complete -- continue fetching until results are empty or you hit a cap.
- **Empty results are not errors**: `HUNTER_DOMAIN_SEARCH` can return `emails: []` with no error. Treat as "no data found" and continue, rather than retrying as a failure.
- **Verification status nuances**: `accept_all` or `risky` statuses from `HUNTER_EMAIL_VERIFIER` indicate uncertainty. Exclude these from strict deliverability workflows or handle them separately.
- **Free/basic plan limits**: Free and basic plans limit `HUNTER_DOMAIN_SEARCH` to 10 results per request. Higher limits require a paid plan.
- **Domain format matters**: Use bare domains like "stripe.com" -- do not include protocol ("https://") or "www." prefix.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Hunter-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `hunter` |
| 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` |
| Action | Tool Slug | Required Params |
|---|---|---|
| Search domain emails | `HUNTER_DOMAIN_SEARCH` | `domain` or `company` |
| Find person's email | `HUNTER_EMAIL_FINDER` | Name + (`domain` or `company`) |
| Verify email | `HUNTER_EMAIL_VERIFIER` | `email` |
| Get email count | `HUNTER_EMAIL_COUNT` | `domain` or `company` |
| Save/update lead | `HUNTER_UPSERT_LEAD` | `email` |
| Check account | `HUNTER_ACCOUNT_INFORMATION` | None |
---
*Powered by [Composio](https://composio.dev)*

200
instantly-automation/SKILL.md
View File

@@ -1,91 +1,171 @@
---
name: instantly-automation
description: "Automate Instantly tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Instantly Automation
description: "Automate Instantly cold email outreach -- manage campaigns, sending accounts, lead lists, bulk lead imports, and campaign analytics -- using natural language through the Composio MCP integration."
category: email-outreach
requires:
mcp: [rube]
mcp:
- rube
---
# Instantly Automation via Rube MCP
# Instantly Automation
Automate Instantly operations through Composio's Instantly toolkit via Rube MCP.
Automate your cold email outreach with Instantly -- create and manage campaigns with multi-step sequences, configure sending schedules, import leads in bulk, manage sending accounts, and track campaign performance -- all through natural language commands.
**Toolkit docs**: [composio.dev/toolkits/instantly](https://composio.dev/toolkits/instantly)
**Toolkit docs:** [composio.dev/toolkits/instantly](https://composio.dev/toolkits/instantly)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Instantly connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `instantly`
- 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. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Connect your Instantly account when prompted (API key authentication).
3. Start issuing natural language commands to manage your outreach campaigns.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `instantly`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List Sending Accounts
Retrieve all email accounts configured in your Instantly workspace, with filtering by status and provider.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Instantly operations", known_fields: ""}]
session: {generate_id: true}
```
**Tool:** `INSTANTLY_LIST_ACCOUNTS`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Example prompt:**
> "Show all active sending accounts in my Instantly workspace"
## Core Workflow Pattern
**Key parameters:**
- `status` -- Filter by status: `1` (Active), `2` (Paused), `-1` (Connection Error), `-2` (Soft Bounce Error), `-3` (Sending Error)
- `provider_code` -- Filter by provider: `1` (Custom IMAP/SMTP), `2` (Google), `3` (Microsoft), `4` (AWS)
- `search` -- Search by email substring or domain
- `limit` -- Max items (1-100)
- `starting_after` -- Pagination cursor from previous response
- `tag_ids` -- Comma-separated tag UUIDs
### Step 1: Discover Available Tools
---
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Instantly task"}]
session: {id: "existing_session_id"}
```
### 2. Create a Campaign
Launch a new outreach campaign with scheduling, email sequences, A/B testing variants, and sending configuration.
### Step 2: Check Connection
**Tool:** `INSTANTLY_CREATE_CAMPAIGN`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["instantly"]
session_id: "your_session_id"
```
**Example prompt:**
> "Create an Instantly campaign called 'Q1 Outreach' that sends Monday-Friday 9am-5pm Central time with a 3-step email sequence"
### Step 3: Execute Tools
**Key parameters:**
- `name` (required) -- Campaign name
- `campaign_schedule` (required) -- Schedule configuration:
- `schedules` (required) -- Array of schedule objects, each with:
- `name` -- Schedule name
- `timing` -- `{from: "09:00", to: "17:00"}` (HH:mm format)
- `days` -- Map of day index strings "0" (Sun) to "6" (Sat) to booleans
- `timezone` -- Supported values include "America/Chicago", "America/Detroit", "America/Boise", "America/Anchorage"
- `start_date` / `end_date` -- ISO 8601 dates
- `email_list` -- Array of sending account email addresses (must be pre-configured accounts; use `INSTANTLY_LIST_ACCOUNTS` to discover valid addresses)
- `sequences` -- Array (only first element used) containing:
- `steps` -- Array of step objects with:
- `type` -- Must be "email"
- `delay` -- Days before NEXT email (integer, min 0)
- `variants` -- Array of `{subject, body}` objects for A/B testing
- `daily_limit` -- Daily sending cap
- `email_gap` -- Minutes between emails
- `stop_on_reply` -- Stop campaign when lead replies (boolean)
- `stop_on_auto_reply` -- Stop on auto-replies (boolean)
- `open_tracking` / `link_tracking` -- Enable tracking (booleans)
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Timezone notes:**
- Verified working: "America/Chicago" (Central), "America/Detroit" (Eastern), "America/Boise" (Mountain)
- Auto-mapped: "America/New_York" maps to "America/Detroit", "America/Denver" maps to "America/Boise"
- NOT supported: "America/Los_Angeles", "US/Pacific" -- use "America/Anchorage" or "America/Dawson" as alternatives
---
### 3. Update Campaign Settings
Modify an existing campaign's schedule, sending limits, sequences, or tracking settings.
**Tool:** `INSTANTLY_UPDATE_CAMPAIGN`
**Example prompt:**
> "Update my Instantly campaign to increase the daily limit to 100 and enable open tracking"
**Key parameters:**
- `id` (required) -- Campaign UUID
- Any combination of: `name`, `campaign_schedule`, `email_list`, `sequences`, `daily_limit`, `email_gap`, `stop_on_reply`, `open_tracking`, `link_tracking`, etc.
- Set any parameter to `null` to unset it
---
### 4. Manage Lead Lists and Bulk Import
Create dedicated lead lists and import prospects in bulk for campaign targeting.
**Tools:** `INSTANTLY_CREATE_LEAD_LIST`, `INSTANTLY_ADD_LEADS_BULK`
**Example prompt:**
> "Create a lead list called 'Q1 Prospects' and add 50 leads to my Instantly campaign"
**Key parameters for creating lead lists:**
- List name and configuration
**Key parameters for bulk lead import:**
- Campaign or list ID to import into
- Array of lead objects with email and metadata
- Duplicate handling options
- Lead verification settings
---
### 5. Review Campaign Details
Retrieve full campaign configuration to verify settings, inspect sequences, or prepare for updates.
**Tool:** `INSTANTLY_GET_CAMPAIGN`
**Example prompt:**
> "Show me the full details of my Instantly campaign"
**Key parameters:**
- `id` (required) -- Campaign UUID
---
### 6. List All Campaigns
Enumerate all campaigns in your workspace with optional filters and pagination.
**Tool:** `INSTANTLY_LIST_CAMPAIGNS`
**Example prompt:**
> "List all my Instantly campaigns"
**Key parameters:**
- Optional filters and pagination parameters
---
## 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
- **Timezone support is limited**: The Instantly API accepts a restricted set of timezone strings. Pacific Time ("America/Los_Angeles") is NOT supported. Use "America/Anchorage" (UTC-9/UTC-8) or "America/Dawson" (UTC-7 year-round) as alternatives.
- **Invalid schedule payloads cause 400 errors**: A malformed `campaign_schedule` (missing `days`, `from`, `to`, or `schedules`) triggers HTTP 400. Repeated 400s indicate payload issues, not transient failures.
- **Sequences must be complete**: Each sequence step requires a valid `type` ("email"), `delay`, and at least one variant with both `subject` and `body`. Incomplete variants block campaign creation.
- **Only first sequence element is used**: The API only processes `sequences[0]`. Additional sequences are ignored.
- **email_list must reference existing accounts**: The `email_list` field requires email addresses of pre-configured sending accounts in your Instantly workspace, not arbitrary recipient addresses. Always use `INSTANTLY_LIST_ACCOUNTS` to discover valid sending addresses.
- **401 scope errors on campaign creation**: Campaign creation can fail with "Invalid scope. Required: campaigns:create". Update your API key permissions before retrying writes.
- **Read-back fields may differ**: Field names in `INSTANTLY_GET_CAMPAIGN` responses may differ from create payloads (e.g., `timing.from_` vs `timing.from`). Parse defensively.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Instantly-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `instantly` |
| 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` |
| Action | Tool Slug | Required Params |
|---|---|---|
| List sending accounts | `INSTANTLY_LIST_ACCOUNTS` | None (optional filters) |
| Create campaign | `INSTANTLY_CREATE_CAMPAIGN` | `name`, `campaign_schedule` |
| Update campaign | `INSTANTLY_UPDATE_CAMPAIGN` | `id` |
| Get campaign details | `INSTANTLY_GET_CAMPAIGN` | `id` |
| List campaigns | `INSTANTLY_LIST_CAMPAIGNS` | None (optional filters) |
| Create lead list | `INSTANTLY_CREATE_LEAD_LIST` | List name |
| Bulk import leads | `INSTANTLY_ADD_LEADS_BULK` | Campaign/list ID, leads |
---
*Powered by [Composio](https://composio.dev)*

177
jotform-automation/SKILL.md
View File

@@ -1,91 +1,148 @@
---
name: jotform-automation
description: "Automate Jotform tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Jotform Automation
description: "Automate Jotform form listing, user management, activity history, folder organization, and plan inspection through natural language commands"
requires:
mcp: [rube]
mcp:
- rube
---
# Jotform Automation via Rube MCP
# Jotform Automation
Automate Jotform operations through Composio's Jotform toolkit via Rube MCP.
Automate Jotform workflows -- list and search forms, inspect user details, browse activity history, manage folders and labels, and check plan limits -- all through natural language.
**Toolkit docs**: [composio.dev/toolkits/jotform](https://composio.dev/toolkits/jotform)
**Toolkit docs:** [composio.dev/toolkits/jotform](https://composio.dev/toolkits/jotform)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Jotform connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `jotform`
- 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. Add the Rube MCP server to your environment: `https://rube.app/mcp`
2. Connect your Jotform account when prompted (API key auth via Composio)
3. Start issuing natural language commands for Jotform automation
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `jotform`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List and Search Forms
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Jotform operations", known_fields: ""}]
session: {generate_id: true}
```
Retrieve all forms created by the authenticated user with search, filtering, sorting, and pagination.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `JOTFORM_GET_USER_FORMS`
## Core Workflow Pattern
Key parameters:
- `search` -- search query to filter forms by name or content
- `limit` -- number of forms to return
- `offset` -- offset for pagination
- `orderby` -- field to order by
- `sorting` -- sorting direction: `ASC` or `DESC`
- `folder` -- filter by folder ID
### Step 1: Discover Available Tools
Example prompt:
> "List all my Jotform forms that contain 'feedback' in the name, sorted by most recent"
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Jotform task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Get User Account Details
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["jotform"]
session_id: "your_session_id"
```
Retrieve details about the authenticated user including account type, usage statistics, and limits.
### Step 3: Execute Tools
**Tool:** `JOTFORM_GET_USER_DETAILS`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
No parameters required. Returns account info such as username, email, account type, form count, submission count, and usage limits.
Example prompt:
> "Show me my Jotform account details and current usage"
---
### 3. Browse Activity History
Fetch user activity records for auditing, filtered by action type and date range.
**Tool:** `JOTFORM_GET_USER_HISTORY`
Key parameters:
- `action` -- filter by action type (e.g., `formCreation`, `userLogin`, `formUpdate`, `apiKeyCreated`, `userLogout`)
- `date` -- predefined date range: `lastWeek`, `lastMonth`, `last3Months`, `last6Months`, `lastYear`, `all`
- `startDate` -- custom start date in `MM/DD/YYYY` format
- `endDate` -- custom end date in `MM/DD/YYYY` format
- `sortBy` -- sort order: `ASC` or `DESC`
Example prompt:
> "Show me all form creation activity from the last month, sorted newest first"
---
### 4. Manage Folders and Labels
Browse the folder/label structure for organizing forms.
**Tool:** `JOTFORM_GET_USER_FOLDERS`
Key parameters:
- `add_resources` -- set to `true` to include label resources (forms) in the response
- `owner` -- owner username or workspace/team ID (conditionally required for some accounts)
> Jotform has migrated from folders to labels. This tool uses the `GET /user/labels` endpoint.
Example prompt:
> "List all my Jotform folders with their forms included"
---
### 5. Check Plan Limits and Pricing
Retrieve details about a specific Jotform system plan to understand limits and capabilities.
**Tool:** `JOTFORM_GET_SYSTEM_PLAN`
Key parameters:
- `planName` -- the plan to inspect (required): `FREE`, `BRONZE`, `SILVER`, `GOLD`, or `PLATINUM`
Example prompt:
> "What are the limits on the Jotform GOLD plan?"
---
### 6. Full Form Management Workflow
Combine tools for comprehensive form management:
1. **Discover**: `JOTFORM_GET_USER_DETAILS` -- check account type and usage limits
2. **Browse**: `JOTFORM_GET_USER_FORMS` -- list and search forms with filters
3. **Organize**: `JOTFORM_GET_USER_FOLDERS` -- view folder structure with `add_resources=true`
4. **Audit**: `JOTFORM_GET_USER_HISTORY` -- track form creation and modification activity
5. **Plan**: `JOTFORM_GET_SYSTEM_PLAN` -- compare plan features before upgrading
Example prompt:
> "Show me my account usage, list my recent forms, and tell me if I'm close to my plan limits"
---
## 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
| Pitfall | Details |
|---------|---------|
| API key authentication | Jotform uses API key auth, not OAuth -- ensure valid API key is configured in the connection |
| Folders migrated to labels | The folders endpoint now maps to Jotform's labels system; the API behavior may differ from legacy folder documentation |
| Date format for history | Custom date filters use `MM/DD/YYYY` format (e.g., `01/15/2026`), not ISO 8601 |
| Plan name must be exact | `planName` values are case-sensitive enum: `FREE`, `BRONZE`, `SILVER`, `GOLD`, `PLATINUM` |
| Pagination is offset-based | Forms use `limit`/`offset` pagination, not cursor or page-based |
| Owner field conditionally required | `JOTFORM_GET_USER_FOLDERS` may require the `owner` parameter for workspace/team accounts |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Jotform-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `jotform` |
| 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` |
| Action | Tool Slug | Key Params |
|--------|-----------|------------|
| List forms | `JOTFORM_GET_USER_FORMS` | `search`, `limit`, `offset`, `orderby` |
| Get user details | `JOTFORM_GET_USER_DETAILS` | (none) |
| Activity history | `JOTFORM_GET_USER_HISTORY` | `action`, `date`, `startDate`, `endDate` |
| List folders/labels | `JOTFORM_GET_USER_FOLDERS` | `add_resources`, `owner` |
| Check plan | `JOTFORM_GET_SYSTEM_PLAN` | `planName` |
---
*Powered by [Composio](https://composio.dev)*

192
kommo-automation/SKILL.md
View File

@@ -1,91 +1,163 @@
---
name: kommo-automation
description: "Automate Kommo tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Kommo Automation
description: "Automate Kommo CRM operations -- manage leads, pipelines, pipeline stages, tasks, and custom fields -- using natural language through the Composio MCP integration."
category: crm
requires:
mcp: [rube]
mcp:
- rube
---
# Kommo Automation via Rube MCP
# Kommo Automation
Automate Kommo operations through Composio's Kommo toolkit via Rube MCP.
Manage your Kommo CRM sales pipeline -- list and filter leads, navigate pipeline stages, create and update deals, assign tasks, and work with custom fields -- all through natural language commands.
**Toolkit docs**: [composio.dev/toolkits/kommo](https://composio.dev/toolkits/kommo)
**Toolkit docs:** [composio.dev/toolkits/kommo](https://composio.dev/toolkits/kommo)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Kommo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `kommo`
- 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. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Connect your Kommo account when prompted (OAuth authentication).
3. Start issuing natural language commands to manage your CRM.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `kommo`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Navigate Pipelines and Stages
List all lead pipelines, then drill into specific pipeline stages to understand your sales funnel structure.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Kommo operations", known_fields: ""}]
session: {generate_id: true}
```
**Tools:** `KOMMO_LIST_LEADS_PIPELINES`, `KOMMO_LIST_PIPELINE_STAGES`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Example prompt:**
> "Show all my Kommo pipelines and the stages in my main sales pipeline"
## Core Workflow Pattern
**Key parameters for List Pipelines:** None required.
### Step 1: Discover Available Tools
**Key parameters for List Stages:**
- `pipeline_id` (required) -- The pipeline ID to list stages for
- `with_description` -- Include stage descriptions in the response (boolean)
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Kommo task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. List and Filter Leads
Retrieve leads with powerful filtering by pipeline, status, date ranges, responsible users, price, and more.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["kommo"]
session_id: "your_session_id"
```
**Tool:** `KOMMO_LIST_LEADS`
### Step 3: Execute Tools
**Example prompt:**
> "Show all leads in pipeline 12345 created this week, sorted by newest first"
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Key parameters:**
- `query` -- Free-text search across all filled fields
- `filter_pipeline_ids` -- Filter by pipeline IDs (array of integers)
- `filter_status` -- Filter by status within a pipeline: `{"pipeline_id": 123, "status_id": 456}`
- `filter_responsible_user_ids` -- Filter by assigned user IDs
- `filter_names` -- Filter by lead names
- `filter_price` -- Filter by deal value
- `filter_created_at` -- Date range: `{"from": <unix_timestamp>, "to": <unix_timestamp>}`
- `filter_updated_at` -- Date range for last update
- `filter_closed_at` -- Date range for closure
- `order_by_created_at` -- Sort: "asc" or "desc"
- `order_by_updated_at` -- Sort by update date
- `limit` -- Max 250 per page
- `page` -- Page number for pagination
- `with_params` -- Additional data: "contacts", "loss_reason", "catalog_elements", "source_id"
---
### 3. Create New Leads
Add new deals to your Kommo pipeline with custom fields, tags, and pipeline placement.
**Tool:** `KOMMO_CREATE_LEAD`
**Example prompt:**
> "Create a new lead called 'Acme Corp Deal' worth $50,000 in pipeline 12345"
**Key parameters:**
- `name` (required) -- Name of the lead/deal
- `price` -- Deal value (integer)
- `pipeline_id` -- Pipeline to add the lead to
- `status_id` -- Stage within the pipeline (defaults to first stage of main pipeline)
- `responsible_user_id` -- Assigned user ID
- `custom_fields_values` -- Array of custom field value objects
- `tags_to_add` -- Array of tags (by name or ID)
- `created_by` -- User ID of creator (0 for robot)
- `loss_reason_id` -- Reason for loss (if applicable)
---
### 4. Update Existing Leads
Modify lead properties including name, price, pipeline stage, responsible user, tags, and custom fields.
**Tool:** `KOMMO_UPDATE_LEAD`
**Example prompt:**
> "Move lead 789 to stage 456 in pipeline 123 and update the price to $75,000"
**Key parameters:**
- Lead ID (required)
- Any combination of: `name`, `price`, `pipeline_id`, `status_id`, `responsible_user_id`, `tags_to_add`, `tags_to_delete`, `custom_fields_values`
---
### 5. Create Tasks
Assign follow-up tasks linked to leads, contacts, or companies.
**Tool:** `KOMMO_CREATE_TASK`
**Example prompt:**
> "Create a follow-up call task for lead 789 due tomorrow assigned to user 42"
**Key parameters:**
- Task text/description
- Entity type and ID (lead, contact, company)
- Responsible user ID
- Due date (Unix timestamp)
- Task type
---
### 6. Discover Custom Fields
List all custom fields for leads, contacts, or companies to understand your CRM schema.
**Tool:** `KOMMO_LIST_CUSTOM_FIELDS`
**Example prompt:**
> "What custom fields are available for leads in Kommo?"
**Key parameters:**
- Entity type (leads, contacts, companies)
---
## 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
- **Date filters use Unix timestamps**: All date range filters (`filter_created_at`, `filter_updated_at`, `filter_closed_at`) require Unix timestamp format in `{"from": <timestamp>, "to": <timestamp>}` structure, not ISO8601 strings.
- **Pipeline and stage IDs are required**: To filter leads by status, you need both `pipeline_id` and `status_id`. Always call `KOMMO_LIST_LEADS_PIPELINES` and `KOMMO_LIST_PIPELINE_STAGES` first to discover valid IDs.
- **Max 250 leads per page**: The `limit` parameter caps at 250. For large datasets, implement pagination using the `page` parameter.
- **Custom field values format**: Custom fields use a specific nested object format. Use `KOMMO_LIST_CUSTOM_FIELDS` to discover field IDs and expected value formats before setting values.
- **Status filter requires both IDs**: The `filter_status` parameter requires both `pipeline_id` and `status_id` as a combined object -- you cannot filter by status alone.
- **Created_by 0 means robot**: When setting `created_by` or `updated_by` to 0, the action is attributed to a robot/automation, not a human user.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Kommo-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `kommo` |
| 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` |
| Action | Tool Slug | Required Params |
|---|---|---|
| List pipelines | `KOMMO_LIST_LEADS_PIPELINES` | None |
| List pipeline stages | `KOMMO_LIST_PIPELINE_STAGES` | `pipeline_id` |
| List leads | `KOMMO_LIST_LEADS` | None (optional filters) |
| Create lead | `KOMMO_CREATE_LEAD` | `name` |
| Update lead | `KOMMO_UPDATE_LEAD` | Lead ID |
| Create task | `KOMMO_CREATE_TASK` | Task details |
| List custom fields | `KOMMO_LIST_CUSTOM_FIELDS` | Entity type |
---
*Powered by [Composio](https://composio.dev)*

145
launch-darkly-automation/SKILL.md
View File

@@ -1,91 +1,130 @@
---
name: launch-darkly-automation
description: "Automate LaunchDarkly tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: LaunchDarkly Automation
description: "Automate LaunchDarkly feature flag management -- list projects and environments, create and delete trigger workflows, and track code references via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# LaunchDarkly Automation via Rube MCP
# LaunchDarkly Automation
Automate LaunchDarkly operations through Composio's LaunchDarkly toolkit via Rube MCP.
Automate your LaunchDarkly feature flag workflows -- enumerate projects and environments, create webhook-driven flag triggers, manage trigger lifecycle, and audit code references across repositories.
**Toolkit docs**: [composio.dev/toolkits/launch_darkly](https://composio.dev/toolkits/launch_darkly)
**Toolkit docs:** [composio.dev/toolkits/launch_darkly](https://composio.dev/toolkits/launch_darkly)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active LaunchDarkly connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `launch_darkly`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your LaunchDarkly account when prompted (API key authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `launch_darkly`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List Projects
Use `LAUNCH_DARKLY_LIST_PROJECTS` to discover all projects and their keys for subsequent operations.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "LaunchDarkly operations", known_fields: ""}]
session: {generate_id: true}
Tool: LAUNCH_DARKLY_LIST_PROJECTS
Inputs:
- filter: string (e.g., "query:myproject" or "keys:proj1,proj2" or "tags:mytag")
- expand: string (e.g., "environments" to include env list per project)
- limit: integer (default 20)
- offset: integer (pagination start index)
- sort: string (e.g., "name" or "-name" for descending)
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
### 2. Get Environments for a Project
## Core Workflow Pattern
### Step 1: Discover Available Tools
Use `LAUNCH_DARKLY_GET_ENVIRONMENTS` to list all environments within a project (production, staging, test, etc.).
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific LaunchDarkly task"}]
session: {id: "existing_session_id"}
Tool: LAUNCH_DARKLY_GET_ENVIRONMENTS
Inputs:
- project_key: string (required) -- e.g., "my-project", "default"
- filter: string (e.g., "query:production")
- limit: integer (default 20)
- offset: integer (pagination)
- sort: string (e.g., "name" or "-name")
```
### Step 2: Check Connection
### 3. Create a Flag Trigger Workflow
Use `LAUNCH_DARKLY_CREATE_TRIGGER_WORKFLOW` to set up automated flag toggles triggered by external events (webhooks, Datadog alerts, etc.).
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["launch_darkly"]
session_id: "your_session_id"
Tool: LAUNCH_DARKLY_CREATE_TRIGGER_WORKFLOW
Inputs:
- project_key: string (required)
- feature_flag_key: string (required) -- e.g., "new-feature", "enable-dark-mode"
- environment_key: string (required) -- e.g., "production", "staging"
- integration_key: string (default "generic-trigger") -- or "datadog", "honeycomb", "dynatrace"
- instructions: array of objects (optional):
- kind: "flag_action" (fixed)
- action: "turnFlagOn" | "turnFlagOff"
- comment: string (optional) -- description of the trigger purpose
```
### Step 3: Execute Tools
The trigger generates a unique webhook URL that can be called to execute the configured flag action.
### 4. Delete a Flag Trigger Workflow
Use `LAUNCH_DARKLY_DELETE_TRIGGER_WORKFLOW` to permanently remove a trigger and its URL.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: LAUNCH_DARKLY_DELETE_TRIGGER_WORKFLOW
Inputs:
- project_key: string (required)
- feature_flag_key: string (required)
- environment_key: string (required)
- id: string (required) -- the trigger ID returned during creation
```
**Warning:** Deletion is irreversible. The trigger and its URL cannot be recovered.
### 5. List Code Reference Repositories
Use `LAUNCH_DARKLY_LIST_CODE_REFERENCE_REPOSITORIES` to track where feature flags are used in your codebase.
```
Tool: LAUNCH_DARKLY_LIST_CODE_REFERENCE_REPOSITORIES
Inputs:
- projKey: string (optional) -- filter by project key
- flagKey: string (optional) -- filter by feature flag key
- withBranches: string (any value to include branch data)
- withReferencesForDefaultBranch: string (any value to include code refs for default branch)
```
**Note:** Code references is an Enterprise feature requiring `code-reference-repository` write permissions.
---
## 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
| Pitfall | Detail |
|---------|--------|
| Project key discovery | Always use `LAUNCH_DARKLY_LIST_PROJECTS` first to find valid project keys before calling other tools. |
| Environment key format | Environment keys are lowercase slugs (e.g., "production", "test"), not display names. |
| Trigger deletion is permanent | Once deleted via `LAUNCH_DARKLY_DELETE_TRIGGER_WORKFLOW`, the trigger URL is unrecoverable. |
| Enterprise-only code refs | `LAUNCH_DARKLY_LIST_CODE_REFERENCE_REPOSITORIES` requires Enterprise plan and write permissions. |
| Trigger instructions format | Each instruction object requires `kind: "flag_action"` (fixed constant) and `action` as either `turnFlagOn` or `turnFlagOff`. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with LaunchDarkly-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `launch_darkly` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `LAUNCH_DARKLY_LIST_PROJECTS` | List all projects with filtering and pagination |
| `LAUNCH_DARKLY_GET_ENVIRONMENTS` | List environments within a project |
| `LAUNCH_DARKLY_CREATE_TRIGGER_WORKFLOW` | Create a webhook-driven flag trigger |
| `LAUNCH_DARKLY_DELETE_TRIGGER_WORKFLOW` | Permanently delete a flag trigger |
| `LAUNCH_DARKLY_LIST_CODE_REFERENCE_REPOSITORIES` | List repos with code references to flags |
---
*Powered by [Composio](https://composio.dev)*

148
lemlist-automation/SKILL.md
View File

@@ -1,91 +1,135 @@
---
name: lemlist-automation
description: "Automate Lemlist tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Lemlist Automation
description: "Automate Lemlist multichannel outreach -- manage campaigns, enroll leads, add personalization variables, export campaign data, and handle unsubscribes via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Lemlist Automation via Rube MCP
# Lemlist Automation
Automate Lemlist operations through Composio's Lemlist toolkit via Rube MCP.
Automate your Lemlist multichannel outreach workflows -- manage campaigns, enroll leads at scale, enrich with custom variables, export campaign data, and clean up unsubscribes.
**Toolkit docs**: [composio.dev/toolkits/lemlist](https://composio.dev/toolkits/lemlist)
**Toolkit docs:** [composio.dev/toolkits/lemlist](https://composio.dev/toolkits/lemlist)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Lemlist connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `lemlist`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your Lemlist account when prompted (API key authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `lemlist`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List and Discover Campaigns
Use `LEMLIST_GET_LIST_CAMPAIGNS` to enumerate all campaigns by status, with pagination support.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Lemlist operations", known_fields: ""}]
session: {generate_id: true}
Tool: LEMLIST_GET_LIST_CAMPAIGNS
Inputs:
- status: "running" | "draft" | "archived" | "ended" | "paused" | "errors" (optional)
- limit: integer (max 100, default 100)
- offset: integer (pagination offset)
- sortBy: "createdAt"
- sortOrder: "asc" | "desc"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Important:** The response may be wrapped as `{campaigns: [...], pagination: {...}}` instead of a flat list. Always extract from the `campaigns` key.
## Core Workflow Pattern
### 2. Get Campaign Details
### Step 1: Discover Available Tools
Use `LEMLIST_GET_CAMPAIGN_BY_ID` to validate campaign configuration before writes.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Lemlist task"}]
session: {id: "existing_session_id"}
Tool: LEMLIST_GET_CAMPAIGN_BY_ID
Inputs:
- campaignId: string (required) -- e.g., "cam_A1B2C3D4E5F6G7H8I9"
```
### Step 2: Check Connection
### 3. Enroll Leads into a Campaign
Use `LEMLIST_POST_CREATE_LEAD_IN_CAMPAIGN` to add leads with optional email finding, phone lookup, and LinkedIn enrichment.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["lemlist"]
session_id: "your_session_id"
Tool: LEMLIST_POST_CREATE_LEAD_IN_CAMPAIGN
Inputs:
- campaignId: string (required)
- email: string (required)
- firstName, lastName, companyName, companyDomain: string (optional)
- jobTitle, phone, linkedinUrl, icebreaker: string (optional)
- deduplicate: boolean (prevents cross-campaign duplicates)
- findEmail, findPhone, verifyEmail, linkedinEnrichment: boolean (optional)
- timezone: string (IANA format, e.g., "America/New_York")
```
### Step 3: Execute Tools
**Bulk pattern:** Chunk leads into batches of ~50 and checkpoint progress between batches.
### 4. Add Custom Variables to a Lead
Use `LEMLIST_POST_ADD_VARIABLES_TO_LEAD` to enrich leads with personalization fields after enrollment.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: LEMLIST_POST_ADD_VARIABLES_TO_LEAD
Inputs:
- leadId: string (required) -- internal Lemlist lead ID (NOT email)
- company: string (required) -- must match your company name in Lemlist
- variables: object (required) -- key-value pairs, e.g., {"score": "42", "color": "yellow"}
```
**Important:** This is NOT an upsert -- attempting to add variables that already exist will fail. Resolve the internal `leadId` via `LEMLIST_GET_RETRIEVE_LEAD_BY_EMAIL` if you only have the email address.
### 5. Export Campaign Leads
Use `LEMLIST_GET_EXPORT_CAMPAIGN_LEADS` to download leads with state filtering for reporting or QA.
```
Tool: LEMLIST_GET_EXPORT_CAMPAIGN_LEADS
Inputs:
- campaignId: string (required)
- (supports state filtering and JSON/CSV output)
```
### 6. Unsubscribe Lead from Campaign
Use `LEMLIST_DELETE_UNSUBSCRIBE_LEAD_FROM_CAMPAIGN` to stop outreach by removing a lead from a campaign.
```
Tool: LEMLIST_DELETE_UNSUBSCRIBE_LEAD_FROM_CAMPAIGN
Inputs:
- campaignId: string (required)
- leadId or email: string (required)
```
---
## 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
| Pitfall | Detail |
|---------|--------|
| Wrapped campaign list | `LEMLIST_GET_LIST_CAMPAIGNS` may return `{campaigns: [...], pagination: {...}}` instead of a flat array. Always extract from the `campaigns` key. |
| Cross-campaign deduplication | `LEMLIST_POST_CREATE_LEAD_IN_CAMPAIGN` with deduplication enabled fails with HTTP 500 "Lead already in other campaign" -- disable deduplication for intentional cross-campaign enrollment. |
| Bulk import failures | Chunk bulk imports to ~50 per batch with checkpoints to avoid losing partial progress on intermittent failures. |
| Invalid leadId | `LEMLIST_POST_ADD_VARIABLES_TO_LEAD` returns HTTP 400 "Invalid leadId" when using an email as the leadId -- resolve the internal ID via `LEMLIST_GET_RETRIEVE_LEAD_BY_EMAIL` first. |
| Variable collisions | `LEMLIST_POST_ADD_VARIABLES_TO_LEAD` is not an upsert. Adding keys that already exist returns HTTP 400 "Variables X already exist". |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Lemlist-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `lemlist` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `LEMLIST_GET_LIST_CAMPAIGNS` | List all campaigns with status filter and pagination |
| `LEMLIST_GET_CAMPAIGN_BY_ID` | Get detailed campaign info by ID |
| `LEMLIST_POST_CREATE_LEAD_IN_CAMPAIGN` | Create and enroll a lead into a campaign |
| `LEMLIST_POST_ADD_VARIABLES_TO_LEAD` | Add custom personalization variables to a lead |
| `LEMLIST_GET_RETRIEVE_LEAD_BY_EMAIL` | Look up a lead by email address |
| `LEMLIST_GET_EXPORT_CAMPAIGN_LEADS` | Export leads from a campaign with state filtering |
| `LEMLIST_DELETE_UNSUBSCRIBE_LEAD_FROM_CAMPAIGN` | Remove a lead from a campaign |
---
*Powered by [Composio](https://composio.dev)*

185
lemon-squeezy-automation/SKILL.md
View File

@@ -1,91 +1,156 @@
---
name: lemon-squeezy-automation
description: "Automate Lemon Squeezy tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Lemon Squeezy Automation
description: "Automate Lemon Squeezy store management -- products, orders, subscriptions, customers, discounts, and checkout tracking -- using natural language through the Composio MCP integration."
category: e-commerce
requires:
mcp: [rube]
mcp:
- rube
---
# Lemon Squeezy Automation via Rube MCP
# Lemon Squeezy Automation
Automate Lemon Squeezy operations through Composio's Lemon Squeezy toolkit via Rube MCP.
Manage your Lemon Squeezy digital products business -- track orders, monitor subscriptions, analyze customers, review discounts, and audit checkouts -- all through natural language commands.
**Toolkit docs**: [composio.dev/toolkits/lemon_squeezy](https://composio.dev/toolkits/lemon_squeezy)
**Toolkit docs:** [composio.dev/toolkits/lemon_squeezy](https://composio.dev/toolkits/lemon_squeezy)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Lemon Squeezy connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `lemon_squeezy`
- 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. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Connect your Lemon Squeezy account when prompted (API key authentication).
3. Start issuing natural language commands to manage your store.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `lemon_squeezy`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Discover Stores and Products
List all stores to get store IDs, then retrieve products and variants for a specific store.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Lemon Squeezy operations", known_fields: ""}]
session: {generate_id: true}
```
**Tools:** `LEMON_SQUEEZY_LIST_ALL_STORES`, `LEMON_SQUEEZY_LIST_ALL_PRODUCTS`, `LEMON_SQUEEZY_LIST_ALL_VARIANTS`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Example prompt:**
> "List all my Lemon Squeezy stores and their products"
## Core Workflow Pattern
**Key parameters:**
- `LEMON_SQUEEZY_LIST_ALL_STORES` -- No parameters required
- `LEMON_SQUEEZY_LIST_ALL_PRODUCTS` -- Filter by `filter[store_id]`
- `LEMON_SQUEEZY_LIST_ALL_VARIANTS` -- Filter by `filter[product_id]`, `filter[status]` (pending/draft/published)
### Step 1: Discover Available Tools
---
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Lemon Squeezy task"}]
session: {id: "existing_session_id"}
```
### 2. Track Orders and Order Items
Retrieve all orders with optional filtering by store, user email, or order number, and drill into individual order items.
### Step 2: Check Connection
**Tools:** `LEMON_SQUEEZY_LIST_ALL_ORDERS`, `LEMON_SQUEEZY_LIST_ALL_ORDER_ITEMS`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["lemon_squeezy"]
session_id: "your_session_id"
```
**Example prompt:**
> "Show all orders from johndoe@example.com in my Lemon Squeezy store"
### Step 3: Execute Tools
**Key parameters for orders:**
- `filter[store_id]` -- Filter by store ID
- `filter[user_email]` -- Filter by customer email
- `filter[order_number]` -- Filter by specific order number
- `page[number]` / `page[size]` -- Pagination (max 100 per page)
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Key parameters for order items:**
- `filter[order_id]`, `filter[product_id]`, `filter[variant_id]` -- Filter by related entity
---
### 3. Monitor Subscriptions
List all subscriptions with rich filtering options to track recurring revenue.
**Tool:** `LEMON_SQUEEZY_LIST_ALL_SUBSCRIPTIONS`
**Example prompt:**
> "Show all active subscriptions in my Lemon Squeezy store"
**Key parameters:**
- `filter[status]` -- Filter by status (e.g., `active`, `cancelled`)
- `filter[store_id]` -- Filter by store
- `filter[product_id]` -- Filter by product
- `filter[user_email]` -- Filter by subscriber email
- `filter[variant_id]` -- Filter by variant
- `page[number]` / `page[size]` -- Pagination (max 100 per page)
---
### 4. Manage Customers
Retrieve customer records with details including email, MRR, total revenue, and customer portal URLs.
**Tool:** `LEMON_SQUEEZY_LIST_ALL_CUSTOMERS`
**Example prompt:**
> "Find the Lemon Squeezy customer with email johndoe@example.com"
**Key parameters:**
- `filter[email]` -- Filter by exact email address
- `filter[store_id]` -- Filter by store ID
- `page[number]` / `page[size]` -- Pagination (max 100 per page)
---
### 5. Audit Discounts and Redemptions
List all discount codes and track how they have been redeemed across orders.
**Tools:** `LEMON_SQUEEZY_LIST_ALL_DISCOUNTS`, `LEMON_SQUEEZY_LIST_ALL_DISCOUNT_REDEMPTIONS`
**Example prompt:**
> "Show all discounts for store 12345 and their redemption history"
**Key parameters for discounts:**
- `filter[store_id]` -- Filter by store
- `page[number]` / `page[size]` -- Pagination
**Key parameters for redemptions:**
- `filter[discount_id]` -- Filter by discount
- `filter[order_id]` -- Filter by order
---
### 6. Review Checkouts
List all checkout sessions with optional filtering by store or variant.
**Tool:** `LEMON_SQUEEZY_LIST_ALL_CHECKOUTS`
**Example prompt:**
> "Show all checkouts for variant 42 in my Lemon Squeezy store"
**Key parameters:**
- `filter[store_id]` -- Filter by store ID
- `filter[variant_id]` -- Filter by variant 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
- **Store ID is foundational**: Most filters require a `store_id`. Always call `LEMON_SQUEEZY_LIST_ALL_STORES` first to discover valid store IDs before filtering other resources.
- **Pagination is mandatory for large datasets**: All list endpoints use `page[number]` / `page[size]` pagination (max 100 per page). Do not assume the first page is complete.
- **Filter parameter naming**: Lemon Squeezy uses bracket notation for filters (e.g., `filter[store_id]`, `page[number]`). Ensure exact parameter names are used.
- **Subscription invoices vs. orders**: Subscription invoices (`LEMON_SQUEEZY_LIST_ALL_SUBSCRIPTION_INVOICES`) are separate from one-time orders. Use the appropriate endpoint for your use case.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Lemon Squeezy-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `lemon_squeezy` |
| 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` |
| Action | Tool Slug | Required Params |
|---|---|---|
| List stores | `LEMON_SQUEEZY_LIST_ALL_STORES` | None |
| List products | `LEMON_SQUEEZY_LIST_ALL_PRODUCTS` | None (optional filters) |
| List variants | `LEMON_SQUEEZY_LIST_ALL_VARIANTS` | None (optional filters) |
| List orders | `LEMON_SQUEEZY_LIST_ALL_ORDERS` | None (optional filters) |
| List order items | `LEMON_SQUEEZY_LIST_ALL_ORDER_ITEMS` | None (optional filters) |
| List subscriptions | `LEMON_SQUEEZY_LIST_ALL_SUBSCRIPTIONS` | None (optional filters) |
| List customers | `LEMON_SQUEEZY_LIST_ALL_CUSTOMERS` | None (optional filters) |
| List discounts | `LEMON_SQUEEZY_LIST_ALL_DISCOUNTS` | None (optional filters) |
| List discount redemptions | `LEMON_SQUEEZY_LIST_ALL_DISCOUNT_REDEMPTIONS` | None (optional filters) |
| List checkouts | `LEMON_SQUEEZY_LIST_ALL_CHECKOUTS` | None (optional filters) |
---
*Powered by [Composio](https://composio.dev)*

178
lever-automation/SKILL.md
View File

@@ -1,91 +1,149 @@
---
name: lever-automation
description: "Automate Lever tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Lever Automation
description: "Automate recruiting workflows in Lever ATS -- manage opportunities, job postings, requisitions, pipeline stages, and candidate tags through the Composio Lever integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Lever Automation via Rube MCP
# Lever Automation
Automate Lever operations through Composio's Lever toolkit via Rube MCP.
Automate your recruiting operations in **Lever ATS** directly from Claude Code. Manage job postings, track candidate pipelines, update requisitions, and query opportunities without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/lever](https://composio.dev/toolkits/lever)
**Toolkit docs:** [composio.dev/toolkits/lever](https://composio.dev/toolkits/lever)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Lever connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `lever`
- 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. Add the Composio MCP server to your configuration:
```
https://rube.app/mcp
```
2. Connect your Lever account when prompted by running any Lever command. The agent will provide an OAuth link to authenticate.
3. Ensure your Lever API key has sufficient scopes for the operations you need (read/write access to postings, opportunities, requisitions).
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `lever`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List and Filter Job Postings
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Lever operations", known_fields: ""}]
session: {generate_id: true}
```
Retrieve all job postings with optional filtering by state, team, department, location, or commitment type.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `LEVER_LIST_POSTINGS`
## Core Workflow Pattern
Key parameters:
- `state` -- filter by `published`, `internal`, `closed`, `draft`, `pending`, `rejected`
- `team`, `department`, `location`, `commitment` -- narrow results by organizational attributes
- `limit` (1-100) and `offset` -- paginate through large posting sets
- `tag` -- filter by posting tag
### Step 1: Discover Available Tools
Example prompt: *"List all published engineering job postings in Lever"*
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Lever task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Browse Candidate Opportunities
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["lever"]
session_id: "your_session_id"
```
List all opportunities in the hiring pipeline with rich filtering for pipeline analysis and candidate tracking.
### Step 3: Execute Tools
**Tool:** `LEVER_LIST_OPPORTUNITIES`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
Key parameters:
- `posting_id`, `stage_id`, `tag` -- filter by posting, pipeline stage, or tag
- `email`, `contact_id` -- find opportunities for a specific candidate
- `archived` -- filter by archived status (`true`/`false`)
- `created_at_start`, `created_at_end` -- date range filtering (ISO 8601)
- `expand` -- expand `applications`, `contact`, `owner`, `stage`, `stageChanges`, `sources`, `sourcedBy` into full objects
Example prompt: *"Show me all active opportunities for the Senior Engineer posting, expanded with contact details"*
---
### 3. Get Opportunity Details
Fetch comprehensive details about a single candidate opportunity including contact info, stage progression, sources, and applications.
**Tool:** `LEVER_GET_OPPORTUNITY`
Key parameters:
- `opportunity` (required) -- the unique opportunity UID
- `expand` -- comma-separated fields to expand: `contact`, `stage`, `owner`
Example prompt: *"Get full details for opportunity 31c9716c-d4e3-47e8-a6a1-54078a1151d6 with contact and stage expanded"*
---
### 4. Manage Requisitions
Create, list, update, and delete requisitions to track headcount and hiring needs.
**Tools:** `LEVER_LIST_REQUISITIONS`, `LEVER_GET_REQUISITION`, `LEVER_UPDATE_REQUISITION`, `LEVER_DELETE_REQUISITION`
Update requires these fields:
- `requisition` (required) -- UUID of the requisition
- `requisitionCode` (required) -- unique code like `REQ-001`
- `name` (required) -- requisition title
- `headcountTotal` (required) -- number of positions (minimum 1)
- `status` -- `open` or `closed`
- Optional: `hiringManager`, `owner`, `department`, `team`, `location`, `compensationBand`
Example prompt: *"Update requisition REQ-001 to increase headcount to 3 and change status to open"*
---
### 5. View Pipeline Stages
Retrieve all hiring pipeline stages configured in your Lever account.
**Tool:** `LEVER_LIST_STAGES`
Key parameters:
- `limit` (1-100) -- max items per page
- `offset` -- pagination token from previous response
Example prompt: *"List all pipeline stages in our Lever account"*
---
### 6. Manage Tags
List all tags used to categorize candidates, opportunities, and postings.
**Tool:** `LEVER_LIST_TAGS`
Key parameters:
- `limit` -- max items per page
- `offset` -- pagination token
Example prompt: *"Show all candidate tags in Lever"*
---
## 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
- **Pagination required for large datasets:** `LEVER_LIST_OPPORTUNITIES` and `LEVER_LIST_POSTINGS` default to 100 results max per page. Always check for an `offset` token in the response and iterate to get complete results.
- **Expand parameter format:** The `expand` field on `LEVER_LIST_OPPORTUNITIES` accepts an array of strings, while on `LEVER_GET_OPPORTUNITY` and `LEVER_GET_REQUISITION` it accepts a comma-separated string. Follow the exact schema for each tool.
- **Requisition updates are full replacements:** `LEVER_UPDATE_REQUISITION` requires all mandatory fields (`requisitionCode`, `name`, `headcountTotal`) even if you only want to change one field. Always fetch the current requisition first with `LEVER_GET_REQUISITION`.
- **Timestamps:** Opportunity date filters use ISO 8601 format, while `LEVER_LIST_POSTINGS` uses Unix timestamps in milliseconds for `updated_at_start`.
- **Connection scopes:** Write operations (update/delete requisitions) will fail if your API token lacks the necessary permissions, even if reads succeed.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Lever-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `lever` |
| 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` |
| Tool Slug | Description |
|---|---|
| `LEVER_LIST_POSTINGS` | List all job postings with filtering by state, team, department |
| `LEVER_LIST_OPPORTUNITIES` | List candidate opportunities with pipeline filtering |
| `LEVER_GET_OPPORTUNITY` | Get detailed info for a single opportunity |
| `LEVER_GET_REQUISITION` | Retrieve a single requisition by ID |
| `LEVER_LIST_REQUISITIONS` | List all requisitions with status/code filtering |
| `LEVER_UPDATE_REQUISITION` | Update an existing requisition (full replacement) |
| `LEVER_DELETE_REQUISITION` | Delete/archive a requisition |
| `LEVER_LIST_STAGES` | List all pipeline stages |
| `LEVER_LIST_TAGS` | List all tags for categorization |
---
*Powered by [Composio](https://composio.dev)*

160
mailerlite-automation/SKILL.md
View File

@@ -1,91 +1,139 @@
---
name: mailerlite-automation
description: "Automate Mailerlite tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: MailerLite Automation
description: "Automate email marketing workflows including subscriber management, campaign analytics, group segmentation, and account monitoring through MailerLite via Composio"
requires:
mcp: [rube]
mcp:
- rube
---
# Mailerlite Automation via Rube MCP
# MailerLite Automation
Automate Mailerlite operations through Composio's Mailerlite toolkit via Rube MCP.
Automate email marketing operations -- manage subscribers, analyze campaign performance, organize groups and segments, and monitor account health -- all orchestrated through the Composio MCP integration.
**Toolkit docs**: [composio.dev/toolkits/mailerlite](https://composio.dev/toolkits/mailerlite)
**Toolkit docs:** [composio.dev/toolkits/mailerlite](https://composio.dev/toolkits/mailerlite)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Mailerlite connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `mailerlite`
- 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. Connect your MailerLite account through the Composio MCP server at `https://rube.app/mcp`
2. The agent will prompt you with an authentication link if no active connection exists
3. Once connected, all `MAILERLITE_*` tools become available for execution
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `mailerlite`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Verify Account & Fetch Metadata
Retrieve account details including plan limits and timezone to ensure consistent reporting.
**Tool:** `MAILERLITE_GET_ACCOUNT_INFO`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Mailerlite operations", known_fields: ""}]
session: {generate_id: true}
No parameters required -- returns account metadata, plan details, and timezone configuration.
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Always run this first to establish plan constraints and timezone for consistent time-windowed queries.
## Core Workflow Pattern
---
### Step 1: Discover Available Tools
### 2. Get Account-Wide Performance Stats
Retrieve aggregate subscriber counts, sent email totals, and engagement metrics for a health snapshot.
**Tool:** `MAILERLITE_GET_ACCOUNT_STATS`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Mailerlite task"}]
session: {id: "existing_session_id"}
No parameters required -- returns overall subscriber counts, sent emails, and performance metrics.
```
### Step 2: Check Connection
---
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["mailerlite"]
session_id: "your_session_id"
```
### 3. List & Paginate Subscribers
Retrieve subscribers with optional status filtering and cursor-based pagination.
### Step 3: Execute Tools
**Tool:** `MAILERLITE_GET_SUBSCRIBERS`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `filter[status]` | string | No | Filter by: `active`, `unsubscribed`, `unconfirmed`, `bounced`, `junk` |
| `limit` | integer | No | Subscribers per page (default: 25) |
| `cursor` | string | No | Pagination cursor from previous response `meta.cursor` |
| `include` | string | No | Set to `groups` to include group memberships |
**Important:** Loop with `meta.next_cursor` until `null` to build a complete subscriber list.
---
### 4. List & Analyze Campaigns
Retrieve campaigns with optional status/type filters and page-based pagination.
**Tool:** `MAILERLITE_GET_CAMPAIGNS`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `filter[status]` | string | No | Filter by: `sent`, `draft`, `ready` |
| `filter[type]` | string | No | Filter by: `regular`, `ab`, `resend`, `rss` |
| `limit` | integer | No | Items per page (default: 25) |
| `page` | integer | No | Page number (default: 1) |
**Important:** Paginate using `meta.last_page` to avoid omitting campaigns from historical analysis.
---
### 5. Manage Subscriber Groups
List, filter, and sort subscriber groups for audience organization.
**Tool:** `MAILERLITE_GET_GROUPS`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `filter[name]` | string | No | Partial name match filter |
| `limit` | integer | No | Max groups to return |
| `page` | integer | No | Page number (starting from 1) |
| `sort` | string | No | Sort by: `name`, `total`, `open_rate`, `click_rate`, `created_at` (prefix `-` for descending) |
---
### 6. Retrieve Audience Segments & Custom Fields
Fetch segments and custom field definitions for advanced audience analysis.
**Tools:** `MAILERLITE_GET_SEGMENTS` and `MAILERLITE_GET_FIELDS`
**Segments:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `limit` | integer | No | Max segments to return (max 250) |
| `page` | integer | No | Page number (starting from 1) |
**Fields:** No parameters required -- returns all custom field definitions.
---
## 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
| Pitfall | Details |
|---------|---------|
| **Subscriber pagination is cursor-based** | `MAILERLITE_GET_SUBSCRIBERS` uses `meta.next_cursor` -- you must loop until `null` or counts will be incomplete |
| **Campaign pagination is page-based** | `MAILERLITE_GET_CAMPAIGNS` uses `page`/`limit` with `meta.last_page` -- stopping early omits campaigns and distorts trends |
| **Sampling bias** | Computing engagement metrics from only the first page introduces bias; always aggregate across all pages |
| **Nested response shape** | MailerLite payloads are nested under `results[i].response.data` with `data` and `meta` subkeys, not a flat `data` key -- parse accordingly |
| **API quotas** | Subscriber listing is limited by MailerLite Connect API quotas -- plan batch operations accordingly |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Mailerlite-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `mailerlite` |
| 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` |
| Tool Slug | Purpose |
|-----------|---------|
| `MAILERLITE_GET_ACCOUNT_INFO` | Verify auth and review account metadata |
| `MAILERLITE_GET_ACCOUNT_STATS` | Get aggregate performance metrics |
| `MAILERLITE_GET_SUBSCRIBERS` | List subscribers with filtering and pagination |
| `MAILERLITE_GET_CAMPAIGNS` | List campaigns with status/type filters |
| `MAILERLITE_GET_GROUPS` | List and sort subscriber groups |
| `MAILERLITE_GET_SEGMENTS` | List audience segments |
| `MAILERLITE_GET_FIELDS` | Retrieve custom field definitions |
---
*Powered by [Composio](https://composio.dev)*

179
microsoft-clarity-automation/SKILL.md
View File

@@ -1,91 +1,150 @@
---
name: microsoft-clarity-automation
description: "Automate Microsoft Clarity tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Microsoft Clarity Automation
description: "Automate user behavior analytics with Microsoft Clarity -- export heatmap data, session metrics, and engagement analytics segmented by browser, device, country, source, and more through the Composio Microsoft Clarity integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Microsoft Clarity Automation via Rube MCP
# Microsoft Clarity Automation
Automate Microsoft Clarity operations through Composio's Microsoft Clarity toolkit via Rube MCP.
Export **Microsoft Clarity** user behavior analytics directly from Claude Code. Pull heatmap data, session metrics, and engagement insights segmented by multiple dimensions without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/microsoft_clarity](https://composio.dev/toolkits/microsoft_clarity)
**Toolkit docs:** [composio.dev/toolkits/microsoft_clarity](https://composio.dev/toolkits/microsoft_clarity)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Microsoft Clarity connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `microsoft_clarity`
- 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. Add the Composio MCP server to your configuration:
```
https://rube.app/mcp
```
2. Connect your Microsoft Clarity account when prompted. The agent will provide an authentication link.
3. Ensure your Clarity project has sufficient data collection enabled for the dimensions you want to analyze.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `microsoft_clarity`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Export Recent Analytics Data
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Microsoft Clarity operations", known_fields: ""}]
session: {generate_id: true}
```
Export Clarity analytics data for the last 1-3 days, segmented by up to three dimensions simultaneously.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `MICROSOFT_CLARITY_DATA_EXPORT`
## Core Workflow Pattern
Key parameters:
- `numOfDays` (required) -- number of days to export: `1` (last 24h), `2` (last 48h), or `3` (last 72h)
- `dimension1` -- first breakdown dimension
- `dimension2` -- second breakdown dimension (optional)
- `dimension3` -- third breakdown dimension (optional)
### Step 1: Discover Available Tools
Available dimensions:
- `Browser` -- Chrome, Firefox, Safari, Edge, etc.
- `Device` -- Desktop, Mobile, Tablet
- `Country/Region` -- geographic location of users
- `OS` -- Windows, macOS, iOS, Android, etc.
- `Source` -- traffic source (e.g., google, direct, referral)
- `Medium` -- traffic medium (organic, cpc, referral, etc.)
- `Campaign` -- marketing campaign name
- `Channel` -- traffic channel grouping
- `URL` -- specific page URLs
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Microsoft Clarity task"}]
session: {id: "existing_session_id"}
```
Example prompt: *"Export Clarity data for the last 24 hours broken down by Device and Country/Region"*
### Step 2: Check Connection
---
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["microsoft_clarity"]
session_id: "your_session_id"
```
### 2. Device Performance Analysis
### Step 3: Execute Tools
Analyze how user behavior differs across device types to optimize responsive design.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Tool:** `MICROSOFT_CLARITY_DATA_EXPORT`
Configuration: `numOfDays: 3`, `dimension1: "Device"`, `dimension2: "Browser"`
Example prompt: *"Show me Clarity metrics for the last 3 days by Device and Browser"*
---
### 3. Traffic Source Breakdown
Understand which traffic sources drive the most engaged users.
**Tool:** `MICROSOFT_CLARITY_DATA_EXPORT`
Configuration: `numOfDays: 2`, `dimension1: "Source"`, `dimension2: "Medium"`
Example prompt: *"Export Clarity data for the last 48 hours broken down by Source and Medium"*
---
### 4. Geographic User Behavior
Analyze user engagement patterns across different countries and regions.
**Tool:** `MICROSOFT_CLARITY_DATA_EXPORT`
Configuration: `numOfDays: 3`, `dimension1: "Country/Region"`, `dimension2: "Device"`
Example prompt: *"Get Clarity data for the last 72 hours segmented by Country/Region and Device type"*
---
### 5. Page-Level Performance
Examine which specific URLs have the highest or lowest engagement metrics.
**Tool:** `MICROSOFT_CLARITY_DATA_EXPORT`
Configuration: `numOfDays: 1`, `dimension1: "URL"`, `dimension2: "Device"`
Example prompt: *"Export yesterday's Clarity data broken down by URL and Device"*
---
### 6. Campaign Attribution Analysis
Evaluate marketing campaign effectiveness through user behavior metrics.
**Tool:** `MICROSOFT_CLARITY_DATA_EXPORT`
Configuration: `numOfDays: 3`, `dimension1: "Campaign"`, `dimension2: "Channel"`, `dimension3: "Device"`
Example prompt: *"Show Clarity engagement data for the last 3 days by Campaign, Channel, and Device"*
---
## 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
- **Limited time window:** Data export is limited to the last 1, 2, or 3 days only. The `numOfDays` parameter only accepts values of 1, 2, or 3. For longer historical analysis, you need to run exports periodically and aggregate them externally.
- **Dimension name exact match:** Dimension values must match exactly as listed (e.g., `Country/Region` not `country` or `region`). Case and slashes matter.
- **Maximum three dimensions:** You can segment by up to three dimensions per export. For more complex analysis, run multiple exports with different dimension combinations.
- **Data availability lag:** Clarity data may have a short processing delay. Very recent sessions (last few minutes) may not appear in exports.
- **Single tool limitation:** The Clarity integration currently offers only the data export tool. For heatmap visualizations and session recordings, use the Clarity web dashboard directly.
- **Response size:** Exports with high-cardinality dimensions like `URL` combined with other dimensions can produce large response payloads. Consider narrowing your time window or using fewer dimensions.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Microsoft Clarity-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `microsoft_clarity` |
| 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` |
| Tool Slug | Description |
|---|---|
| `MICROSOFT_CLARITY_DATA_EXPORT` | Export analytics data with up to 3 dimensional breakdowns |
**Available Dimensions:**
| Dimension | Description |
|---|---|
| `Browser` | Web browser (Chrome, Firefox, Safari, etc.) |
| `Device` | Device type (Desktop, Mobile, Tablet) |
| `Country/Region` | Geographic location |
| `OS` | Operating system |
| `Source` | Traffic source |
| `Medium` | Traffic medium |
| `Campaign` | Marketing campaign |
| `Channel` | Traffic channel grouping |
| `URL` | Specific page URL |
---
*Powered by [Composio](https://composio.dev)*

147
mistral-ai-automation/SKILL.md
View File

@@ -1,91 +1,134 @@
---
name: mistral-ai-automation
description: "Automate Mistral AI tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Mistral AI Automation
description: "Automate Mistral AI operations -- manage files and libraries, upload documents for fine-tuning, batch processing, and OCR, track fine-tuning jobs, and build RAG pipelines via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Mistral AI Automation via Rube MCP
# Mistral AI Automation
Automate Mistral AI operations through Composio's Mistral AI toolkit via Rube MCP.
Automate your Mistral AI workflows -- upload files for fine-tuning, batch processing, and OCR, manage document libraries for RAG-enabled agents, list and retrieve files, track fine-tuning jobs, and integrate Mistral AI into cross-app data pipelines.
**Toolkit docs**: [composio.dev/toolkits/mistral_ai](https://composio.dev/toolkits/mistral_ai)
**Toolkit docs:** [composio.dev/toolkits/mistral_ai](https://composio.dev/toolkits/mistral_ai)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Mistral AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `mistral_ai`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your Mistral AI account when prompted (API key authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `mistral_ai`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Upload Files to Mistral AI
Use `MISTRAL_AI_UPLOAD_FILE` to upload files for fine-tuning, batch processing, or OCR.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Mistral AI operations", known_fields: ""}]
session: {generate_id: true}
Tool: MISTRAL_AI_UPLOAD_FILE
Inputs:
- file: object (required)
- name: string -- destination filename (e.g., "training_data.jsonl")
- mimetype: string -- MIME type (e.g., "application/pdf", "application/jsonl")
- s3key: string -- S3 key of a previously downloaded/stored file
- purpose: "fine-tune" | "batch" | "ocr" (default "fine-tune")
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Limits:** Maximum file size is 512 MB. For fine-tuning, only `.jsonl` files are supported.
## Core Workflow Pattern
### 2. List and Retrieve Files
### Step 1: Discover Available Tools
Use `MISTRAL_AI_LIST_FILES` to browse uploaded files with pagination, and `MISTRAL_AI_RETRIEVE_FILE` to get metadata for a specific file.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Mistral AI task"}]
session: {id: "existing_session_id"}
Tool: MISTRAL_AI_LIST_FILES
Inputs:
- limit: integer (optional, min 1)
- after: string (file ID cursor for next page)
- order: "asc" | "desc" (default "desc")
Tool: MISTRAL_AI_RETRIEVE_FILE
Inputs:
- file_id: string (required) -- UUID obtained from List Files
```
### Step 2: Check Connection
### 3. Create Document Libraries
Use `MISTRAL_AI_CREATE_LIBRARY` to group documents into libraries for use with RAG-enabled Mistral AI agents.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["mistral_ai"]
session_id: "your_session_id"
Tool: MISTRAL_AI_CREATE_LIBRARY
Inputs:
- name: string (required) -- e.g., "Project Documents"
- description: string (optional)
```
### Step 3: Execute Tools
### 4. Upload Documents to a Library
Use `MISTRAL_AI_UPLOAD_LIBRARY_DOCUMENT` to add documents to a library for RAG retrieval by Mistral AI agents.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: MISTRAL_AI_UPLOAD_LIBRARY_DOCUMENT
- Requires library_id and file details
- Call RUBE_GET_TOOL_SCHEMAS for full input schema before use
```
### 5. List Libraries and Download Files
Use `MISTRAL_AI_LIST_LIBRARIES` to discover available document libraries, and `MISTRAL_AI_DOWNLOAD_FILE` to retrieve file content.
```
Tool: MISTRAL_AI_LIST_LIBRARIES
- Lists all document libraries with metadata (id, name, document counts)
- Call RUBE_GET_TOOL_SCHEMAS for full input schema
Tool: MISTRAL_AI_DOWNLOAD_FILE
- Downloads raw binary content of a previously uploaded file
- Call RUBE_GET_TOOL_SCHEMAS for full input schema
```
### 6. Track Fine-Tuning Jobs
Use `MISTRAL_AI_GET_FINE_TUNING_JOBS` to list and filter fine-tuning jobs by model, status, and creation time.
```
Tool: MISTRAL_AI_GET_FINE_TUNING_JOBS
- Supports filtering by model, status, creation time, and W&B integration
- Call RUBE_GET_TOOL_SCHEMAS for full input schema
```
---
## 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
| Pitfall | Detail |
|---------|--------|
| Fine-tune file format | Only `.jsonl` files are supported for fine-tuning uploads. Other formats will be rejected. |
| File size limit | Maximum upload size is 512 MB per file. |
| File object structure | `MISTRAL_AI_UPLOAD_FILE` requires an `s3key` referencing a previously stored file, not raw binary content. Use a download action first to stage files in S3. |
| Pagination cursors | `MISTRAL_AI_LIST_FILES` uses cursor-based pagination via the `after` parameter (file ID). Continue fetching until no more results are returned. |
| Library document processing | Uploaded library documents are processed asynchronously. They may not be immediately available for RAG queries after upload. |
| Schema references | Several tools (`MISTRAL_AI_UPLOAD_LIBRARY_DOCUMENT`, `MISTRAL_AI_LIST_LIBRARIES`, `MISTRAL_AI_GET_FINE_TUNING_JOBS`, `MISTRAL_AI_DOWNLOAD_FILE`) require calling `RUBE_GET_TOOL_SCHEMAS` to load full input schemas before execution. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Mistral AI-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `mistral_ai` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `MISTRAL_AI_UPLOAD_FILE` | Upload files for fine-tuning, batch processing, or OCR |
| `MISTRAL_AI_LIST_FILES` | List uploaded files with pagination |
| `MISTRAL_AI_RETRIEVE_FILE` | Get metadata for a specific file by ID |
| `MISTRAL_AI_DOWNLOAD_FILE` | Download content of an uploaded file |
| `MISTRAL_AI_CREATE_LIBRARY` | Create a document library for RAG |
| `MISTRAL_AI_LIST_LIBRARIES` | List all document libraries with metadata |
| `MISTRAL_AI_UPLOAD_LIBRARY_DOCUMENT` | Add a document to a library for RAG |
| `MISTRAL_AI_GET_FINE_TUNING_JOBS` | List and filter fine-tuning jobs |
---
*Powered by [Composio](https://composio.dev)*

152
neon-automation/SKILL.md
View File

@@ -1,91 +1,139 @@
---
name: neon-automation
description: "Automate Neon tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Neon Automation
description: "Automate Neon serverless Postgres operations -- manage projects, branches, databases, roles, and connection URIs via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Neon Automation via Rube MCP
# Neon Automation
Automate Neon operations through Composio's Neon toolkit via Rube MCP.
Automate your Neon serverless Postgres workflows -- list projects and branches, inspect databases, retrieve connection URIs, manage roles, and integrate Neon database operations into cross-app pipelines.
**Toolkit docs**: [composio.dev/toolkits/neon](https://composio.dev/toolkits/neon)
**Toolkit docs:** [composio.dev/toolkits/neon](https://composio.dev/toolkits/neon)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Neon connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `neon`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your Neon account when prompted (API key authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `neon`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List Projects
Use `NEON_RETRIEVE_PROJECTS_LIST` to discover all projects associated with the authenticated user.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Neon operations", known_fields: ""}]
session: {generate_id: true}
Tool: NEON_RETRIEVE_PROJECTS_LIST
Inputs:
- org_id: string (REQUIRED when using a personal API key)
- limit: integer (1-400, default 10)
- cursor: string (pagination cursor from previous response)
- search: string (search by project name or ID, supports partial match)
- timeout: integer (milliseconds; returns partial results on timeout)
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Important:** When using a personal API key, `org_id` is required. Retrieve it first via `NEON_GET_USER_ORGANIZATIONS`.
## Core Workflow Pattern
### 2. Get Project Details
### Step 1: Discover Available Tools
Use `NEON_ACCESS_PROJECT_DETAILS_BY_ID` to inspect project configuration, owner info, and consumption metrics.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Neon task"}]
session: {id: "existing_session_id"}
Tool: NEON_ACCESS_PROJECT_DETAILS_BY_ID
Inputs:
- project_id: string (required) -- format: "adjective-noun-number", e.g., "dry-smoke-26258271"
```
### Step 2: Check Connection
### 3. List Branches for a Project
Use `NEON_GET_BRANCHES_FOR_PROJECT` to enumerate branches (development stages) within a project.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["neon"]
session_id: "your_session_id"
Tool: NEON_GET_BRANCHES_FOR_PROJECT
Inputs:
- project_id: string (required)
- search: string (optional, search by branch name or ID)
```
### Step 3: Execute Tools
### 4. List Databases on a Branch
Use `NEON_FETCH_DATABASE_FOR_BRANCH` to inventory databases within a specific project and branch.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: NEON_FETCH_DATABASE_FOR_BRANCH
Inputs:
- project_id: string (required)
- branch_id: string (required)
```
### 5. Get Connection URI
Use `NEON_GET_PROJECT_CONNECTION_URI` to obtain a Postgres connection string for a project/branch/database.
```
Tool: NEON_GET_PROJECT_CONNECTION_URI
Inputs:
- project_id: string (required)
- database_name: string (required) -- e.g., "neondb"
- role_name: string (required) -- e.g., "neondb_owner"
- branch_id: string (optional, defaults to project default branch)
- endpoint_id: string (optional, defaults to read-write endpoint)
- pooled: boolean (optional, adds -pooler for connection pooling)
```
**Security:** The returned URI includes credentials. Treat it as a secret -- do not log or share it.
### 6. Inspect Database Details and Roles
Use `NEON_RETRIEVE_BRANCH_DATABASE_DETAILS` to verify a database before connecting, and `NEON_GET_BRANCH_ROLES_FOR_PROJECT` to list available roles.
```
Tool: NEON_RETRIEVE_BRANCH_DATABASE_DETAILS
Inputs:
- project_id: string (required)
- branch_id: string (required)
- database_name: string (required)
Tool: NEON_GET_BRANCH_ROLES_FOR_PROJECT
Inputs:
- project_id: string (required)
- branch_id: string (required)
```
---
## 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
| Pitfall | Detail |
|---------|--------|
| org_id required | `NEON_RETRIEVE_PROJECTS_LIST` returns HTTP 400 "org_id is required" when using a personal API key. Call `NEON_GET_USER_ORGANIZATIONS` first. |
| Incomplete pagination | Project lists may be incomplete without pagination. Iterate using `cursor` until it is empty. |
| Rate limiting | `NEON_RETRIEVE_PROJECTS_LIST` returns HTTP 429 on bursty listing. Avoid redundant calls and back off before retrying. |
| Invalid role/database pairing | `NEON_GET_PROJECT_CONNECTION_URI` returns 401/403 when the database_name/role_name pairing is invalid. Use `NEON_GET_BRANCH_ROLES_FOR_PROJECT` to select an allowed role. |
| Connection URI is a secret | The returned URI includes credentials. Never log, display, or share it in plain text. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Neon-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `neon` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `NEON_RETRIEVE_PROJECTS_LIST` | List all Neon projects with pagination and search |
| `NEON_ACCESS_PROJECT_DETAILS_BY_ID` | Get project configuration and consumption metrics |
| `NEON_GET_BRANCHES_FOR_PROJECT` | List branches within a project |
| `NEON_FETCH_DATABASE_FOR_BRANCH` | List databases on a specific branch |
| `NEON_GET_PROJECT_CONNECTION_URI` | Get a Postgres connection URI (with credentials) |
| `NEON_RETRIEVE_BRANCH_DATABASE_DETAILS` | Inspect database metadata and settings |
| `NEON_GET_USER_ORGANIZATIONS` | List organizations for the authenticated user |
| `NEON_CREATE_API_KEY_FOR_ORGANIZATION` | Create a new API key for an organization |
| `NEON_GET_BRANCH_ROLES_FOR_PROJECT` | List roles available on a branch |
---
*Powered by [Composio](https://composio.dev)*

244
netsuite-automation/SKILL.md
View File

@@ -1,91 +1,231 @@
---
name: netsuite-automation
description: "Automate Netsuite tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: NetSuite Automation
description: "NetSuite Automation: manage customers, sales orders, invoices, inventory, and records via Oracle NetSuite ERP with SuiteQL queries"
requires:
mcp: [rube]
---
# Netsuite Automation via Rube MCP
# NetSuite Automation
Automate Netsuite operations through Composio's Netsuite toolkit via Rube MCP.
Automate Oracle NetSuite ERP operations including creating customers and sales orders, running SuiteQL queries, upserting records by external ID, and inspecting record metadata for comprehensive business management.
**Toolkit docs**: [composio.dev/toolkits/netsuite](https://composio.dev/toolkits/netsuite)
**Toolkit docs:** [composio.dev/toolkits/netsuite](https://composio.dev/toolkits/netsuite)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Netsuite connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `netsuite`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `netsuite`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure an active connection exists for the `netsuite` toolkit. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
---
Always discover available tools before executing workflows:
## Core Workflows
### 1. Create Sales Orders
Create customer orders with line items including item references, quantities, and pricing.
**Tool:** `NETSUITE_CREATE_SALES_ORDER`
**Key Parameters:**
- `entity` (required) -- Customer reference: `{"id": "<internal_id>"}`
- `item` (required) -- Container with `items` array, each containing:
- `item` (required) -- Item reference: `{"id": "<internal_id>"}`
- `quantity` (required) -- Units to order (non-negative)
- `rate` -- Unit price (optional if item has default pricing)
- `amount` -- Total line amount (alternative to rate)
- `taxcode` -- Tax code reference: `{"id": "<internal_id>"}` (required if SuiteTax enabled)
- `description` -- Line item notes
- `tranDate` -- Transaction date in `YYYY-MM-DD` format
- `memo` -- Header memo
- `orderStatus` -- `"A"` (Pending Approval) or `"B"` (Pending Fulfillment)
- `otherrefnum` -- External reference or PO number
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Netsuite operations", known_fields: ""}]
session: {generate_id: true}
Tool: NETSUITE_CREATE_SALES_ORDER
Arguments:
entity: {"id": "1234"}
item: {
"items": [
{"item": {"id": "56"}, "quantity": 10, "rate": 25.00},
{"item": {"id": "78"}, "quantity": 5, "rate": 50.00}
]
}
tranDate: "2026-02-11"
memo: "Q1 bulk order"
orderStatus: "B"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
---
## Core Workflow Pattern
### 2. Run SuiteQL Queries
### Step 1: Discover Available Tools
Execute ad-hoc SQL queries against NetSuite data with server-side paging.
**Tool:** `NETSUITE_RUN_SUITEQL_QUERY`
**Key Parameters:**
- `q` (required) -- SuiteQL SELECT statement
- `limit` -- Rows per page (default varies)
- `offset` -- Zero-based index of first row (must be a multiple of `limit`)
**Examples:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Netsuite task"}]
session: {id: "existing_session_id"}
Tool: NETSUITE_RUN_SUITEQL_QUERY
Arguments:
q: "SELECT id, companyname, email FROM customer WHERE isinactive = 'F' ORDER BY companyname"
limit: 100
offset: 0
```
### Step 2: Check Connection
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["netsuite"]
session_id: "your_session_id"
Tool: NETSUITE_RUN_SUITEQL_QUERY
Arguments:
q: "SELECT id, entitystatus, total FROM transaction WHERE type = 'SalesOrd' AND trandate >= '2026-01-01'"
limit: 50
```
### Step 3: Execute Tools
---
### 3. Create and Manage Customers
Create new customer records with subsidiary assignment and contact details.
**Tools:**
- `NETSUITE_CREATE_CUSTOMER` -- Create a new customer
- `NETSUITE_GET_CUSTOMER` -- Retrieve customer by internal ID
- `NETSUITE_UPDATE_CUSTOMER` -- Update existing customer (PATCH semantics)
**Key Parameters for `NETSUITE_CREATE_CUSTOMER`:**
- `body` (required) -- JSON object with customer data. Required fields:
- `subsidiary` -- Object with `id` (subsidiary internal ID)
- Either `companyName` (for businesses) or `firstName` + `lastName` (for individuals)
- Optional: `email`, `phone`, `isPerson` (set to `"T"` for individuals), `comments`
- `replace` -- Comma-separated sublist names to fully replace (e.g., `"contacts,addressbook"`)
**Example:**
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: NETSUITE_CREATE_CUSTOMER
Arguments:
body: {
"companyName": "Acme Corp",
"subsidiary": {"id": "1"},
"email": "info@acme.com",
"phone": "555-0100"
}
```
---
### 4. Upsert Records by External ID
Create or update records idempotently using an external identifier. Essential for sync workflows.
**Tool:** `NETSUITE_UPSERT_RECORD_BY_EXTERNAL_ID`
**Key Parameters:**
- `record_type` (required) -- Record type name, e.g., `"customer"`, `"salesorder"`, `"customrecord_myrec"`
- `external_id` (required) -- External ID value (letters, numbers, underscore, hyphen only)
- `body` (required) -- JSON object matching the record schema; include mandatory fields when creating
**Example:**
```
Tool: NETSUITE_UPSERT_RECORD_BY_EXTERNAL_ID
Arguments:
record_type: "customer"
external_id: "CRM-CUST-42"
body: {
"companyName": "Acme Corp",
"subsidiary": {"id": "1"},
"email": "updated@acme.com"
}
```
> **Warning:** Idempotency depends on consistent external ID usage. Mismatches silently create additional records instead of updating.
---
### 5. Inspect Record Metadata
Discover available fields, data types, constraints, and requirements before creating or updating records.
**Tool:** `NETSUITE_GET_RECORD_METADATA`
**Key Parameters:**
- `record_type` (required) -- e.g., `"customer"`, `"salesorder"`, `"invoice"`, `"vendor"`, `"employee"`, `"item"`
- `accept` -- `"application/schema+json"` (default, JSON Schema) or `"application/swagger+json"` (OpenAPI 3.0)
**Example:**
```
Tool: NETSUITE_GET_RECORD_METADATA
Arguments:
record_type: "salesorder"
```
---
### 6. List and Filter Records
Retrieve multiple records with optional filtering and pagination.
**Tool:** `NETSUITE_LIST_RECORDS`
**Key Parameters:**
- `recordType` (required) -- e.g., `"customer"`, `"salesorder"`
- `q` -- Filter expression using N/query operators, e.g., `"email START_WITH \"barbara\""`
- `limit` -- Max records per page (1--1000, default 1000)
- `offset` -- Zero-based index (must be divisible by limit)
**Supporting Tools:**
- `NETSUITE_FILTER_RECORD_COLLECTION` -- Alternative filtering (secondary to SuiteQL)
- `NETSUITE_GET_RECORD_SELECTED_FIELDS` -- Retrieve specific fields only (reduced payload)
---
## Recommended Execution Plan
1. **Inspect the record schema** using `NETSUITE_GET_RECORD_METADATA` to discover required fields
2. **Search for existing records** using `NETSUITE_RUN_SUITEQL_QUERY` to avoid duplicates
3. **Look up customer** by email using SuiteQL; fetch details with `NETSUITE_GET_CUSTOMER` if found
4. **Create customer if needed** using `NETSUITE_CREATE_CUSTOMER` (ensure `subsidiary` is set)
5. **Validate item internal IDs** using `NETSUITE_LIST_RECORDS` or SuiteQL
6. **Create the sales order** using `NETSUITE_CREATE_SALES_ORDER` with validated references
7. **Optionally upsert by external ID** using `NETSUITE_UPSERT_RECORD_BY_EXTERNAL_ID` for sync workflows
8. **Verify results** using `NETSUITE_GET_RECORD_SELECTED_FIELDS` to confirm pricing/totals
---
## 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
| Pitfall | Detail |
|---------|--------|
| **Invalid item IDs** | `NETSUITE_CREATE_SALES_ORDER` throws USER_ERROR when item internal ID is invalid. Pre-validate via `NETSUITE_LIST_RECORDS` or `NETSUITE_RUN_SUITEQL_QUERY`. |
| **Missing required fields** | `NETSUITE_CREATE_CUSTOMER` returns 400 when required fields (e.g., `subsidiary`) are missing. Always inspect with `NETSUITE_GET_RECORD_METADATA` first. |
| **SuiteQL field names** | Query differences by account can cause empty results. Confirm field names via `NETSUITE_GET_RECORD_METADATA` when results look wrong. |
| **Filter expression limits** | `NETSUITE_FILTER_RECORD_COLLECTION` may fail if filter syntax is unsupported. Treat as secondary to SuiteQL. |
| **External ID idempotency** | `NETSUITE_UPSERT_RECORD_BY_EXTERNAL_ID` depends on consistent external IDs. Mismatches silently create duplicates instead of updating. |
| **SuiteTax line items** | Accounts with SuiteTax enabled require `taxcode` on every line item. Omitting it causes creation failures. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Netsuite-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `netsuite` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `NETSUITE_CREATE_SALES_ORDER` | Create a new sales order with line items |
| `NETSUITE_RUN_SUITEQL_QUERY` | Execute ad-hoc SuiteQL queries with paging |
| `NETSUITE_CREATE_CUSTOMER` | Create a new customer record |
| `NETSUITE_GET_CUSTOMER` | Retrieve a customer by internal ID |
| `NETSUITE_UPDATE_CUSTOMER` | Update an existing customer (PATCH) |
| `NETSUITE_UPSERT_RECORD_BY_EXTERNAL_ID` | Create or update a record by external ID |
| `NETSUITE_GET_RECORD_METADATA` | Inspect record schema and field definitions |
| `NETSUITE_LIST_RECORDS` | List records with filtering and pagination |
| `NETSUITE_FILTER_RECORD_COLLECTION` | Alternative record filtering |
| `NETSUITE_GET_RECORD_SELECTED_FIELDS` | Retrieve specific fields from a record |
---
*Powered by [Composio](https://composio.dev)*

163
new-relic-automation/SKILL.md
View File

@@ -1,91 +1,148 @@
---
name: new-relic-automation
description: "Automate New Relic tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: New Relic Automation
description: "Automate New Relic observability workflows -- manage alert policies, notification channels, alert conditions, and monitor applications and browser apps via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# New Relic Automation via Rube MCP
# New Relic Automation
Automate New Relic operations through Composio's New Relic toolkit via Rube MCP.
Automate your New Relic observability workflows -- create and manage alert policies, configure notification channels (email, Slack, webhook, PagerDuty), monitor APM applications, inspect alert conditions, and integrate New Relic alerting into cross-app pipelines.
**Toolkit docs**: [composio.dev/toolkits/new_relic](https://composio.dev/toolkits/new_relic)
**Toolkit docs:** [composio.dev/toolkits/new_relic](https://composio.dev/toolkits/new_relic)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active New Relic connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `new_relic`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your New Relic account when prompted (API key authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `new_relic`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List Alert Policies
Use `NEW_RELIC_GET_ALERT_POLICIES` to discover existing alert policies with optional filtering.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "New Relic operations", known_fields: ""}]
session: {generate_id: true}
Tool: NEW_RELIC_GET_ALERT_POLICIES
Inputs:
- name: string (optional, partial match supported)
- incident_preference: "PER_POLICY" | "PER_CONDITION" | "PER_CONDITION_AND_TARGET"
- page: integer (1-indexed pagination)
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
### 2. Create an Alert Policy
## Core Workflow Pattern
### Step 1: Discover Available Tools
Use `NEW_RELIC_CREATE_ALERT_POLICY` to set up a new policy container for alert conditions.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific New Relic task"}]
session: {id: "existing_session_id"}
Tool: NEW_RELIC_CREATE_ALERT_POLICY
Inputs:
- name: string (required) -- must be unique within the account
- incident_preference: "PER_POLICY" | "PER_CONDITION" | "PER_CONDITION_AND_TARGET" (default: PER_POLICY)
```
### Step 2: Check Connection
**Incident preferences explained:**
- `PER_POLICY` -- one issue per policy (recommended for most use cases)
- `PER_CONDITION` -- one issue per alert condition
- `PER_CONDITION_AND_TARGET` -- one issue per condition and signal/target
### 3. Create Alert Notification Channels
Use `NEW_RELIC_CREATE_ALERT_CHANNEL` to register notification endpoints for alert delivery.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["new_relic"]
session_id: "your_session_id"
Tool: NEW_RELIC_CREATE_ALERT_CHANNEL
Inputs:
- type: "email" | "slack" | "webhook" | "pagerduty" | "opsgenie" | "victorops" (required)
- name: string (required) -- human-readable channel name
- configuration: object (required) -- varies by type:
Email: { recipients: "devops@example.com,oncall@example.com" }
Slack: { url: "<slack_webhook_url>", channel: "alerts" }
Webhook: { url: "https://hooks.example.com/alerts", auth_username, auth_password }
PagerDuty: { service_key: "<integration_key>" }
OpsGenie: { api_key, recipients, tags, teams }
VictorOps: { key: "<api_key>", route_key: "<routing_key>" }
```
### Step 3: Execute Tools
### 4. Get Alert Conditions for a Policy
Use `NEW_RELIC_GET_ALERT_CONDITIONS` to inspect the conditions attached to a specific policy.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: NEW_RELIC_GET_ALERT_CONDITIONS
Inputs:
- policy_id: integer (required)
```
### 5. Monitor Applications
Use `NEW_RELIC_GET_APPLICATIONS` and `NEW_RELIC_GET_BROWSER_APPLICATIONS` to list APM and browser-monitored apps.
```
Tool: NEW_RELIC_GET_APPLICATIONS
Inputs:
- name: string (optional, case-insensitive partial match)
- host: string (optional, case-insensitive partial match)
- ids: string (optional, comma-separated list of app IDs)
- page: integer (1-indexed)
Tool: NEW_RELIC_GET_BROWSER_APPLICATIONS
Inputs:
- filter[name]: string (optional, case-insensitive partial match)
- page: integer (1-indexed)
```
### 6. Manage Channels and Policies
Use `NEW_RELIC_UPDATE_ALERT_CHANNEL` to modify existing channels and `NEW_RELIC_DELETE_ALERT_POLICY` to remove policies.
```
Tool: NEW_RELIC_UPDATE_ALERT_CHANNEL
Inputs:
- alert_channel_id: integer (required)
- name: string (optional)
- type: string (optional, only to change type)
- configuration: object (optional, fields vary by type)
Tool: NEW_RELIC_DELETE_ALERT_POLICY
Inputs:
- policy_id: string (required) -- ID of the policy to delete
```
---
## 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
| Pitfall | Detail |
|---------|--------|
| Unique policy names | `NEW_RELIC_CREATE_ALERT_POLICY` requires the name to be unique within the account. |
| Channel config varies by type | The `configuration` object for `NEW_RELIC_CREATE_ALERT_CHANNEL` has different required fields per channel type (e.g., `recipients` for email, `service_key` for PagerDuty). |
| Pagination required | All list endpoints return paginated results. Iterate pages until results are exhausted. |
| Policy ID type mismatch | `NEW_RELIC_GET_ALERT_CONDITIONS` expects `policy_id` as an integer, while `NEW_RELIC_DELETE_ALERT_POLICY` expects it as a string. |
| Channel-policy linking | After creating a channel, you must separately associate it with a policy for alerts to flow to that channel. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with New Relic-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `new_relic` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `NEW_RELIC_GET_ALERT_POLICIES` | List alert policies with optional filtering |
| `NEW_RELIC_CREATE_ALERT_POLICY` | Create a new alert policy |
| `NEW_RELIC_DELETE_ALERT_POLICY` | Delete an alert policy by ID |
| `NEW_RELIC_CREATE_ALERT_CHANNEL` | Create a notification channel (email, Slack, webhook, etc.) |
| `NEW_RELIC_GET_ALERT_CHANNELS` | List all configured alert channels |
| `NEW_RELIC_UPDATE_ALERT_CHANNEL` | Update an existing alert channel |
| `NEW_RELIC_GET_ALERT_CONDITIONS` | Get alert conditions for a policy |
| `NEW_RELIC_GET_APPLICATIONS` | List APM applications |
| `NEW_RELIC_GET_BROWSER_APPLICATIONS` | List browser-monitored applications |
---
*Powered by [Composio](https://composio.dev)*

154
omnisend-automation/SKILL.md
View File

@@ -1,91 +1,125 @@
---
name: omnisend-automation
description: "Automate Omnisend tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Omnisend Automation
description: "Automate ecommerce marketing workflows including contact management, bulk operations, and subscriber segmentation through Omnisend via Composio"
requires:
mcp: [rube]
mcp:
- rube
---
# Omnisend Automation via Rube MCP
# Omnisend Automation
Automate Omnisend operations through Composio's Omnisend toolkit via Rube MCP.
Automate ecommerce marketing operations -- create and update contacts, manage subscriber lists with cursor pagination, run bulk batch operations, and segment audiences -- all orchestrated through the Composio MCP integration.
**Toolkit docs**: [composio.dev/toolkits/omnisend](https://composio.dev/toolkits/omnisend)
**Toolkit docs:** [composio.dev/toolkits/omnisend](https://composio.dev/toolkits/omnisend)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Omnisend connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `omnisend`
- 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. Connect your Omnisend account through the Composio MCP server at `https://rube.app/mcp`
2. The agent will prompt you with an authentication link if no active connection exists
3. Once connected, all `OMNISEND_*` tools become available for execution
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `omnisend`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Create or Update a Contact
Upsert a contact by email identifier with subscription status, profile fields, and optional welcome message.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Omnisend operations", known_fields: ""}]
session: {generate_id: true}
```
**Tool:** `OMNISEND_CREATE_OR_UPDATE_CONTACT`
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `identifiers` | array | Yes | At least one identifier object with `id` (email), `type` (`email`), optional `channels.email.status` (`subscribed`, `nonSubscribed`, `unsubscribed`), and `sendWelcomeMessage` (boolean) |
| `firstName` | string | No | Contact's first name |
| `lastName` | string | No | Contact's last name |
| `gender` | string | No | `m` or `f` |
| `birthdate` | string | No | Format: `YYYY-MM-DD` |
| `country` | string | No | Full country name |
| `countryCode` | string | No | ISO 3166-1 alpha-2 code (e.g., `US`) |
| `city` | string | No | City name |
| `address` | string | No | Street address |
| `postalCode` | string | No | ZIP/postal code |
## Core Workflow Pattern
---
### Step 1: Discover Available Tools
### 2. List Contacts with Pagination
Retrieve contacts in batches with optional filters for email, phone, status, segment, or tag.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Omnisend task"}]
session: {id: "existing_session_id"}
```
**Tool:** `OMNISEND_LIST_CONTACTS`
### Step 2: Check Connection
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `limit` | integer | No | Results per page (default: 100, max: 250) |
| `after` | string | No | Cursor for next page (base64-encoded ContactID) |
| `before` | string | No | Cursor for previous page |
| `email` | string | No | Filter by exact email address |
| `phone` | string | No | Filter by full phone number with country code |
| `status` | string | No | Filter by: `subscribed`, `nonSubscribed`, `unsubscribed` |
| `segmentID` | integer | No | Filter by segment ID |
| `tag` | string | No | Filter by tag (e.g., `VIP`) |
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["omnisend"]
session_id: "your_session_id"
```
---
### Step 3: Execute Tools
### 3. Get Contact Details
Retrieve the full profile for a single contact when you already have their contact ID.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Tool:** `OMNISEND_GET_CONTACT`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `contactId` | string | Yes | Unique contact identifier (e.g., `60e7412b1234567890abcdef`) |
---
### 4. Update an Existing Contact
Patch specific fields on a contact by ID without overwriting the entire record.
**Tool:** `OMNISEND_UPDATE_CONTACT`
Requires the `contactId` and the fields to update. Retrieve the contact ID first via `OMNISEND_LIST_CONTACTS` or `OMNISEND_GET_CONTACT`.
---
### 5. Bulk Batch Operations
Process many records asynchronously in a single call -- contacts, products, orders, events, or categories.
**Tool:** `OMNISEND_CREATE_BATCH`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `method` | string | Yes | `POST` or `PUT` |
| `endpoint` | string | Yes | Target: `contacts`, `orders`, `products`, `events`, `categories` |
| `items` | array | Yes | Array of payload objects for each operation |
| `eventID` | string | Conditional | Required when endpoint is `events` |
Use batch operations to avoid rate limits when processing large data sets.
---
## 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
| Pitfall | Details |
|---------|---------|
| **Identifier required** | `OMNISEND_CREATE_OR_UPDATE_CONTACT` requires at least one identifier in the `identifiers` array -- only `email` type is supported |
| **Cursor-based pagination** | `OMNISEND_LIST_CONTACTS` uses base64-encoded `after`/`before` cursors, not page numbers -- follow cursors to avoid incomplete data |
| **Contact ID resolution** | `OMNISEND_UPDATE_CONTACT` requires a `contactId` -- always resolve it first via list or get operations |
| **Batch method constraints** | `OMNISEND_CREATE_BATCH` only accepts `POST` or `PUT` methods -- no `DELETE` or `PATCH` |
| **Event ID dependency** | When batching events, the `eventID` parameter is mandatory -- omitting it causes the batch to fail |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Omnisend-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `omnisend` |
| 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` |
| Tool Slug | Purpose |
|-----------|---------|
| `OMNISEND_CREATE_OR_UPDATE_CONTACT` | Create or upsert a contact by email |
| `OMNISEND_LIST_CONTACTS` | List contacts with filtering and cursor pagination |
| `OMNISEND_GET_CONTACT` | Get full profile for a single contact by ID |
| `OMNISEND_UPDATE_CONTACT` | Patch specific fields on an existing contact |
| `OMNISEND_CREATE_BATCH` | Bulk async operations for contacts, products, orders, events |
---
*Powered by [Composio](https://composio.dev)*

135
openai-automation/SKILL.md
View File

@@ -1,91 +1,122 @@
---
name: openai-automation
description: "Automate OpenAI tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: OpenAI Automation
description: "Automate OpenAI API operations -- generate responses with multimodal and structured output support, create embeddings, generate images, and list models via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# OpenAI Automation via Rube MCP
# OpenAI Automation
Automate OpenAI operations through Composio's OpenAI toolkit via Rube MCP.
Automate your OpenAI API workflows -- generate text with the Responses API (including multimodal image+text inputs and structured JSON outputs), create embeddings for search and clustering, generate images with DALL-E and GPT Image models, and list available models.
**Toolkit docs**: [composio.dev/toolkits/openai](https://composio.dev/toolkits/openai)
**Toolkit docs:** [composio.dev/toolkits/openai](https://composio.dev/toolkits/openai)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active OpenAI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `openai`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your OpenAI account when prompted (API key authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `openai`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Generate a Response (Text, Multimodal, Structured)
Use `OPENAI_CREATE_RESPONSE` for one-shot model responses including text, image analysis, OCR, and structured JSON outputs.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "OpenAI operations", known_fields: ""}]
session: {generate_id: true}
Tool: OPENAI_CREATE_RESPONSE
Inputs:
- model: string (required) -- e.g., "gpt-5", "gpt-4o", "o3-mini"
- input: string | array (required)
Simple: "Explain quantum computing"
Multimodal: [
{ role: "user", content: [
{ type: "input_text", text: "What is in this image?" },
{ type: "input_image", image_url: { url: "https://..." } }
]}
]
- temperature: number (0-2, optional -- not supported with reasoning models)
- max_output_tokens: integer (optional)
- reasoning: { effort: "none" | "minimal" | "low" | "medium" | "high" }
- text: object (structured output config)
- format: { type: "json_schema", name: "...", schema: {...}, strict: true }
- tools: array (function, code_interpreter, file_search, web_search)
- tool_choice: "auto" | "none" | "required" | { type: "function", function: { name: "..." } }
- store: boolean (false to opt out of model distillation)
- stream: boolean
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Structured output example:** Set `text.format` to `{ type: "json_schema", name: "person", schema: { type: "object", properties: { name: { type: "string" }, age: { type: "integer" } }, required: ["name", "age"], additionalProperties: false }, strict: true }`.
## Core Workflow Pattern
### 2. Create Embeddings
### Step 1: Discover Available Tools
Use `OPENAI_CREATE_EMBEDDINGS` for vector search, clustering, recommendations, and RAG pipelines.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific OpenAI task"}]
session: {id: "existing_session_id"}
Tool: OPENAI_CREATE_EMBEDDINGS
Inputs:
- input: string | string[] | int[] | int[][] (required) -- max 8192 tokens, max 2048 items
- model: string (required) -- "text-embedding-3-small", "text-embedding-3-large", "text-embedding-ada-002"
- dimensions: integer (optional, only for text-embedding-3 and later)
- encoding_format: "float" | "base64" (default "float")
- user: string (optional, end-user ID for abuse monitoring)
```
### Step 2: Check Connection
### 3. Generate Images
Use `OPENAI_CREATE_IMAGE` to create images from text prompts using GPT Image or DALL-E models.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["openai"]
session_id: "your_session_id"
Tool: OPENAI_CREATE_IMAGE
Inputs:
- model: string (required) -- "gpt-image-1", "gpt-image-1.5", "dall-e-3", "dall-e-2"
- prompt: string (required) -- max 32000 chars (GPT Image), 4000 (DALL-E 3), 1000 (DALL-E 2)
- size: "1024x1024" | "1536x1024" | "1024x1536" | "auto" | "256x256" | "512x512" | "1792x1024" | "1024x1792"
- quality: "standard" | "hd" | "auto" | "high" | "medium" | "low"
- n: integer (1-10; DALL-E 3 supports n=1 only)
- background: "transparent" | "opaque" | "auto" (GPT Image models only)
- style: "vivid" | "natural" (DALL-E 3 only)
- user: string (optional)
```
### Step 3: Execute Tools
### 4. List Available Models
Use `OPENAI_LIST_MODELS` to discover which models are accessible with your API key.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: OPENAI_LIST_MODELS
Inputs: (none)
```
---
## 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
| Pitfall | Detail |
|---------|--------|
| DALL-E deprecation | DALL-E 2 and DALL-E 3 are deprecated and will stop being supported on 05/12/2026. Prefer GPT Image models. |
| DALL-E 3 single image only | `OPENAI_CREATE_IMAGE` with DALL-E 3 only supports `n=1`. Use GPT Image models or DALL-E 2 for multiple images. |
| Token limits for embeddings | Input must not exceed 8192 tokens per item and 2048 items per batch for embedding models. |
| Reasoning model restrictions | `temperature` and `top_p` are not supported with reasoning models (o3-mini, etc.). Use `reasoning.effort` instead. |
| Structured output strict mode | When `strict: true` in json_schema format, ALL schema properties must be listed in the `required` array. |
| Prompt length varies by model | Image prompt max lengths differ: 32000 (GPT Image), 4000 (DALL-E 3), 1000 (DALL-E 2). |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with OpenAI-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `openai` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `OPENAI_CREATE_RESPONSE` | Generate text/multimodal responses with structured output support |
| `OPENAI_CREATE_EMBEDDINGS` | Create text embeddings for search, clustering, and RAG |
| `OPENAI_CREATE_IMAGE` | Generate images from text prompts |
| `OPENAI_LIST_MODELS` | List all models available to your API key |
---
*Powered by [Composio](https://composio.dev)*

191
pandadoc-automation/SKILL.md
View File

@@ -1,91 +1,162 @@
---
name: pandadoc-automation
description: "Automate Pandadoc tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: PandaDoc Automation
description: "Automate document workflows with PandaDoc -- create documents from files, manage contacts, organize folders, set up webhooks, create templates, and track document status through the Composio PandaDoc integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Pandadoc Automation via Rube MCP
# PandaDoc Automation
Automate Pandadoc operations through Composio's Pandadoc toolkit via Rube MCP.
Manage **PandaDoc** document workflows directly from Claude Code. Create documents from uploaded files, manage recipients and contacts, organize with folders, set up event webhooks, create templates, and track document status without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/pandadoc](https://composio.dev/toolkits/pandadoc)
**Toolkit docs:** [composio.dev/toolkits/pandadoc](https://composio.dev/toolkits/pandadoc)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Pandadoc connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `pandadoc`
- 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. Add the Composio MCP server to your configuration:
```
https://rube.app/mcp
```
2. Connect your PandaDoc account when prompted. The agent will provide an OAuth link to authenticate.
3. Ensure your PandaDoc workspace has the appropriate plan for the features you need (e.g., e-signatures, templates, webhooks).
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `pandadoc`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Create a Document from File
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Pandadoc operations", known_fields: ""}]
session: {generate_id: true}
```
Upload a PDF, DOCX, or RTF file to create a new PandaDoc document with designated recipients for signing and tracking.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `PANDADOC_CREATE_DOCUMENT_FROM_FILE`
## Core Workflow Pattern
Key parameters:
- `name` (required) -- document name
- `recipients` (required) -- array of recipient objects, each with:
- `email` (required) -- recipient email
- `first_name`, `last_name` -- recipient name
- `role` -- `signer` (default), `approver`, or `cc` (must be unique per recipient)
- `signing_order` -- numeric order (if set for one, must be set for all)
- `file` -- uploaded file object with `name`, `mimetype`, and `s3key`
- `url` -- alternatively, a public HTTPS URL to the file
- `parse_form_fields` (default false) -- parse PDF form fields
- `tags` -- array of strings for categorization
- `owner` -- document owner (email or membership_id)
### Step 1: Discover Available Tools
Example prompt: *"Create a PandaDoc document from contract.pdf with john@example.com as signer and jane@example.com as approver"*
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Pandadoc task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Get Document Details
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["pandadoc"]
session_id: "your_session_id"
```
Fetch comprehensive metadata for a document including recipients, fields, tokens, pricing, tags, and content-block references.
### Step 3: Execute Tools
**Tool:** `PANDADOC_GET_DOCUMENT_DETAILS`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
Key parameters:
- `id` (required) -- the unique document identifier (e.g., `BhVzRcxH9Z2LgfPPGXFUqa`)
Use this to check document status, inspect recipient completion, review field values, or gather metadata for reporting.
Example prompt: *"Get the full details and status for PandaDoc document BhVzRcxH9Z2LgfPPGXFUqa"*
---
### 3. Manage Contacts
Create new contacts or update existing ones in PandaDoc. Contacts are matched by email -- if a contact with the given email exists, it gets updated; otherwise, a new one is created.
**Tool:** `PANDADOC_CREATE_OR_UPDATE_CONTACT`
Key parameters:
- `email` (required) -- contact email address
- `first_name`, `last_name` -- contact name
- `company` -- company name
- `job_title` -- role/title
- `phone` -- phone number
- `street_address`, `city`, `state`, `postal_code`, `country` -- address fields
Example prompt: *"Create a PandaDoc contact for john.doe@example.com at Acme Corp as Software Engineer"*
---
### 4. Organize with Folders
Create folders and move documents to organize your PandaDoc workspace.
**Tools:** `PANDADOC_CREATE_FOLDER`, `PANDADOC_LIST_DOCUMENT_FOLDERS`, `PANDADOC_MOVE_DOCUMENT_TO_FOLDER`
For creating folders:
- `name` (required) -- folder name
- `parent_uuid` -- parent folder UUID for nested structures
Example prompt: *"Create a 'Q1 2026 Contracts' folder in PandaDoc and move document BhVzRcxH9Z to it"*
---
### 5. Set Up Webhooks
Create webhook subscriptions to receive real-time notifications when document events occur.
**Tool:** `PANDADOC_CREATE_WEBHOOK`
Key parameters:
- `name` (required) -- descriptive name for the webhook
- `url` (required) -- endpoint URL for notifications
- `triggers` (required) -- event types: `document_state_changed`, `recipient_completed`, `document_updated`, etc.
- `active` (default true) -- enable/disable the webhook
- `payload` -- additional data to include: `fields`, `products`, `metadata`, `tokens`, `pricing`
Example prompt: *"Set up a PandaDoc webhook to notify https://api.example.com/hooks when documents change state or recipients complete"*
---
### 6. Create Templates
Create reusable templates from PDF files or from scratch with structured content blocks.
**Tool:** `PANDADOC_CREATE_TEMPLATE`
Key parameters:
- `name` (required) -- template name
- `file_path` -- path to PDF file for template creation
- `content` -- structured content object with `title` and `blocks` array for building from scratch
- `description` -- template description
- `tags` -- categorization tags
Example prompt: *"Create a PandaDoc template called 'Standard NDA' from the nda-template.pdf file"*
---
## 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
- **Unique recipient roles:** PandaDoc API does not allow duplicate roles within a single document. Each recipient must have a unique `role` value (e.g., `signer`, `signer_2`, `approver`, `cc`).
- **Signing order consistency:** If you specify `signing_order` for any recipient, you must specify it for ALL recipients in the document. Partial ordering will cause errors.
- **File upload requirements:** Either `file` (with `s3key`) or `url` must be provided for document creation, not both. The URL must be publicly accessible HTTPS.
- **Contact upsert behavior:** `PANDADOC_CREATE_OR_UPDATE_CONTACT` matches by email. If you need to update a contact's email itself, you must create a new contact and handle the old one separately.
- **Document ID format:** Document IDs are alphanumeric strings (e.g., `BhVzRcxH9Z2LgfPPGXFUqa`). They are returned when documents are created and can be found via the PandaDoc dashboard.
- **Webhook event naming:** Trigger event names must match exactly (e.g., `document_state_changed`, not `stateChanged` or `state_changed`). Check PandaDoc API docs for the complete list.
- **Folder operations require UUIDs:** Moving documents requires both the document ID and the destination folder UUID. List folders first to get the correct UUID.
- **Template content blocks:** When creating templates from scratch, the `blocks` array must contain valid content block objects per PandaDoc's schema. Check their API documentation for supported block types.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Pandadoc-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `pandadoc` |
| 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` |
| Tool Slug | Description |
|---|---|
| `PANDADOC_CREATE_DOCUMENT_FROM_FILE` | Create a document from PDF/DOCX/RTF with recipients |
| `PANDADOC_GET_DOCUMENT_DETAILS` | Get full document metadata, status, and fields |
| `PANDADOC_CREATE_OR_UPDATE_CONTACT` | Create or update a contact by email |
| `PANDADOC_CREATE_FOLDER` | Create a folder for document organization |
| `PANDADOC_LIST_DOCUMENT_FOLDERS` | List all document folders |
| `PANDADOC_MOVE_DOCUMENT_TO_FOLDER` | Move a document to a specific folder |
| `PANDADOC_CREATE_WEBHOOK` | Set up event notification webhooks |
| `PANDADOC_CREATE_TEMPLATE` | Create a reusable document template |
---
*Powered by [Composio](https://composio.dev)*

141
phantombuster-automation/SKILL.md
View File

@@ -1,91 +1,128 @@
---
name: phantombuster-automation
description: "Automate Phantombuster tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: PhantomBuster Automation
description: "Automate lead generation, web scraping, and social media data extraction workflows through PhantomBuster's cloud platform via Composio"
requires:
mcp: [rube]
mcp:
- rube
---
# Phantombuster Automation via Rube MCP
# PhantomBuster Automation
Automate Phantombuster operations through Composio's Phantombuster toolkit via Rube MCP.
Automate cloud-based data extraction and lead generation -- manage agents and scripts, monitor organization resources and usage, track container execution, and solve captcha challenges -- all orchestrated through the Composio MCP integration.
**Toolkit docs**: [composio.dev/toolkits/phantombuster](https://composio.dev/toolkits/phantombuster)
**Toolkit docs:** [composio.dev/toolkits/phantombuster](https://composio.dev/toolkits/phantombuster)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Phantombuster connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `phantombuster`
- 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. Connect your PhantomBuster account through the Composio MCP server at `https://rube.app/mcp`
2. The agent will prompt you with an authentication link if no active connection exists
3. Once connected, all `PHANTOMBUSTER_*` tools become available for execution
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `phantombuster`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List All Agents
Fetch every agent associated with your account or organization to inventory automation workflows.
**Tool:** `PHANTOMBUSTER_GET_AGENTS_FETCH_ALL`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Phantombuster operations", known_fields: ""}]
session: {generate_id: true}
No parameters required -- returns all agents with IDs and metadata.
Authenticate your API key first.
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Use agent IDs from this response when fetching containers or monitoring specific automations.
## Core Workflow Pattern
---
### Step 1: Discover Available Tools
### 2. List All Scripts
Retrieve all scripts available under your account (without code bodies) for script management.
**Tool:** `PHANTOMBUSTER_GET_SCRIPTS_FETCH_ALL`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Phantombuster task"}]
session: {id: "existing_session_id"}
No parameters required -- returns script metadata without source code.
```
### Step 2: Check Connection
---
### 3. Monitor Organization Resources & Quotas
Check your organization's current resource usage and quota limits to plan automation capacity.
**Tool:** `PHANTOMBUSTER_GET_ORGS_FETCH_RESOURCES`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["phantombuster"]
session_id: "your_session_id"
No parameters required -- returns resource allocation and current usage metrics.
```
### Step 3: Execute Tools
---
### 4. Retrieve Agent Containers
Fetch all execution containers for a specific agent to monitor run history and status.
**Tool:** `PHANTOMBUSTER_GET_CONTAINERS_FETCH_ALL`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `agentId` | string | Yes | Agent ID from `PHANTOMBUSTER_GET_AGENTS_FETCH_ALL` |
---
### 5. Export Agent Usage Report
Download a CSV report of all agents' run statistics for your organization.
**Tool:** `PHANTOMBUSTER_GET_ORGS_EXPORT_AGENT_USAGE`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Returns a downloadable CSV with comprehensive agent execution statistics.
```
---
### 6. Solve hCaptcha Challenges
Obtain a valid hCaptcha token for automated form submissions or scraping flows that require captcha solving.
**Tool:** `PHANTOMBUSTER_POST_HCAPTCHA`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `siteKey` | string | Yes | Public site key of the hCaptcha widget |
| `pageUrl` | string | Yes | Full URL of the page with the captcha |
| `proxy` | string | No | Proxy URL (e.g., `http://user:pass@host:port`) |
| `userAgent` | string | No | Custom User-Agent string to simulate |
---
## 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
| Pitfall | Details |
|---------|---------|
| **Agent ID required for containers** | `PHANTOMBUSTER_GET_CONTAINERS_FETCH_ALL` requires a valid `agentId` -- always resolve it first via `PHANTOMBUSTER_GET_AGENTS_FETCH_ALL` |
| **API key authentication** | All PhantomBuster tools require a valid API key connection -- verify authentication before calling any tools |
| **Script bodies not included** | `PHANTOMBUSTER_GET_SCRIPTS_FETCH_ALL` returns metadata only, not source code |
| **Organization scope** | Resource and usage tools operate at the organization level tied to your API key -- ensure the correct org is targeted |
| **Branch operations** | `PHANTOMBUSTER_GET_BRANCHES_FETCH_ALL` and `PHANTOMBUSTER_GET_BRANCHES_DIFF` are for advanced script versioning -- use them to assess staging vs. release changes before deployment |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Phantombuster-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `phantombuster` |
| 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` |
| Tool Slug | Purpose |
|-----------|---------|
| `PHANTOMBUSTER_GET_AGENTS_FETCH_ALL` | List all agents in your account |
| `PHANTOMBUSTER_GET_SCRIPTS_FETCH_ALL` | List all scripts (metadata only) |
| `PHANTOMBUSTER_GET_ORGS_FETCH_RESOURCES` | Check organization resource usage and quotas |
| `PHANTOMBUSTER_GET_CONTAINERS_FETCH_ALL` | Get all containers for a specific agent |
| `PHANTOMBUSTER_GET_ORGS_EXPORT_AGENT_USAGE` | Export agent usage as CSV |
| `PHANTOMBUSTER_POST_HCAPTCHA` | Solve hCaptcha challenges for automation |
| `PHANTOMBUSTER_GET_ORGS_FETCH` | Fetch organization details |
| `PHANTOMBUSTER_GET_ORGS_FETCH_AGENT_GROUPS` | Get agent groups and ordering |
| `PHANTOMBUSTER_GET_BRANCHES_FETCH_ALL` | List all script branches |
| `PHANTOMBUSTER_GET_BRANCHES_DIFF` | Compare staging vs. release branches |
---
*Powered by [Composio](https://composio.dev)*

179
prismic-automation/SKILL.md
View File

@@ -1,91 +1,150 @@
---
name: prismic-automation
description: "Automate Prismic tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Prismic Automation
description: "Automate headless CMS operations in Prismic -- query documents, search content, retrieve custom types, and manage repository refs through the Composio Prismic integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Prismic Automation via Rube MCP
# Prismic Automation
Automate Prismic operations through Composio's Prismic toolkit via Rube MCP.
Manage your **Prismic** headless CMS directly from Claude Code. Query documents by type, full-text search content, inspect custom types, and work with repository refs for content versioning.
**Toolkit docs**: [composio.dev/toolkits/prismic](https://composio.dev/toolkits/prismic)
**Toolkit docs:** [composio.dev/toolkits/prismic](https://composio.dev/toolkits/prismic)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Prismic connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `prismic`
- 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. Add the Composio MCP server to your configuration:
```
https://rube.app/mcp
```
2. Connect your Prismic account when prompted. The agent will provide an authentication link.
3. Most content queries require a `ref` token. Always start by calling `PRISMIC_REPOSITORY_API_GET_REFS` or `PRISMIC_REPOSITORY_API_GET_INFO` to obtain the master ref.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `prismic`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Get Repository Info and Refs
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Prismic operations", known_fields: ""}]
session: {generate_id: true}
```
Retrieve comprehensive repository metadata including available refs (content versions), custom types, languages, tags, and bookmarks. This is typically your first API call.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tools:** `PRISMIC_REPOSITORY_API_GET_INFO`, `PRISMIC_REPOSITORY_API_GET_REFS`
## Core Workflow Pattern
No parameters required -- these endpoints return the full repository configuration. The `refs` field is critical since refs are required for all content queries.
### Step 1: Discover Available Tools
Example prompt: *"Get my Prismic repository info and the current master ref"*
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Prismic task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Query Documents with Predicates
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["prismic"]
session_id: "your_session_id"
```
Fetch documents using Prismic's predicate query syntax with full pagination and filtering support.
### Step 3: Execute Tools
**Tool:** `PRISMIC_CONTENT_API_QUERY_DOCUMENTS`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
Key parameters:
- `ref` (required) -- content release reference ID (typically the master ref)
- `q` -- predicate query, e.g., `[[at(document.type, "page")]]`
- `page` (min 1) and `pageSize` (1-100) -- pagination
- `lang` -- language code, e.g., `en-us` (default `*` for all)
- `orderings` -- sort order, e.g., `[my.article.date desc]`
- `fetch` -- comma-separated fields to fetch, reducing response size
- `fetchLinks` -- resolve linked document fields inline
Example prompt: *"Query all published blog posts in Prismic, sorted by date descending, in English"*
---
### 3. Fetch Documents by Type
Retrieve all documents of a specific custom type with automatic master ref resolution.
**Tool:** `PRISMIC_GET_DOCUMENTS_BY_TYPE`
Key parameters:
- `type` (required) -- custom type API ID, e.g., `blog_post`, `article`, `page`
- `page` (default 1) and `pageSize` (1-100, default 20)
- `lang` -- language code filter
- `orderings` -- sort order, e.g., `[my.article.date desc]`
- `after` -- cursor-based pagination for deep pagination beyond page 50
Example prompt: *"Get all blog_post documents in Prismic, 20 per page"*
---
### 4. Full-Text Search
Search across all text fields in documents for specified terms. Case-insensitive, matches on root words.
**Tool:** `PRISMIC_CONTENT_API_GET_DOCUMENTS_WITH_FULLTEXT_SEARCH`
Key parameters:
- `q` (required) -- full-text predicate, e.g., `[[fulltext(document, "machine learning")]]`
- `page`, `pageSize`, `lang`, `orderings` -- same pagination/filtering as other queries
Example prompt: *"Search all Prismic documents for 'machine learning'"*
---
### 5. Get a Single Document by ID
Retrieve a specific document by its unique identifier.
**Tool:** `PRISMIC_GET_DOCUMENT_BY_ID`
Key parameters:
- `document_id` (required) -- unique document identifier
- `ref` (required) -- content ref from repository
- `lang` -- optional language filter
Example prompt: *"Fetch Prismic document Xx2KLhEAAJljVWaA"*
---
### 6. List Custom Types
Discover all custom types (content models) defined in the repository, including their structure definitions.
**Tool:** `PRISMIC_TYPES_API_GET_TYPES`
Key parameters:
- `limit` -- max number of types to return per page
- `page` -- page number (1-indexed)
- `sort` -- sort order, e.g., `name`
Example prompt: *"List all custom types in my Prismic repository"*
---
## 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
- **Ref is required for all content queries:** You must obtain a valid `ref` (typically the master ref) from `PRISMIC_REPOSITORY_API_GET_REFS` or `PRISMIC_REPOSITORY_API_GET_INFO` before querying any documents. Queries without a ref will fail.
- **Predicate syntax requires double brackets:** Prismic queries use double square brackets: `[[at(document.type, "page")]]`. For multiple predicates, combine them: `[[at(document.type, "blog")][at(document.tags, ["featured"])]]`.
- **Deep pagination limit:** Standard page-based pagination may fail beyond page 50. For deep pagination, use the `after` parameter with the last document ID from your previous result set.
- **pageSize cap is 100:** Requesting more than 100 documents per page will be rejected. Use pagination to iterate through larger result sets.
- **Language filtering:** The default language filter is `*` (all languages). If you need documents in a specific locale, always pass `lang` explicitly (e.g., `en-us`, `fr-fr`).
- **Integration fields require separate ref:** When using `PRISMIC_CONTENT_API_GET_DOCUMENTS_WITH_INTEGRATION_FIELDS`, you need an `integrationFieldsRef` in addition to the standard content `ref`.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Prismic-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `prismic` |
| 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` |
| Tool Slug | Description |
|---|---|
| `PRISMIC_REPOSITORY_API_GET_INFO` | Get repository metadata, refs, types, languages |
| `PRISMIC_REPOSITORY_API_GET_REFS` | List all refs (master + releases) |
| `PRISMIC_TYPES_API_GET_TYPES` | List all custom types / content models |
| `PRISMIC_CONTENT_API_QUERY_DOCUMENTS` | Query documents with predicates and pagination |
| `PRISMIC_GET_DOCUMENTS_BY_TYPE` | Fetch documents filtered by custom type |
| `PRISMIC_GET_DOCUMENT_BY_ID` | Retrieve a single document by ID |
| `PRISMIC_CONTENT_API_GET_DOCUMENTS_WITH_FULLTEXT_SEARCH` | Full-text search across all documents |
| `PRISMIC_CONTENT_API_GET_DOCUMENTS_WITH_PREDICATES` | Filter documents with multiple predicate conditions |
| `PRISMIC_CONTENT_API_GET_DOCUMENTS_WITH_INTEGRATION_FIELDS` | Fetch documents with integration fields data |
| `PRISMIC_GET_DOCUMENTS_ORDERED` | Fetch documents sorted by specified fields |
---
*Powered by [Composio](https://composio.dev)*

170
productboard-automation/SKILL.md
View File

@@ -1,91 +1,157 @@
---
name: productboard-automation
description: "Automate Productboard tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Productboard Automation
description: "Automate product management workflows in Productboard -- manage features, notes, objectives, components, and releases through natural language commands."
requires:
mcp: [rube]
mcp:
- rube
---
# Productboard Automation via Rube MCP
# Productboard Automation
Automate Productboard operations through Composio's Productboard toolkit via Rube MCP.
Automate your Productboard product management operations directly from Claude Code. Create notes from customer feedback, browse features and objectives, link entities, and track releases -- all without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/productboard](https://composio.dev/toolkits/productboard)
**Toolkit docs:** [composio.dev/toolkits/productboard](https://composio.dev/toolkits/productboard)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Productboard connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `productboard`
- 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. Add the Rube MCP server to your Claude Code config with URL: `https://rube.app/mcp`
2. When prompted, authenticate your Productboard account through the connection link provided
3. Start automating your product management workflows with natural language
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `productboard`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Manage Customer Notes
Create notes from customer feedback and organize them with tags, links, and followers.
**Tools:** `PRODUCTBOARD_CREATE_NOTE`, `PRODUCTBOARD_LIST_NOTES`, `PRODUCTBOARD_ADD_NOTE_TAG`, `PRODUCTBOARD_ADD_NOTE_FOLLOWERS`, `PRODUCTBOARD_CREATE_NOTE_LINK`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Productboard operations", known_fields: ""}]
session: {generate_id: true}
Create a note titled "Mobile app crash report" with content from customer feedback, tagged "bug" and linked to feature abc-123
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Key parameters for `PRODUCTBOARD_CREATE_NOTE`:
- `title` (required) and `content` (required) -- note title and body
- `customer_email` or `user.email` -- attribute to a customer/user
- `tags` -- array of tag strings for categorization
- `display_url` -- URL linked from the note title
- `source` -- origin system with `origin` and `record_id`
- `company` -- associate with a company
## Core Workflow Pattern
Key parameters for `PRODUCTBOARD_LIST_NOTES`:
- `createdFrom` / `createdTo` -- ISO 8601 date range
- `last` -- relative time window (e.g., `"6m"`, `"10d"`, `"24h"`)
- `term` -- full-text search by title or content
- `allTags` / `anyTag` -- filter by tags (cannot combine both)
- `featureId`, `companyId`, `ownerEmail`, `source` -- entity filters
- `pageLimit` (max 100) / `pageCursor` -- pagination
### Step 1: Discover Available Tools
### 2. Browse and Retrieve Features
List all features/subfeatures and retrieve detailed information.
**Tools:** `PRODUCTBOARD_LIST_FEATURES`, `PRODUCTBOARD_RETRIEVE_FEATURE`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Productboard task"}]
session: {id: "existing_session_id"}
List the first 50 features in Productboard, then get details on feature abc-def-123
```
### Step 2: Check Connection
- `PRODUCTBOARD_LIST_FEATURES` supports `pageLimit` (default 100) and `pageOffset` for pagination
- `PRODUCTBOARD_RETRIEVE_FEATURE` requires feature `id` (UUID) to get complete details
### 3. Objectives and Key Results (OKRs)
List objectives, view feature-objective links, and browse key results.
**Tools:** `PRODUCTBOARD_LIST_OBJECTIVES`, `PRODUCTBOARD_LIST_FEATURE_OBJECTIVES`, `PRODUCTBOARD_LIST_KEY_RESULTS`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["productboard"]
session_id: "your_session_id"
Show me all in-progress objectives owned by alice@example.com
```
### Step 3: Execute Tools
Key parameters for `PRODUCTBOARD_LIST_OBJECTIVES`:
- `status.name` -- filter by status (e.g., `"In Progress"`)
- `owner.email` -- filter by owner email
- `parent.id` -- filter by parent objective
- `archived` -- filter by archived state
`PRODUCTBOARD_LIST_FEATURE_OBJECTIVES`:
- Requires `id` (UUID) of a **top-level feature** (not subfeatures)
- Supports `pageCursor` for pagination
### 4. Component Management
List product components for organizing features and the product hierarchy.
**Tool:** `PRODUCTBOARD_LIST_COMPONENTS`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
List all components in our Productboard workspace
```
- Supports `page_limit` and `page_offset` for pagination
- Follow `links.next` for additional pages
### 5. Release Tracking
View feature-release assignments with state and date filters.
**Tool:** `PRODUCTBOARD_LIST_FEATURE_RELEASE_ASSIGNMENTS`
```
Show all active release assignments for feature abc-123
```
- Filter by `feature.id`, `release.id`, `release.state` (planned, active, closed)
- Date range filters: `release.timeframe.endDate.from` and `release.timeframe.endDate.to` (YYYY-MM-DD)
### 6. Link Notes to Features
Connect customer feedback notes to product features for insight aggregation.
**Tool:** `PRODUCTBOARD_CREATE_NOTE_LINK`
```
Link note 3fa85f64-5717 to feature 1b6c8c76-8f5d for tracking
```
- Requires `noteId` (UUID) and `entityId` (UUID of feature, component, or product)
- Use after creating notes to ensure feedback is connected to the right product areas
---
## 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
- **Top-level features only for objectives:** `PRODUCTBOARD_LIST_FEATURE_OBJECTIVES` only works with top-level feature IDs, not subfeature IDs. Use `PRODUCTBOARD_LIST_FEATURES` to identify which features are top-level.
- **Tag filter exclusivity:** `allTags` and `anyTag` cannot be combined in `PRODUCTBOARD_LIST_NOTES`. Choose one filter strategy per query.
- **Relative vs. absolute dates:** The `last` parameter (e.g., `"24h"`) cannot be combined with `createdFrom`/`createdTo` in `PRODUCTBOARD_LIST_NOTES`. Use one approach, not both.
- **Cursor-based pagination:** Follow `links.next` or use `pageCursor` from responses for multi-page results. Offset-based and cursor-based pagination are used on different endpoints -- check each tool.
- **Note attribution:** Either `user.email` or `customer_email` must be provided in `PRODUCTBOARD_CREATE_NOTE` to attribute feedback. Without it, the note will have no customer association.
- **UUID formats required:** All entity IDs (features, notes, components) must be valid UUIDs. Passing malformed IDs causes 400 errors.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Productboard-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `productboard` |
| 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` |
| Tool Slug | Description |
|---|---|
| `PRODUCTBOARD_CREATE_NOTE` | Create a customer feedback note (requires `title`, `content`) |
| `PRODUCTBOARD_LIST_NOTES` | List notes with search, date, and tag filters |
| `PRODUCTBOARD_ADD_NOTE_TAG` | Add a tag to a note |
| `PRODUCTBOARD_ADD_NOTE_FOLLOWERS` | Add followers to a note by email |
| `PRODUCTBOARD_CREATE_NOTE_LINK` | Link a note to a feature/component (requires `noteId`, `entityId`) |
| `PRODUCTBOARD_LIST_FEATURES` | List all features with pagination |
| `PRODUCTBOARD_RETRIEVE_FEATURE` | Get detailed feature info by UUID |
| `PRODUCTBOARD_LIST_OBJECTIVES` | List objectives with status/owner filters |
| `PRODUCTBOARD_LIST_FEATURE_OBJECTIVES` | List objectives linked to a top-level feature |
| `PRODUCTBOARD_LIST_KEY_RESULTS` | List key results for objectives |
| `PRODUCTBOARD_LIST_COMPONENTS` | List product components with pagination |
| `PRODUCTBOARD_LIST_FEATURE_RELEASE_ASSIGNMENTS` | List feature-release assignments with filters |
---
*Powered by [Composio](https://composio.dev)*

175
quickbooks-automation/SKILL.md
View File

@@ -1,91 +1,160 @@
---
name: quickbooks-automation
description: "Automate Quickbooks tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: QuickBooks Automation
description: "QuickBooks Automation: manage invoices, customers, accounts, and payments in QuickBooks Online for streamlined bookkeeping"
requires:
mcp: [rube]
---
# Quickbooks Automation via Rube MCP
# QuickBooks Automation
Automate Quickbooks operations through Composio's Quickbooks toolkit via Rube MCP.
Automate QuickBooks Online operations including creating invoices, managing customers, querying accounts, and listing invoices for financial reporting.
**Toolkit docs**: [composio.dev/toolkits/quickbooks](https://composio.dev/toolkits/quickbooks)
**Toolkit docs:** [composio.dev/toolkits/quickbooks](https://composio.dev/toolkits/quickbooks)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Quickbooks connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `quickbooks`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `quickbooks`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure an active connection exists for the `quickbooks` toolkit. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
---
Always discover available tools before executing workflows:
## Core Workflows
### 1. Create an Invoice
Create a new invoice for a customer with line items.
**Tool:** `QUICKBOOKS_CREATE_INVOICE`
**Key Parameters:**
- `customer_id` (required) -- ID of the customer (CustomerRef.value)
- `lines` (required) -- Array of line item objects. Each must include:
- `DetailType` -- e.g., `"SalesItemLineDetail"`
- `Amount` -- Line item total
- `SalesItemLineDetail` -- Object with `ItemRef` containing `value` (item ID)
- `minorversion` -- Optional API version parameter
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Quickbooks operations", known_fields: ""}]
session: {generate_id: true}
Tool: QUICKBOOKS_CREATE_INVOICE
Arguments:
customer_id: "21"
lines: [
{
"DetailType": "SalesItemLineDetail",
"Amount": 150.00,
"SalesItemLineDetail": {
"ItemRef": {"value": "1", "name": "Services"}
}
}
]
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Prerequisites:** Resolve the customer ID using `QUICKBOOKS_READ_CUSTOMER` or create one with `QUICKBOOKS_CREATE_CUSTOMER`. Resolve item/account IDs using `QUICKBOOKS_QUERY_ACCOUNT`.
## Core Workflow Pattern
---
### Step 1: Discover Available Tools
### 2. Manage Customers
Create and read customer records.
**Tools:**
- `QUICKBOOKS_CREATE_CUSTOMER` -- Create a new customer
- `QUICKBOOKS_READ_CUSTOMER` -- Read a customer by ID
**Key Parameters for `QUICKBOOKS_CREATE_CUSTOMER`:**
- `display_name` -- Display name (must be unique across customers, vendors, employees; max 500 chars)
- `given_name` -- First name (max 100 chars)
- `family_name` -- Last name (max 100 chars)
- `middle_name` -- Middle name (max 100 chars)
- `title` -- Title, e.g., `"Mr."`, `"Dr."` (max 16 chars)
- `suffix` -- Name suffix, e.g., `"Jr."` (max 16 chars)
> At least one of `display_name`, `title`, `given_name`, `middle_name`, `family_name`, or `suffix` is required.
**Key Parameters for `QUICKBOOKS_READ_CUSTOMER`:**
- `customer_id` (required) -- ID of the customer to read
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Quickbooks task"}]
session: {id: "existing_session_id"}
Tool: QUICKBOOKS_CREATE_CUSTOMER
Arguments:
display_name: "Acme Corporation"
given_name: "John"
family_name: "Doe"
```
### Step 2: Check Connection
---
### 3. Query and Read Accounts
Retrieve account information for use in invoice line items and financial reporting.
**Tools:**
- `QUICKBOOKS_QUERY_ACCOUNT` -- Execute a query against accounts
- `QUICKBOOKS_READ_ACCOUNT` -- Read a specific account by ID
**Key Parameters for `QUICKBOOKS_QUERY_ACCOUNT`:**
- `query` (required) -- SQL-like query string, e.g., `"SELECT * FROM Account WHERE AccountType = 'Income'"`
**Example:**
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["quickbooks"]
session_id: "your_session_id"
Tool: QUICKBOOKS_QUERY_ACCOUNT
Arguments:
query: "SELECT * FROM Account WHERE AccountType = 'Income' MAXRESULTS 10"
```
### 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"
```
### 4. List and Filter Invoices
Retrieve invoices with optional pagination and filtering.
**Tool:** `QUICKBOOKS_LIST_INVOICES`
**Steps:**
1. Call `QUICKBOOKS_LIST_INVOICES` with pagination parameters
2. Use `start_position` and `max_results` to page through results
3. Filter by specific criteria as needed
---
## Recommended Execution Plan
1. **Resolve the customer** using `QUICKBOOKS_READ_CUSTOMER` (if you have a customer ID) or create one with `QUICKBOOKS_CREATE_CUSTOMER`
2. **Resolve item/revenue accounts** using `QUICKBOOKS_QUERY_ACCOUNT` and `QUICKBOOKS_READ_ACCOUNT` to get account or item IDs for invoice line items
3. **Create the invoice** using `QUICKBOOKS_CREATE_INVOICE` with the resolved `customer_id` and well-formed line items
4. **Verify creation** using `QUICKBOOKS_LIST_INVOICES` to locate the new invoice by ID or DocNumber
---
## 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
| Pitfall | Detail |
|---------|--------|
| **Invalid references** | `QUICKBOOKS_CREATE_INVOICE` fails if `customer_id` or `ItemRef.value` point to non-existent or inactive records. Always resolve IDs first. |
| **Line item validation** | Incorrect `DetailType` or missing `SalesItemLineDetail` fields cause schema/validation errors during invoice creation. |
| **Pagination** | `QUICKBOOKS_LIST_INVOICES` uses `start_position` and `max_results`. Incomplete pagination settings can miss invoices in larger books. |
| **Sync tokens** | Any later edits require the latest `SyncToken` from a fresh invoice read. Stale sync tokens cause update rejections. |
| **Rate limits** | QuickBooks enforces per-minute and daily API caps. High-volume runs should include backoff to avoid throttling errors. |
| **DisplayName uniqueness** | Customer `display_name` must be unique across all Customer, Vendor, and Employee objects. Duplicates cause creation failures. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Quickbooks-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `quickbooks` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `QUICKBOOKS_CREATE_INVOICE` | Create a new invoice with line items |
| `QUICKBOOKS_READ_CUSTOMER` | Read a customer record by ID |
| `QUICKBOOKS_CREATE_CUSTOMER` | Create a new customer record |
| `QUICKBOOKS_QUERY_ACCOUNT` | Query accounts with SQL-like syntax |
| `QUICKBOOKS_READ_ACCOUNT` | Read a specific account by ID |
| `QUICKBOOKS_LIST_INVOICES` | List invoices with pagination |
---
*Powered by [Composio](https://composio.dev)*

214
ramp-automation/SKILL.md
View File

@@ -1,91 +1,203 @@
---
name: ramp-automation
description: "Automate Ramp tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Ramp Automation
description: "Ramp Automation: manage corporate card transactions, reimbursements, users, and expense tracking via the Ramp platform"
requires:
mcp: [rube]
---
# Ramp Automation via Rube MCP
# Ramp Automation
Automate Ramp operations through Composio's Ramp toolkit via Rube MCP.
Automate Ramp corporate finance operations including retrieving transactions, managing reimbursements, searching expenses, viewing card details, and listing users for expense management and accounting workflows.
**Toolkit docs**: [composio.dev/toolkits/ramp](https://composio.dev/toolkits/ramp)
**Toolkit docs:** [composio.dev/toolkits/ramp](https://composio.dev/toolkits/ramp)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Ramp connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ramp`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ramp`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure an active connection exists for the `ramp` toolkit. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
---
Always discover available tools before executing workflows:
## Core Workflows
### 1. List All Transactions
Retrieve all corporate card transactions with comprehensive filtering options.
**Tool:** `RAMP_GET_ALL_TRANSACTIONS`
**Key Parameters:**
- `from_date` -- Transactions after this date (ISO 8601 datetime)
- `to_date` -- Transactions before this date (ISO 8601 datetime, default: today)
- `user_id` -- Filter by user UUID
- `card_id` -- Filter by physical card UUID
- `department_id` -- Filter by department UUID
- `merchant_id` -- Filter by merchant UUID
- `entity_id` -- Filter by business entity UUID
- `min_amount` / `max_amount` -- Amount range filter (USD)
- `state` -- Transaction state; set to `"ALL"` to include declined transactions
- `approval_status` -- Filter by approval status
- `sync_status` -- Filter by ERP sync status (supersedes `sync_ready` and `has_no_sync_commits`)
- `has_no_sync_commits` -- `true` for unsynced transactions
- `sync_ready` -- `true` for transactions ready to sync to ERP
- `requires_memo` -- `true` for transactions missing required memos
- `include_merchant_data` -- `true` to include full purchase data from merchant
- `page_size` -- Results per page (2--100, default: 20)
- `start` -- Pagination cursor: ID of last entity from previous page
- `order_by_date_desc` / `order_by_date_asc` -- Sort by date
- `order_by_amount_desc` / `order_by_amount_asc` -- Sort by amount
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Ramp operations", known_fields: ""}]
session: {generate_id: true}
Tool: RAMP_GET_ALL_TRANSACTIONS
Arguments:
from_date: "2026-02-01T00:00:00Z"
to_date: "2026-02-11T23:59:59Z"
page_size: 50
order_by_date_desc: true
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
---
## Core Workflow Pattern
### 2. Search Transactions
### Step 1: Discover Available Tools
Search transactions by merchant name, memo, or other transaction details.
**Tool:** `RAMP_SEARCH_TRANSACTIONS`
**Key Parameters:**
- `query` (required) -- Search text for merchant name, memo, or other details
- All filter parameters from `RAMP_GET_ALL_TRANSACTIONS` are also available
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Ramp task"}]
session: {id: "existing_session_id"}
Tool: RAMP_SEARCH_TRANSACTIONS
Arguments:
query: "AWS"
from_date: "2026-01-01T00:00:00Z"
page_size: 25
```
### Step 2: Check Connection
---
### 3. Get Transaction Details
Retrieve complete details of a specific transaction including merchant details, receipts, accounting codes, and dispute information.
**Tool:** `RAMP_GET_TRANSACTION`
**Key Parameters:**
- `transaction_id` (required) -- ID of the transaction
**Example:**
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["ramp"]
session_id: "your_session_id"
Tool: RAMP_GET_TRANSACTION
Arguments:
transaction_id: "txn_abc123def456"
```
### Step 3: Execute Tools
---
### 4. Manage Reimbursements
List and retrieve reimbursement records for approval workflows and expense analysis.
**Tools:**
- `RAMP_LIST_REIMBURSEMENTS` -- List reimbursements with filtering
- `RAMP_GET_REIMBURSEMENT` -- Get complete details of a specific reimbursement
**Key Parameters for `RAMP_LIST_REIMBURSEMENTS`:**
- `user_id` -- Filter by employee UUID
- `entity_id` -- Filter by business entity UUID
- `from_date` / `to_date` -- Date range for creation date
- `from_submitted_at` / `to_submitted_at` -- Date range for submission date
- `from_transaction_date` / `to_transaction_date` -- Underlying transaction date range
- `awaiting_approval_by_user_id` -- Filter for reimbursements pending a specific approver
- `sync_status` -- Filter by ERP sync status
- `has_no_sync_commits` -- `true` for unsynced reimbursements
- `sync_ready` -- `true` for reimbursements ready to sync
- `direction` -- `"BUSINESS_TO_USER"` (default) or `"USER_TO_BUSINESS"` (repayments)
- `page_size` -- Results per page (2--100, default: 20)
- `start` -- Pagination cursor
**Example:**
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: RAMP_LIST_REIMBURSEMENTS
Arguments:
from_date: "2026-02-01T00:00:00Z"
sync_ready: true
page_size: 50
```
---
### 5. List Users and Get My Transactions
View organization users and personal transaction history.
**Tools:**
- `RAMP_LIST_USERS` -- List users with filtering by department, role, location, entity
- `RAMP_GET_MY_TRANSACTIONS` -- Get transactions for the authenticated user
**Key Parameters for `RAMP_LIST_USERS`:**
- `department_id` -- Filter by department UUID
- `role` -- Filter by user role
- `email` -- Filter by email address
- `employee_id` -- Filter by employee ID
- `entity_id` -- Filter by business entity UUID
- `location_id` -- Filter by location UUID
- `page_size` -- Results per page (2--100, default: 20)
**Example:**
```
Tool: RAMP_LIST_USERS
Arguments:
role: "ADMIN"
page_size: 50
```
---
### 6. View Card Details and Accounting Fields
Retrieve card information and custom accounting field configurations.
**Tools:**
- `RAMP_GET_CARD` -- Get detailed card information (spending limits, cardholder, fulfillment status)
- `RAMP_FETCH_CUSTOM_ACCOUNTING_FIELD` -- Fetch custom accounting field definitions
---
## 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
| Pitfall | Detail |
|---------|--------|
| **Pagination required** | All list endpoints return paginated results. Use the `start` parameter with the ID of the last entity from the previous page to iterate. |
| **Date format** | All date parameters must be ISO 8601 datetime format (e.g., `"2026-02-11T00:00:00Z"`). Plain date strings will fail. |
| **sync_status priority** | When `sync_status` is set, it supersedes both `has_no_sync_commits` and `sync_ready` parameters. |
| **Amount filters in USD** | `min_amount` and `max_amount` are in USD. Ensure correct currency context when filtering. |
| **state=ALL for declined** | By default, declined transactions are excluded. Set `state: "ALL"` to include them in results. |
| **page_size bounds** | Must be between 2 and 100. Default is 20. Values outside this range cause errors. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Ramp-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ramp` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `RAMP_GET_ALL_TRANSACTIONS` | List all transactions with filtering |
| `RAMP_SEARCH_TRANSACTIONS` | Search transactions by text query |
| `RAMP_GET_TRANSACTION` | Get details of a specific transaction |
| `RAMP_GET_MY_TRANSACTIONS` | Get authenticated user's transactions |
| `RAMP_LIST_REIMBURSEMENTS` | List reimbursements with filtering |
| `RAMP_GET_REIMBURSEMENT` | Get details of a specific reimbursement |
| `RAMP_LIST_USERS` | List organization users |
| `RAMP_GET_CARD` | Get card details |
| `RAMP_FETCH_CUSTOM_ACCOUNTING_FIELD` | Fetch custom accounting field config |
---
*Powered by [Composio](https://composio.dev)*

151
replicate-automation/SKILL.md
View File

@@ -1,91 +1,138 @@
---
name: replicate-automation
description: "Automate Replicate tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Replicate Automation
description: "Automate Replicate AI model operations -- run predictions, upload files, inspect model schemas, list versions, and manage prediction history via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Replicate Automation via Rube MCP
# Replicate Automation
Automate Replicate operations through Composio's Replicate toolkit via Rube MCP.
Automate your Replicate AI model workflows -- run predictions on any public model (image generation, LLMs, audio, video), upload input files, inspect model schemas and documentation, list model versions, and track prediction history.
**Toolkit docs**: [composio.dev/toolkits/replicate](https://composio.dev/toolkits/replicate)
**Toolkit docs:** [composio.dev/toolkits/replicate](https://composio.dev/toolkits/replicate)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Replicate connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `replicate`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your Replicate account when prompted (API token authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `replicate`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Get Model Details and Schema
Use `REPLICATE_MODELS_GET` to inspect a model's input/output schema before running predictions.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Replicate operations", known_fields: ""}]
session: {generate_id: true}
Tool: REPLICATE_MODELS_GET
Inputs:
- model_owner: string (required) -- e.g., "meta", "black-forest-labs", "stability-ai"
- model_name: string (required) -- e.g., "meta-llama-3-8b-instruct", "flux-1.1-pro"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Important:** Each model has unique input keys and types. Always check the `openapi_schema` from this response before constructing prediction inputs.
## Core Workflow Pattern
### 2. Run a Prediction
### Step 1: Discover Available Tools
Use `REPLICATE_MODELS_PREDICTIONS_CREATE` to run inference on any model with optional synchronous waiting and webhooks.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Replicate task"}]
session: {id: "existing_session_id"}
Tool: REPLICATE_MODELS_PREDICTIONS_CREATE
Inputs:
- model_owner: string (required) -- e.g., "meta", "black-forest-labs"
- model_name: string (required) -- e.g., "flux-1.1-pro", "sdxl"
- input: object (required) -- model-specific inputs, e.g., { "prompt": "A sunset over mountains" }
- wait_for: integer (1-60 seconds, optional) -- synchronous wait for completion
- cancel_after: string (optional) -- max execution time, e.g., "300s", "5m"
- webhook: string (optional) -- HTTPS URL for async completion notifications
- webhook_events_filter: array (optional) -- ["start", "output", "logs", "completed"]
```
### Step 2: Check Connection
**Sync vs Async:** Use `wait_for` (1-60s) for fast models. For long-running jobs, omit it and use webhooks or poll via `REPLICATE_PREDICTIONS_LIST`.
### 3. Upload Files for Model Input
Use `REPLICATE_CREATE_FILE` to upload images, documents, or other binary inputs that models need.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["replicate"]
session_id: "your_session_id"
Tool: REPLICATE_CREATE_FILE
Inputs:
- content: string (required) -- base64-encoded file content
- filename: string (required) -- e.g., "input.png", "audio.wav" (max 255 bytes UTF-8)
- content_type: string (default "application/octet-stream") -- MIME type
- metadata: object (optional) -- custom JSON metadata
```
### Step 3: Execute Tools
### 4. Read Model Documentation
Use `REPLICATE_MODELS_README_GET` to access a model's README in Markdown format for detailed usage instructions.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: REPLICATE_MODELS_README_GET
Inputs:
- model_owner: string (required)
- model_name: string (required)
```
### 5. List Model Versions
Use `REPLICATE_MODELS_VERSIONS_LIST` to see all available versions of a model, sorted newest first.
```
Tool: REPLICATE_MODELS_VERSIONS_LIST
Inputs:
- model_owner: string (required)
- model_name: string (required)
```
### 6. Track Prediction History and Files
Use `REPLICATE_PREDICTIONS_LIST` to retrieve prediction history, and `REPLICATE_FILES_GET`/`REPLICATE_FILES_LIST` to manage uploaded files.
```
Tool: REPLICATE_PREDICTIONS_LIST
- Lists all predictions for the authenticated user with pagination
Tool: REPLICATE_FILES_LIST
- Lists uploaded files, most recent first
Tool: REPLICATE_FILES_GET
- Get details of a specific file by 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
| Pitfall | Detail |
|---------|--------|
| Model-specific input keys | Each model has unique input keys and types. Using the wrong key causes validation errors. Always call `REPLICATE_MODELS_GET` first to check the `openapi_schema`. |
| File upload encoding | `REPLICATE_CREATE_FILE` requires base64-encoded content. Binary files treated as text (UTF-8) will fail with decode errors. |
| Public vs deployment paths | Public models must be run via `REPLICATE_MODELS_PREDICTIONS_CREATE`. Using deployment-oriented paths causes HTTP 404 failures. |
| Sync wait limits | `wait_for` supports 1-60 seconds only. Long-running jobs need async handling via webhooks or polling `REPLICATE_PREDICTIONS_LIST`. |
| Image model constraints | Image models like flux-1.1-pro have specific constraints (e.g., max width/height 1440px, valid aspect ratios). Check the model schema first. |
| Stale file references | Heavy usage creates many uploads. Routinely check `REPLICATE_FILES_LIST` to avoid using stale `file_id` references. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Replicate-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `replicate` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `REPLICATE_MODELS_GET` | Get model details, schema, and metadata |
| `REPLICATE_MODELS_PREDICTIONS_CREATE` | Run a prediction on a model |
| `REPLICATE_CREATE_FILE` | Upload a file for model input |
| `REPLICATE_MODELS_README_GET` | Get model README documentation |
| `REPLICATE_MODELS_VERSIONS_LIST` | List all versions of a model |
| `REPLICATE_PREDICTIONS_LIST` | List prediction history with pagination |
| `REPLICATE_FILES_LIST` | List uploaded files |
| `REPLICATE_FILES_GET` | Get file details by ID |
---
*Powered by [Composio](https://composio.dev)*

121
ring-central-automation/SKILL.md
View File

@@ -1,91 +1,56 @@
---
name: ring-central-automation
description: "Automate RingCentral tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: RingCentral Automation
description: "RingCentral automation via Rube MCP -- toolkit not currently available in Composio; no RING_CENTRAL_ tools found"
requires:
mcp: [rube]
mcp:
- rube
---
# RingCentral Automation via Rube MCP
# RingCentral Automation
Automate RingCentral operations through Composio's RingCentral toolkit via Rube MCP.
> **Status: Toolkit Not Available** -- RUBE_SEARCH_TOOLS returned no `ring_central`-specific tools. The RingCentral toolkit is not currently available in Composio's tool catalog. Searches returned tools from unrelated toolkits (ClickSend, Telnyx, Slack) instead.
**Toolkit docs**: [composio.dev/toolkits/ring_central](https://composio.dev/toolkits/ring_central)
**Toolkit docs:** [composio.dev/toolkits/ring_central](https://composio.dev/toolkits/ring_central)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active RingCentral connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ring_central`
- 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 `ring_central`
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: "RingCentral 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 RingCentral task"}]
session: {id: "existing_session_id"}
```
### Step 2: Check Connection
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["ring_central"]
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 RingCentral-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ring_central` |
| 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` |
1. Add the Rube MCP server to your environment: `https://rube.app/mcp`
2. Check availability by calling `RUBE_SEARCH_TOOLS` with RingCentral-related queries
3. If `RING_CENTRAL_*` tools appear in the future, connect via `RUBE_MANAGE_CONNECTIONS` with toolkit `ring_central`
---
## Current Status
As of the last tool discovery scan, no `RING_CENTRAL_*` tool slugs were returned by RUBE_SEARCH_TOOLS. Queries for RingCentral messaging, call logs, fax, and extension management all returned tools from other toolkits:
- SMS/messaging queries returned **ClickSend** tools (`CLICKSEND_CREATE_SMS_SEND`, etc.)
- Call management queries returned **Pipedrive** call log tools
- Telephony/VoIP queries returned **Telnyx** notification tools
- Fax queries returned **ClickSend** fax automation tools
This indicates the `ring_central` toolkit either has no tools registered or is not yet integrated into the Composio platform.
---
## Alternatives
If you need telephony, SMS, or communication automation, consider these available toolkits:
| Need | Alternative Toolkit | Example Tool |
|------|-------------------|--------------|
| SMS messaging | ClickSend | `CLICKSEND_CREATE_SMS_SEND` |
| VoIP/telephony | Telnyx | `TELNYX_CREATE_NOTIFICATION_CHANNEL` |
| Team messaging | Slack / Webex | `SLACK_SEND_MESSAGE` / `WEBEX_MESSAGING_CREATE_MESSAGE` |
---
## When Tools Become Available
Once RingCentral tools are added to Composio, this skill should be updated with real tool slugs, schemas, and pitfalls following the same pattern as other automation skills in this collection.
---
*Powered by [Composio](https://composio.dev)*

190
semrush-automation/SKILL.md
View File

@@ -1,91 +1,161 @@
---
name: semrush-automation
description: "Automate Semrush tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: SEMrush Automation
description: "Automate SEO analysis with SEMrush -- research keywords, analyze domain organic rankings, audit backlinks, assess keyword difficulty, and discover related terms through the Composio SEMrush integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Semrush Automation via Rube MCP
# SEMrush Automation
Automate Semrush operations through Composio's Semrush toolkit via Rube MCP.
Run **SEMrush** SEO analytics directly from Claude Code. Analyze domain keywords, audit backlink profiles, research keyword difficulty, discover related terms, and track organic page performance without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/semrush](https://composio.dev/toolkits/semrush)
**Toolkit docs:** [composio.dev/toolkits/semrush](https://composio.dev/toolkits/semrush)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Semrush connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `semrush`
- 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. Add the Composio MCP server to your configuration:
```
https://rube.app/mcp
```
2. Connect your SEMrush account when prompted. The agent will provide an authentication link.
3. All SEMrush tools require a `database` parameter specifying the regional database (e.g., `us`, `uk`, `de`). Choose the correct region for your target audience.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `semrush`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Domain Organic Keywords Analysis
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Semrush operations", known_fields: ""}]
session: {generate_id: true}
```
Retrieve all organic search keywords for a domain, including positions, traffic estimates, CPC, and keyword difficulty.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `SEMRUSH_DOMAIN_ORGANIC_SEARCH_KEYWORDS`
## Core Workflow Pattern
Key parameters:
- `domain` (required) -- e.g., `example.com`
- `database` (required) -- regional database code (e.g., `us`, `uk`, `de`)
- `display_limit` (default 10000) and `display_offset` (default 0) -- pagination
- `display_sort` -- sort by position, traffic, volume, etc. (e.g., `tr_desc` for traffic descending)
- `display_date` -- historical data in `YYYYMM15` format (monthly) or `YYYYMMDD` (daily)
- `export_columns` -- specify columns like `Ph` (phrase), `Po` (position), `Nq` (volume), `Tr` (traffic), `Kd` (difficulty)
- `display_filter` -- filter by specific columns
### Step 1: Discover Available Tools
Example prompt: *"Get the top 100 organic keywords for example.com in the US database, sorted by traffic"*
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Semrush task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Keyword Overview and Batch Analysis
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["semrush"]
session_id: "your_session_id"
```
Get detailed metrics for individual keywords or analyze up to 100 keywords at once.
### Step 3: Execute Tools
**Tools:** `SEMRUSH_KEYWORD_OVERVIEW_ONE_DATABASE`, `SEMRUSH_BATCH_KEYWORD_OVERVIEW`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
For single keyword:
- `phrase` (required) -- keyword to investigate
- `database` (required) -- regional database
For batch (up to 100 keywords):
- `phrase` (required) -- semicolon-separated keywords (max 255 chars total)
- `database` (required) -- regional database
- `export_columns` -- `Ph` (phrase), `Nq` (volume), `Cp` (CPC), `Co` (competition), `Kd` (difficulty), `In` (intent)
Example prompt: *"Get keyword metrics for 'seo services;content marketing;link building' in the US database"*
---
### 3. Domain Organic Pages Report
Discover which URLs on a domain drive the most organic traffic and visibility.
**Tool:** `SEMRUSH_DOMAIN_ORGANIC_PAGES`
Key parameters:
- `domain` (required) -- target domain
- `database` (required) -- regional database
- `display_sort` -- e.g., `pc_desc` for traffic share descending
- `display_limit` and `display_offset` -- pagination
- `export_columns` -- `Ur` (URL), `Pc` (traffic %), `Tg` (traffic), `Tr` (traffic cost)
Example prompt: *"Show the top 50 organic pages for example.com ranked by traffic share"*
---
### 4. Backlink Profile Overview
Get a summary of backlinks for a domain including Authority Score, link types, and referring domain counts.
**Tool:** `SEMRUSH_BACKLINKS_OVERVIEW`
Key parameters:
- `target` (required) -- domain, subdomain, or full URL
- `target_type` (required) -- `root_domain`, `domain`, or `url`
- `export_columns` -- `ascore` (Authority Score), `total` (total backlinks), `domains_num` (referring domains), `follows_num`, `nofollows_num`, etc.
Example prompt: *"Get the backlink overview for example.com including Authority Score and referring domain count"*
---
### 5. Keyword Difficulty Assessment
Score how hard it is to rank in the top 10 for specific keywords (0-100 scale).
**Tool:** `SEMRUSH_KEYWORD_DIFFICULTY`
Key parameters:
- `phrase` (required) -- keyword to analyze
- `database` (required) -- regional database
- `export_columns` -- `Ph` (phrase), `Kd` (difficulty score)
Example prompt: *"What is the keyword difficulty for 'best project management software' in the US?"*
---
### 6. Discover Related Keywords
Find synonyms, variations, and related terms for a seed keyword to expand your content strategy.
**Tool:** `SEMRUSH_RELATED_KEYWORDS`
Key parameters:
- `phrase` (required) -- seed keyword
- `database` (required) -- regional database
- `display_limit` (default 10000) -- max results
- `display_sort` -- e.g., `nq_desc` for volume descending, `kd_asc` for easiest first
- `export_columns` -- `Ph`, `Nq`, `Kd`, `Cp`, `Co`, `Rr` (relatedness score)
Example prompt: *"Find related keywords for 'project management' in the US, sorted by search volume"*
---
## 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
- **Pagination is essential:** `SEMRUSH_DOMAIN_ORGANIC_SEARCH_KEYWORDS` and `SEMRUSH_DOMAIN_ORGANIC_PAGES` can return very large datasets. Always use `display_limit` and `display_offset` instead of assuming a single page is complete.
- **CSV-style responses:** Many SEMrush tools return data as CSV-style text in a single field (e.g., `data/keyword_data`). You must parse rows and columns before analysis or joining reports.
- **"ERROR 50 :: NOTHING FOUND":** This literal string means the domain or keyword has no data in that database. Treat it as a valid zero-result response, not a transport error.
- **Batch keyword limits:** `SEMRUSH_BATCH_KEYWORD_OVERVIEW` may return HTTP 400 for problematic or oversized batches (max 255 chars total for the `phrase` field). Shrink batches or fall back to `SEMRUSH_KEYWORD_OVERVIEW_ONE_DATABASE` for individual lookups.
- **Date format:** Historical dates must use `YYYYMM15` format for monthly data (e.g., `20231015`). Using an incorrect format will return unexpected results.
- **Regional database matters:** Always use the correct regional database for your target audience. Results for `us` vs `uk` can differ dramatically in volume, CPC, and rankings.
- **Column codes:** Export columns use short codes (`Ph`, `Nq`, `Kd`, etc.). Avoid over-narrowing `export_columns` so key metrics like traffic, CPC, position, and difficulty are retained.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Semrush-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `semrush` |
| 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` |
| Tool Slug | Description |
|---|---|
| `SEMRUSH_DOMAIN_ORGANIC_SEARCH_KEYWORDS` | Organic keywords for a domain with positions and traffic |
| `SEMRUSH_KEYWORD_OVERVIEW_ONE_DATABASE` | Single keyword metrics (volume, CPC, difficulty) |
| `SEMRUSH_BATCH_KEYWORD_OVERVIEW` | Batch metrics for up to 100 keywords |
| `SEMRUSH_DOMAIN_ORGANIC_PAGES` | Top organic pages for a domain by traffic |
| `SEMRUSH_BACKLINKS_OVERVIEW` | Backlink profile summary with Authority Score |
| `SEMRUSH_BACKLINKS` | Detailed backlinks list for a target |
| `SEMRUSH_KEYWORD_DIFFICULTY` | Keyword difficulty score (0-100) |
| `SEMRUSH_RELATED_KEYWORDS` | Related/similar keywords for a seed phrase |
| `SEMRUSH_CATEGORIES` | Domain categories with confidence ratings |
| `SEMRUSH_DOMAIN_ORGANIC_SUBDOMAINS` | Subdomain-level organic rankings breakdown |
---
*Powered by [Composio](https://composio.dev)*

208
share-point-automation/SKILL.md
View File

@@ -1,91 +1,197 @@
---
name: share-point-automation
description: "Automate SharePoint tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: SharePoint Automation
description: "SharePoint Automation: manage sites, lists, documents, folders, pages, and search content across SharePoint and OneDrive"
requires:
mcp: [rube]
---
# SharePoint Automation via Rube MCP
# SharePoint Automation
Automate SharePoint operations through Composio's SharePoint toolkit via Rube MCP.
Automate SharePoint operations including managing sites, lists, documents, folders, and pages. Integrates with both SharePoint REST API and Microsoft Graph via OneDrive.
**Toolkit docs**: [composio.dev/toolkits/share_point](https://composio.dev/toolkits/share_point)
**Toolkit docs:** [composio.dev/toolkits/share_point](https://composio.dev/toolkits/share_point)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active SharePoint connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `share_point`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `share_point`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure active connections exist for the `share_point` and `one_drive` toolkits. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
> **Note:** Many OneDrive/SharePoint tools only work with organizational Microsoft 365 accounts (Azure AD/Entra ID). Personal Microsoft accounts are NOT supported.
Always discover available tools before executing workflows:
---
## Core Workflows
### 1. List and Browse Sites
Retrieve site details and enumerate subsites to discover the SharePoint topology.
**Tools:**
- `ONE_DRIVE_GET_SITE_DETAILS` -- Get metadata for a specific site by ID
- `ONE_DRIVE_LIST_SITE_SUBSITES` -- List all subsites of a parent site
**Key Parameters:**
- `site_id` (required) -- Composite format: `hostname,site-collection-guid,web-guid` (e.g., `"contoso.sharepoint.com,da60e844-...,712a596e-..."`)
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "SharePoint operations", known_fields: ""}]
session: {generate_id: true}
Tool: ONE_DRIVE_GET_SITE_DETAILS
Arguments:
site_id: "contoso.sharepoint.com,2C712604-1370-44E7-A1F5-426573FDA80A,2D2244C3-251A-49EA-93A8-39E1C3A060FE"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
---
## Core Workflow Pattern
### 2. Manage Lists
### Step 1: Discover Available Tools
Create lists, enumerate existing lists, and retrieve list items.
**Tools:**
- `SHARE_POINT_LIST_ALL_LISTS` -- Retrieve all lists on a site (supports OData filter, select, orderby, top)
- `SHARE_POINT_SHAREPOINT_CREATE_LIST` -- Create a new list with a specified template
- `ONE_DRIVE_LIST_SITE_LISTS` -- List all lists under a site via Microsoft Graph
- `ONE_DRIVE_GET_SHAREPOINT_LIST_ITEMS` -- Retrieve items from a specific list
**Key Parameters for `SHARE_POINT_SHAREPOINT_CREATE_LIST`:**
- `name` (required) -- List name
- `template` (required) -- Template type: `"genericList"`, `"documentLibrary"`, `"tasks"`, etc.
- `description` -- Optional description
**Key Parameters for `SHARE_POINT_LIST_ALL_LISTS`:**
- `filter` -- OData filter, e.g., `"Hidden eq false"`
- `select` -- Properties to return, e.g., `"Title,Id"`
- `orderby` -- Sort expression, e.g., `"Title desc"`
- `top` -- Limit results count
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific SharePoint task"}]
session: {id: "existing_session_id"}
Tool: SHARE_POINT_SHAREPOINT_CREATE_LIST
Arguments:
name: "Project Tasks"
template: "tasks"
description: "Task tracking for Q1 deliverables"
```
### Step 2: Check Connection
---
### 3. Manage Folders and Files
Create folders, list files within folders, and navigate the document library.
**Tools:**
- `SHARE_POINT_SHAREPOINT_CREATE_FOLDER` -- Create a new folder in a document library
- `SHARE_POINT_LIST_FILES_IN_FOLDER` -- List files within a folder by server-relative URL
- `SHARE_POINT_GET_FOLDER_BY_SERVER_RELATIVE_URL` -- Get folder metadata by path
**Key Parameters for `SHARE_POINT_SHAREPOINT_CREATE_FOLDER`:**
- `folder_name` (required) -- Name of the folder to create
- `document_library` -- Target library (default: `"Shared Documents"`)
- `relative_path` -- Additional path within the library
**Key Parameters for `SHARE_POINT_LIST_FILES_IN_FOLDER`:**
- `folder_name` (required) -- Server-relative URL, e.g., `"/Shared Documents"`
- `select` -- Comma-separated properties, e.g., `"Name,ServerRelativeUrl,Length"`
- `top` -- Limit results count
- `orderby` -- Sort expression, e.g., `"Name desc"`
**Example:**
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["share_point"]
session_id: "your_session_id"
Tool: SHARE_POINT_LIST_FILES_IN_FOLDER
Arguments:
folder_name: "/Shared Documents/Reports"
select: "Name,ServerRelativeUrl,Length"
top: 50
```
### Step 3: Execute Tools
---
### 4. Search SharePoint Content
Use Keyword Query Language (KQL) to search documents, list items, and other content across the site.
**Tool:** `SHARE_POINT_SEARCH_QUERY`
**Key Parameters:**
- `querytext` (required) -- KQL query, e.g., `"project report"`, `"FileType:docx"`, `"Author:\"John Doe\""`
- `rowlimit` -- Max results per request (default ~50, max 500)
- `startrow` -- Zero-based offset for pagination
- `selectproperties` -- Properties to return, e.g., `"Title,Author,Path"`
- `refinementfilters` -- Narrow results, e.g., `"FileType:equals(\"docx\")"`
**Example:**
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: SHARE_POINT_SEARCH_QUERY
Arguments:
querytext: "IsDocument:1 FileType:pdf"
rowlimit: 25
selectproperties: "Title,Author,Path,LastModifiedTime"
```
---
### 5. Track List Changes (Delta Query)
Use delta queries to get incremental changes (created, updated, deleted items) without reading the entire list.
**Tool:** `ONE_DRIVE_LIST_SHAREPOINT_LIST_ITEMS_DELTA`
**Key Parameters:**
- `site_id` (required) -- Composite site ID
- `list_id` (required) -- List GUID
- `token` -- Omit for initial sync; pass `"latest"` for empty response with token; pass previous token for changes since
- `expand` -- e.g., `"fields($select=ColumnA,ColumnB)"`
- `top` -- Max items per response
---
### 6. Retrieve Site Page Content
Read modern SharePoint Site Pages content including canvas web parts.
**Tool:** `SHARE_POINT_GET_SITE_PAGE_CONTENT`
**Key Parameters:**
- `page_file_name` -- File name with `.aspx` extension, e.g., `"Home.aspx"`
- `item_id` -- Alternative: list item ID of the page
- `render_as` -- `"raw"` (default), `"text"`, or `"html"`
- `site` -- Optional site name scope
---
## 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
| Pitfall | Detail |
|---------|--------|
| **Site ID format** | Must be composite: `hostname,site-collection-guid,web-guid`. Incorrect format causes 400 errors. |
| **Personal accounts unsupported** | `ONE_DRIVE_LIST_SITE_LISTS` and Graph-based tools only work with organizational M365 accounts, not personal MSA/Outlook.com accounts. |
| **OData filter syntax** | SharePoint OData filters use specific syntax. Test filters incrementally; unsupported expressions may silently return empty results. |
| **Pagination** | Use `skiptoken` for server-side paging in list operations. Incomplete pagination settings can miss results. |
| **Folder paths** | Must use server-relative URLs (e.g., `/Shared Documents`) not absolute URLs. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with SharePoint-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `share_point` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `ONE_DRIVE_GET_SITE_DETAILS` | Get metadata for a SharePoint site |
| `ONE_DRIVE_LIST_SITE_SUBSITES` | List subsites of a parent site |
| `ONE_DRIVE_LIST_SITE_LISTS` | List all lists under a site (Graph API) |
| `ONE_DRIVE_LIST_SHAREPOINT_LIST_ITEMS_DELTA` | Track incremental list changes |
| `ONE_DRIVE_GET_SHAREPOINT_LIST_ITEMS` | Retrieve items from a list |
| `ONE_DRIVE_LIST_DRIVES` | List available drives for a user/site/group |
| `ONE_DRIVE_LIST_SITE_COLUMNS` | List column definitions for a site |
| `SHARE_POINT_LIST_ALL_LISTS` | Retrieve all lists on a site (REST API) |
| `SHARE_POINT_SHAREPOINT_CREATE_LIST` | Create a new SharePoint list |
| `SHARE_POINT_SHAREPOINT_CREATE_FOLDER` | Create a folder in a document library |
| `SHARE_POINT_LIST_FILES_IN_FOLDER` | List files in a folder |
| `SHARE_POINT_SEARCH_QUERY` | Search content using KQL |
| `SHARE_POINT_GET_SITE_PAGE_CONTENT` | Retrieve Site Page content |
| `SHARE_POINT_GET_FOLDER_BY_SERVER_RELATIVE_URL` | Get folder metadata by path |
---
*Powered by [Composio](https://composio.dev)*

171
shortcut-automation/SKILL.md
View File

@@ -1,91 +1,158 @@
---
name: shortcut-automation
description: "Automate Shortcut tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Shortcut Automation
description: "Automate project management workflows in Shortcut -- create stories, manage tasks, track epics, and organize workflows through natural language commands."
requires:
mcp: [rube]
mcp:
- rube
---
# Shortcut Automation via Rube MCP
# Shortcut Automation
Automate Shortcut operations through Composio's Shortcut toolkit via Rube MCP.
Automate your Shortcut project management operations directly from Claude Code. Create and list stories, add tasks and comments, batch-create stories, and navigate workflows -- all without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/shortcut](https://composio.dev/toolkits/shortcut)
**Toolkit docs:** [composio.dev/toolkits/shortcut](https://composio.dev/toolkits/shortcut)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Shortcut connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `shortcut`
- 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. Add the Rube MCP server to your Claude Code config with URL: `https://rube.app/mcp`
2. When prompted, authenticate your Shortcut account through the connection link provided
3. Start automating your project management workflows with natural language
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `shortcut`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Create Stories
Add new stories to your Shortcut workspace with full configuration.
**Tool:** `SHORTCUT_CREATE_STORY`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Shortcut operations", known_fields: ""}]
session: {generate_id: true}
Create a feature story called "Add dark mode support" in workflow state 500000001 with estimate 5 and label "frontend"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Key parameters for `SHORTCUT_CREATE_STORY`:
- `name` (required) -- the story title
- `workflow_state_id` -- the workflow state to place the story in (recommended over `project_id`)
- `story_type` -- `"feature"`, `"bug"`, or `"chore"`
- `description` -- story body/description
- `estimate` -- numeric point estimate (or null for unestimated)
- `epic_id` -- associate with an epic
- `iteration_id` -- associate with an iteration
- `labels` -- array of label objects with `name` (and optional `color`, `description`)
- `owner_ids` -- array of member UUIDs to assign
- `deadline` -- due date in ISO 8601 format
- `tasks` -- inline task array with `description` and optional `complete`, `owner_ids`
- `comments` -- inline comment array with `text`
- `story_links` -- link stories with `verb` (`"blocks"`, `"duplicates"`, `"relates to"`)
## Core Workflow Pattern
**Important:** Either `workflow_state_id` or `project_id` must be provided, but not both. `workflow_state_id` is recommended as Projects are being sunset in Shortcut.
### Step 1: Discover Available Tools
### 2. Batch Create Stories
Create multiple stories in a single API call.
**Tool:** `SHORTCUT_CREATE_MULTIPLE_STORIES`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Shortcut task"}]
session: {id: "existing_session_id"}
Create 3 bug stories: "Login page 500 error", "Cart total rounding issue", and "Search results empty state broken"
```
### Step 2: Check Connection
- Requires `stories` array where each element follows the same schema as `SHORTCUT_CREATE_STORY`
- Each story in the array requires `name`
- Efficient for bulk imports, sprint planning, or template-based story creation
### 3. List Stories in a Project
Retrieve all stories within a specific project.
**Tool:** `SHORTCUT_LIST_STORIES`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["shortcut"]
session_id: "your_session_id"
List all stories in project 42 with their descriptions
```
### Step 3: Execute Tools
- Requires `project__public__id` (integer project ID)
- Optional `includes_description: true` to include story descriptions in the response
- Returns all stories with their attributes (status, type, estimate, etc.)
### 4. Manage Story Tasks
Create tasks (checklists) within stories for tracking sub-work.
**Tool:** `SHORTCUT_CREATE_TASK`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Add a task "Write unit tests for dark mode toggle" to story 12345
```
Key parameters:
- `story__public__id` (required) -- the parent story ID
- `description` (required) -- the task description
- `complete` -- boolean, defaults to false
- `owner_ids` -- array of member UUIDs to assign the task
- `external_id` -- ID from an external tool if imported
### 5. Add Story Comments
Post comments on stories for discussion and documentation.
**Tool:** `SHORTCUT_CREATE_STORY_COMMENT`
```
Add a comment to story 12345: "Reviewed the implementation -- looks good, but needs accessibility testing"
```
Key parameters:
- `story__public__id` (required) -- the story ID
- `text` (required) -- the comment body
- `author_id` -- member UUID (defaults to API token owner)
- `parent_id` -- ID of parent comment for threaded replies
### 6. Workflow and Project Discovery
List workflows and projects to resolve IDs for story creation.
**Tools:** `SHORTCUT_LIST_WORKFLOWS`, `SHORTCUT_LIST_PROJECTS`
```
Show me all workflows in our Shortcut workspace so I can find the right workflow state ID
```
- `SHORTCUT_LIST_WORKFLOWS` returns all workflows with their states (IDs, names, types)
- `SHORTCUT_LIST_PROJECTS` returns all projects with their attributes
- Use these to discover valid `workflow_state_id` and `project_id` values before creating stories
---
## 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
- **`workflow_state_id` vs `project_id`:** `SHORTCUT_CREATE_STORY` requires exactly one of these. Providing both or neither causes a rejection. Prefer `workflow_state_id` since Projects are being sunset.
- **Projects are being sunset:** Shortcut is deprecating Projects in favor of workflow-based organization. Use `workflow_state_id` for new stories.
- **Label creation is inline:** Labels in the `labels` array are created on-the-fly if they do not exist. The `name` field is required for each label object.
- **Story type defaults:** If `story_type` is omitted, it defaults to `"feature"`. Always set it explicitly for bugs and chores.
- **Batch limits:** `SHORTCUT_CREATE_MULTIPLE_STORIES` processes all stories in a single request. Very large batches may time out -- keep batches under 25 stories.
- **Integer IDs for stories/projects:** Story and project IDs are integers, not UUIDs. Member and group IDs are UUIDs. Mixing these formats causes errors.
- **`move_to` positioning:** The `move_to` field (`"first"` or `"last"`) moves the story within its workflow state, not across states.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Shortcut-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `shortcut` |
| 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` |
| Tool Slug | Description |
|---|---|
| `SHORTCUT_CREATE_STORY` | Create a single story (requires `name` + `workflow_state_id` or `project_id`) |
| `SHORTCUT_CREATE_MULTIPLE_STORIES` | Batch-create multiple stories (requires `stories` array) |
| `SHORTCUT_LIST_STORIES` | List stories in a project (requires `project__public__id`) |
| `SHORTCUT_CREATE_TASK` | Create a task in a story (requires `story__public__id`, `description`) |
| `SHORTCUT_CREATE_STORY_COMMENT` | Add a comment to a story (requires `story__public__id`, `text`) |
| `SHORTCUT_CREATE_STORY_FROM_TEMPLATE` | Create a story from a template |
| `SHORTCUT_LIST_WORKFLOWS` | List all workflows and their states |
| `SHORTCUT_LIST_PROJECTS` | List all projects |
---
*Powered by [Composio](https://composio.dev)*

142
snowflake-automation/SKILL.md
View File

@@ -1,91 +1,127 @@
---
name: snowflake-automation
description: "Automate Snowflake tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Snowflake Automation
description: "Automate Snowflake data warehouse operations -- list databases, schemas, and tables, execute SQL statements, and manage data workflows via the Composio MCP integration."
requires:
mcp: [rube]
mcp:
- rube
---
# Snowflake Automation via Rube MCP
# Snowflake Automation
Automate Snowflake operations through Composio's Snowflake toolkit via Rube MCP.
Automate your Snowflake data warehouse workflows -- discover databases, browse schemas and tables, execute arbitrary SQL (SELECT, DDL, DML), and integrate Snowflake data operations into cross-app pipelines.
**Toolkit docs**: [composio.dev/toolkits/snowflake](https://composio.dev/toolkits/snowflake)
**Toolkit docs:** [composio.dev/toolkits/snowflake](https://composio.dev/toolkits/snowflake)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Snowflake connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `snowflake`
- 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. Add the Composio MCP server to your client: `https://rube.app/mcp`
2. Connect your Snowflake account when prompted (account credentials or key-pair authentication)
3. Start using the workflows below
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `snowflake`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List Databases
Use `SNOWFLAKE_SHOW_DATABASES` to discover available databases with optional filtering and Time Travel support.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Snowflake operations", known_fields: ""}]
session: {generate_id: true}
Tool: SNOWFLAKE_SHOW_DATABASES
Inputs:
- like_pattern: string (SQL wildcard, e.g., "%test%") -- case-insensitive
- starts_with: string (e.g., "PROD") -- case-sensitive
- limit: integer (max 10000)
- history: boolean (include dropped databases within Time Travel retention)
- terse: boolean (return subset of columns: created_on, name, kind, database_name, schema_name)
- role: string (role to use for execution)
- warehouse: string (optional, not required for SHOW DATABASES)
- timeout: integer (seconds)
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
### 2. Browse Schemas
## Core Workflow Pattern
### Step 1: Discover Available Tools
Use `SNOWFLAKE_SHOW_SCHEMAS` to list schemas within a database or across the account.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Snowflake task"}]
session: {id: "existing_session_id"}
Tool: SNOWFLAKE_SHOW_SCHEMAS
Inputs:
- database: string (database context)
- in_scope: "ACCOUNT" | "DATABASE" | "<specific_database_name>"
- like_pattern: string (SQL wildcard filter)
- starts_with: string (case-sensitive prefix)
- limit: integer (max 10000)
- history: boolean (include dropped schemas)
- terse: boolean (subset columns only)
- role, warehouse, timeout: string/integer (optional)
```
### Step 2: Check Connection
### 3. List Tables
Use `SNOWFLAKE_SHOW_TABLES` to discover tables with metadata including row counts, sizes, and clustering keys.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["snowflake"]
session_id: "your_session_id"
Tool: SNOWFLAKE_SHOW_TABLES
Inputs:
- database: string (database context)
- schema: string (schema context)
- in_scope: "ACCOUNT" | "DATABASE" | "SCHEMA" | "<specific_name>"
- like_pattern: string (e.g., "%customer%")
- starts_with: string (e.g., "FACT", "DIM", "TEMP")
- limit: integer (max 10000)
- history: boolean (include dropped tables)
- terse: boolean (subset columns only)
- role, warehouse, timeout: string/integer (optional)
```
### Step 3: Execute Tools
### 4. Execute SQL Statements
Use `SNOWFLAKE_EXECUTE_SQL` for SELECT queries, DDL (CREATE/ALTER/DROP), and DML (INSERT/UPDATE/DELETE) with parameterized bindings.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: SNOWFLAKE_EXECUTE_SQL
Inputs:
- statement: string (required) -- SQL statement(s), semicolon-separated for multi-statement
- database: string (case-sensitive, falls back to DEFAULT_NAMESPACE)
- schema_name: string (case-sensitive)
- warehouse: string (case-sensitive, required for compute-bound queries)
- role: string (case-sensitive, falls back to DEFAULT_ROLE)
- bindings: object (parameterized query values to prevent SQL injection)
- parameters: object (Snowflake session-level parameters)
- timeout: integer (seconds; 0 = max 604800s)
```
**Examples:**
- `"SELECT * FROM my_table LIMIT 100;"`
- `"CREATE TABLE test (id INT, name STRING);"`
- `"ALTER SESSION SET QUERY_TAG='mytag'; SELECT COUNT(*) FROM my_table;"`
---
## 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
| Pitfall | Detail |
|---------|--------|
| Case sensitivity | Database, schema, warehouse, and role names are case-sensitive in `SNOWFLAKE_EXECUTE_SQL`. |
| Warehouse required for compute | SELECT and DML queries require a running warehouse. SHOW commands do not. |
| Multi-statement execution | Multiple statements separated by semicolons execute in sequence automatically. |
| SQL injection prevention | Always use the `bindings` parameter for user-supplied values to prevent injection attacks. |
| Pagination with LIMIT | `SHOW` commands support `limit` (max 10000) and `from_name` for cursor-based pagination. |
| Time Travel | Set `history: true` to include dropped objects still within the retention period. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Snowflake-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `snowflake` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `SNOWFLAKE_SHOW_DATABASES` | List databases with filtering and Time Travel support |
| `SNOWFLAKE_SHOW_SCHEMAS` | List schemas within a database or account-wide |
| `SNOWFLAKE_SHOW_TABLES` | List tables with metadata (row count, size, clustering) |
| `SNOWFLAKE_EXECUTE_SQL` | Execute SQL: SELECT, DDL, DML with parameterized bindings |
---
*Powered by [Composio](https://composio.dev)*

211
spotify-automation/SKILL.md
View File

@@ -1,91 +1,186 @@
---
name: spotify-automation
description: "Automate Spotify tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Spotify Automation
description: "Automate Spotify workflows including playlist management, music search, playback control, and user profile access via Composio"
requires:
mcp: [rube]
mcp:
- rube
---
# Spotify Automation via Rube MCP
# Spotify Automation
Automate Spotify operations through Composio's Spotify toolkit via Rube MCP.
Automate Spotify operations -- manage playlists, search the music catalog, control playback, browse albums and tracks, and access user profiles -- all orchestrated through the Composio MCP integration.
**Toolkit docs**: [composio.dev/toolkits/spotify](https://composio.dev/toolkits/spotify)
**Toolkit docs:** [composio.dev/toolkits/spotify](https://composio.dev/toolkits/spotify)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Spotify connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `spotify`
- 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. Connect your Spotify account through the Composio MCP server at `https://rube.app/mcp`
2. The agent will prompt you with an authentication link if no active connection exists
3. Once connected, all `SPOTIFY_*` tools become available for execution
4. **Note:** Some features (playback control) require a Spotify Premium subscription
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `spotify`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Get Current User Profile
Retrieve comprehensive profile information for the authenticated Spotify user.
**Tool:** `SPOTIFY_GET_CURRENT_USER_S_PROFILE`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Spotify operations", known_fields: ""}]
session: {generate_id: true}
No parameters required.
Returns: display name, email, country, subscription level (premium/free),
explicit content settings, profile images, follower count, and Spotify URIs.
Required scopes: user-read-private, user-read-email.
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
---
## Core Workflow Pattern
### 2. Search the Spotify Catalog
Find albums, artists, playlists, tracks, shows, episodes, or audiobooks by keyword.
### Step 1: Discover Available Tools
**Tool:** `SPOTIFY_SEARCH_FOR_ITEM`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Spotify task"}]
session: {id: "existing_session_id"}
```
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `q` | string | Yes | Search query keywords |
| `type` | array | Yes | Item types: `album`, `artist`, `playlist`, `track`, `show`, `episode`, `audiobook` |
| `limit` | integer | No | Results to return (default: 20) |
| `offset` | integer | No | Offset for pagination (default: 0) |
| `market` | string | No | ISO 3166-1 alpha-2 country code |
| `include_external` | string | No | Set to `audio` to include external content |
### Step 2: Check Connection
**Note:** Audiobooks are only available in US, UK, Canada, Ireland, New Zealand, and Australia.
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["spotify"]
session_id: "your_session_id"
```
---
### Step 3: Execute Tools
### 3. Manage Playlists
Browse, create, modify, and populate playlists.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Get a user's playlists:**
**Tool:** `SPOTIFY_GET_USER_S_PLAYLISTS`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `user_id` | string | Yes | Spotify user ID |
| `limit` | integer | No | Max playlists, 1-50 (default: 20) |
| `offset` | integer | No | Pagination offset, 0-100000 (default: 0) |
**Get current user's playlists:**
**Tool:** `SPOTIFY_GET_CURRENT_USER_S_PLAYLISTS`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `limit` | integer | No | Max playlists, 1-50 (default: 20) |
| `offset` | integer | No | Pagination offset, 0-100000 (default: 0) |
**Get playlist details:**
**Tool:** `SPOTIFY_GET_PLAYLIST`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `playlist_id` | string | Yes | Spotify playlist ID (e.g., `3cEYpjA9oz9GiPac4AsH4n`) |
| `fields` | string | No | Comma-separated field filter to reduce response size |
| `market` | string | No | ISO country code for market-specific content |
| `additional_types` | string | No | `track,episode` to include podcast episodes |
**Update playlist details:**
**Tool:** `SPOTIFY_CHANGE_PLAYLIST_DETAILS`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `playlist_id` | string | Yes | Playlist ID (must be owned by current user) |
| `name` | string | No | New playlist name |
| `description` | string | No | New playlist description |
| `public` | boolean | No | Public/private toggle |
| `collaborative` | boolean | No | Collaborative mode (only on non-public playlists) |
---
### 4. Browse Playlist Items & Add Tracks
View tracks in a playlist and add new items.
**Tool:** `SPOTIFY_GET_PLAYLIST_ITEMS`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `playlist_id` | string | Yes | Spotify playlist ID |
| `limit` | integer | No | Items per page, 1-50 (default: 20) |
| `offset` | integer | No | Pagination offset (default: 0) |
| `fields` | string | No | Field filter (e.g., `items(track(name,id))`) |
| `market` | string | No | ISO country code |
| `additional_types` | string | No | `track,episode` for podcast episodes |
**Tool:** `SPOTIFY_ADD_ITEMS_TO_PLAYLIST`
Add tracks or episodes to a playlist using Spotify URIs.
---
### 5. Get Track & Album Details
Retrieve catalog information for individual tracks and albums.
**Tool:** `SPOTIFY_GET_TRACK` -- Get details for a single track by Spotify ID.
**Tool:** `SPOTIFY_GET_ALBUM` -- Get comprehensive album data including track listing, artist info, cover art, and popularity.
---
### 6. Control Playback
Start, resume, or change playback on the user's active device.
**Tool:** `SPOTIFY_START_RESUME_PLAYBACK`
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `context_uri` | string | No | Spotify URI of album, artist, or playlist (cannot combine with `uris`) |
| `uris` | array | No | List of track URIs to play (cannot combine with `context_uri`) |
| `offset` | object | No | Starting position: `{position: 5}` or `{uri: 'spotify:track:...'}` |
| `position_ms` | integer | No | Start position in milliseconds |
| `device_id` | string | No | Target device ID (defaults to active device) |
**Requirements:** Spotify Premium subscription and at least one active device.
---
## 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
| Pitfall | Details |
|---------|---------|
| **Premium required for playback** | `SPOTIFY_START_RESUME_PLAYBACK` returns 403 if the user does not have Spotify Premium |
| **Active device required** | Playback control returns 404 if no Spotify device (mobile, desktop, web, speaker) is active |
| **context_uri vs uris are exclusive** | Cannot use both `context_uri` and `uris` in the same playback call |
| **Collaborative playlists** | `collaborative` can only be set to `true` on non-public playlists (`public` must be `false`) |
| **Playlist ownership** | `SPOTIFY_CHANGE_PLAYLIST_DETAILS` only works on playlists owned by the authenticated user |
| **Audiobook market restrictions** | Audiobooks via search are only available in US, UK, Canada, Ireland, New Zealand, and Australia |
| **Max 11000 playlists** | Users are limited to approximately 11,000 playlists via `SPOTIFY_CREATE_PLAYLIST` |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Spotify-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `spotify` |
| 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` |
| Tool Slug | Purpose |
|-----------|---------|
| `SPOTIFY_GET_CURRENT_USER_S_PROFILE` | Get authenticated user's profile |
| `SPOTIFY_SEARCH_FOR_ITEM` | Search catalog for tracks, albums, artists, etc. |
| `SPOTIFY_GET_USER_S_PLAYLISTS` | Get playlists for any user |
| `SPOTIFY_GET_CURRENT_USER_S_PLAYLISTS` | Get current user's playlists |
| `SPOTIFY_GET_PLAYLIST` | Get detailed playlist info |
| `SPOTIFY_GET_PLAYLIST_ITEMS` | List tracks/episodes in a playlist |
| `SPOTIFY_CHANGE_PLAYLIST_DETAILS` | Update playlist name, description, visibility |
| `SPOTIFY_CREATE_PLAYLIST` | Create a new playlist |
| `SPOTIFY_ADD_ITEMS_TO_PLAYLIST` | Add tracks/episodes to a playlist |
| `SPOTIFY_GET_TRACK` | Get track details by ID |
| `SPOTIFY_GET_ALBUM` | Get album details by ID |
| `SPOTIFY_START_RESUME_PLAYBACK` | Start or resume playback on a device |
---
*Powered by [Composio](https://composio.dev)*

195
survey-monkey-automation/SKILL.md
View File

@@ -1,91 +1,166 @@
---
name: survey-monkey-automation
description: "Automate SurveyMonkey tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: SurveyMonkey Automation
description: "Automate SurveyMonkey survey creation, response collection, collector management, and survey discovery through natural language commands"
requires:
mcp: [rube]
mcp:
- rube
---
# SurveyMonkey Automation via Rube MCP
# SurveyMonkey Automation
Automate SurveyMonkey operations through Composio's SurveyMonkey toolkit via Rube MCP.
Automate SurveyMonkey survey workflows -- create surveys, list and search existing surveys, manage collectors and distribution links, retrieve responses, and inspect survey details -- all through natural language.
**Toolkit docs**: [composio.dev/toolkits/survey_monkey](https://composio.dev/toolkits/survey_monkey)
**Toolkit docs:** [composio.dev/toolkits/survey_monkey](https://composio.dev/toolkits/survey_monkey)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active SurveyMonkey connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `survey_monkey`
- 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. Add the Rube MCP server to your environment: `https://rube.app/mcp`
2. Connect your SurveyMonkey account when prompted (OAuth flow via Composio)
3. Start issuing natural language commands for SurveyMonkey automation
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `survey_monkey`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Create a New Survey
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "SurveyMonkey operations", known_fields: ""}]
session: {generate_id: true}
```
Create a new empty survey that can be further configured with questions and pages.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `SURVEY_MONKEY_CREATE_SURVEY`
## Core Workflow Pattern
Key parameters:
- `title` -- survey title displayed to respondents (required)
- `nickname` -- optional internal name for organizing surveys (not shown to respondents)
- `language` -- ISO 639-1 language code (default `en`); examples: `es`, `fr`, `de`
- `footer` -- whether to display SurveyMonkey branding footer (default `true`)
### Step 1: Discover Available Tools
> The created survey starts with one empty page and no questions. Use the returned `survey_id` with other actions to add content and configure collectors.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific SurveyMonkey task"}]
session: {id: "existing_session_id"}
```
Example prompt:
> "Create a new survey titled 'Customer Satisfaction Q1 2026'"
### Step 2: Check Connection
---
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["survey_monkey"]
session_id: "your_session_id"
```
### 2. List and Search Surveys
### Step 3: Execute Tools
Enumerate all surveys in your account with filtering, sorting, and pagination.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Tool:** `SURVEY_MONKEY_GET_SURVEYS`
Key parameters:
- `title` -- search by survey title (partial match)
- `sort_by` -- sort by `title`, `date_modified`, or `num_responses`
- `sort_order` -- `ASC` or `DESC`
- `page` / `per_page` -- pagination controls (default 50 per page, max 100)
- `include` -- additional fields: `response_count`, `date_modified`, `date_created`, `question_count`, `page_count`, `category`, `language`, `folder_id`
- `folder_id` -- filter to surveys in a specific folder
- `start_modified_at` / `end_modified_at` -- date range filter (format: `YYYY-MM-DDTHH:MM:SS`)
Example prompt:
> "List all my surveys sorted by most recent modification, include response counts"
---
### 3. Get Survey Details
Retrieve comprehensive metadata for a specific survey including configuration, question/page counts, response counts, and all relevant URLs.
**Tool:** `SURVEY_MONKEY_GET_SURVEY_DETAILS`
Key parameters:
- `survey_id` -- the unique survey identifier (required)
Returns: title, language, question_count, page_count, response_count, URLs for preview/edit/analyze/collect, button text, and timestamps.
Example prompt:
> "Show me the full details and response count for survey 123456789"
---
### 4. Manage Collectors and Distribution Links
Retrieve collectors (distribution channels) for a survey to get shareable links and monitor response progress.
**Tool:** `SURVEY_MONKEY_GET_COLLECTORS`
Key parameters:
- `survey_id` -- the survey to get collectors for (required)
- `include` -- additional fields: `type`, `status`, `response_count`, `date_created`, `date_modified`, `url`
- `name` -- partial match filter on collector name
- `sort_by` -- sort by `id`, `date_modified`, `type`, `status`, or `name`
- `sort_order` -- `ASC` or `DESC`
- `page` / `per_page` -- pagination (default 50, max 1000)
- `start_date` / `end_date` -- filter by creation date (format: `YYYY-MM-DDTHH:MM:SS`)
Example prompt:
> "Get all collectors for survey 123456789, include URLs and response counts"
---
### 5. Retrieve Survey Responses
Fetch response data for a specific survey with comprehensive filtering options.
**Tool:** `SURVEY_MONKEY_GET_RESPONSES`
Key parameters:
- `survey_id` -- the survey to retrieve responses from (required)
- `status` -- filter by `completed`, `partial`, `overquota`, or `disqualified`
- `page` / `per_page` -- pagination (default 50, max 1000)
- `sort_order` -- `ASC` or `DESC` (sorted by `date_modified`)
- `start_created_at` / `end_created_at` -- filter by creation date range (ISO 8601)
- `start_modified_at` / `end_modified_at` -- filter by modification date range
- `email` -- filter by respondent email
- `first_name` / `last_name` -- filter by respondent name
- `ip` -- filter by IP address
- `total_time_min` / `total_time_max` / `total_time_units` -- filter by completion time
Example prompt:
> "Get all completed responses for survey 123456789 from the last 30 days"
---
### 6. Full Survey Lifecycle Workflow
Combine tools for end-to-end survey management:
1. **Create**: `SURVEY_MONKEY_CREATE_SURVEY` -- create the survey, store the `survey_id`
2. **Distribute**: `SURVEY_MONKEY_GET_COLLECTORS` -- retrieve the collector link to share with respondents
3. **Monitor**: `SURVEY_MONKEY_GET_SURVEY_DETAILS` -- check response counts and survey status
4. **Collect**: `SURVEY_MONKEY_GET_RESPONSES` -- retrieve completed responses, filter by `status=completed`
5. **Audit**: `SURVEY_MONKEY_GET_SURVEYS` -- browse and find surveys if `survey_id` is lost
Example prompt:
> "Create a survey called 'Event Feedback', then show me how to distribute it"
---
## 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
| Pitfall | Details |
|---------|---------|
| Pagination required | `SURVEY_MONKEY_GET_COLLECTORS` and `SURVEY_MONKEY_GET_RESPONSES` require managing `page`/`per_page` for large surveys to avoid missing data |
| Status filtering critical | `SURVEY_MONKEY_GET_RESPONSES` returns partial, overquota, and disqualified entries unless filtered -- use `status=completed` for reliable data |
| No shareable link on create | `SURVEY_MONKEY_CREATE_SURVEY` does not create a distribution link -- use `SURVEY_MONKEY_GET_COLLECTORS` to get shareable URLs |
| Survey ID storage | Losing track of `survey_id` forces reliance on `SURVEY_MONKEY_GET_SURVEYS` which is slower -- store IDs immediately after creation |
| Question ID mapping | Question IDs and answer formats from responses must be carefully mapped; use `SURVEY_MONKEY_GET_SURVEY_DETAILS` to understand the structure |
| Date format | Date filters use `YYYY-MM-DDTHH:MM:SS` format, not ISO 8601 with timezone |
| Empty survey on create | New surveys start with one empty page and no questions -- further configuration is needed |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with SurveyMonkey-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `survey_monkey` |
| 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` |
| Action | Tool Slug | Key Params |
|--------|-----------|------------|
| Create survey | `SURVEY_MONKEY_CREATE_SURVEY` | `title`, `language`, `nickname` |
| List surveys | `SURVEY_MONKEY_GET_SURVEYS` | `title`, `sort_by`, `include`, `page` |
| Get survey details | `SURVEY_MONKEY_GET_SURVEY_DETAILS` | `survey_id` |
| List collectors | `SURVEY_MONKEY_GET_COLLECTORS` | `survey_id`, `include`, `sort_by` |
| Get responses | `SURVEY_MONKEY_GET_RESPONSES` | `survey_id`, `status`, `start_created_at` |
---
*Powered by [Composio](https://composio.dev)*

170
toggl-automation/SKILL.md
View File

@@ -1,91 +1,157 @@
---
name: toggl-automation
description: "Automate Toggl tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Toggl Automation
description: "Automate time tracking workflows in Toggl Track -- create time entries, manage projects, clients, tags, and workspaces through natural language commands."
requires:
mcp: [rube]
mcp:
- rube
---
# Toggl Automation via Rube MCP
# Toggl Automation
Automate Toggl operations through Composio's Toggl toolkit via Rube MCP.
Automate your Toggl Track time tracking operations directly from Claude Code. Log time, manage projects and clients, organize with tags, and control workspaces -- all without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/toggl](https://composio.dev/toolkits/toggl)
**Toolkit docs:** [composio.dev/toolkits/toggl](https://composio.dev/toolkits/toggl)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Toggl connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `toggl`
- 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. Add the Rube MCP server to your Claude Code config with URL: `https://rube.app/mcp`
2. When prompted, authenticate your Toggl Track account through the connection link provided
3. Start automating your time tracking workflows with natural language
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `toggl`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Create and Stop Time Entries
Log time with project, task, and tag associations, or start/stop timers.
**Tools:** `TOGGL_CREATE_TIME_ENTRY`, `TOGGL_PATCH_STOP_TIME_ENTRY`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Toggl operations", known_fields: ""}]
session: {generate_id: true}
Start a time entry in workspace 123456 for project 78910 tagged "meeting" and "design" with description "Design review session"
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Key parameters for `TOGGL_CREATE_TIME_ENTRY`:
- `workspace_id` (required) -- target workspace
- `created_with` (required) -- client application name (e.g., `"api_client"`)
- `start` (required) -- ISO 8601 timestamp
- `stop` -- ISO 8601 end time; omit to leave the entry running
- `duration` -- duration in seconds; omit for running entries
- `project_id` -- associate with a project
- `task_id` -- associate with a task
- `tags` -- array of tag name strings (not IDs)
- `description` -- description of the work
- `billable` -- billable status
## Core Workflow Pattern
Key parameters for `TOGGL_PATCH_STOP_TIME_ENTRY`:
- `workspace_id` (required) and `time_entry_id` (required)
### Step 1: Discover Available Tools
### 2. Manage Projects
Create new projects and list existing ones with client details and pagination.
**Tools:** `TOGGL_CREATE_PROJECT`, `TOGGL_GET_PROJECTS`, `TOGGL_GET_PROJECT_DETAILS`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Toggl task"}]
session: {id: "existing_session_id"}
Create a private billable project called "Q1 Marketing Campaign" in workspace 123456 for client 78910
```
### Step 2: Check Connection
Key parameters for `TOGGL_CREATE_PROJECT`:
- `workspace_id` (required) and `name` (required)
- `client_id`, `billable`, `is_private`, `active`, `color`
- `estimated_hours`, `rate`, `fixed_fee`, `currency` (premium features)
Key parameters for `TOGGL_GET_PROJECTS`:
- `workspace_id` (required)
- `page` / `page_size` (1-200) for pagination
- `since` / `until` -- Unix timestamps for modification filtering (last 3 months only)
- `clients: true` to include full client details
### 3. Manage Clients
Create and list clients within a workspace.
**Tools:** `TOGGL_CREATE_CLIENT`, `TOGGL_GET_LIST_CLIENTS`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["toggl"]
session_id: "your_session_id"
List all active clients in workspace 123456, then create a new client called "Acme Corp"
```
### Step 3: Execute Tools
- `TOGGL_CREATE_CLIENT` requires `workspace_id` and `name`; accepts `notes`, `external_reference`
- `TOGGL_GET_LIST_CLIENTS` requires `workspace_id`; supports `status` (`"active"`, `"archived"`, `"both"`) and `name` (case-insensitive search)
### 4. Tags and Workspace Preferences
Retrieve tags for categorization and check workspace settings.
**Tools:** `TOGGL_GET_TAGS`, `TOGGL_GET_WORKSPACE_PREFERENCES`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Show me all tags in workspace 123456 and the workspace preferences
```
- `TOGGL_GET_TAGS` requires `workspace_id`; returns tag IDs and names
- `TOGGL_GET_WORKSPACE_PREFERENCES` requires `workspace_id`; returns pricing plan and display settings
### 5. Workspace Discovery
List all workspaces the authenticated user belongs to.
**Tool:** `TOGGL_GET_USER_WORKSPACES`
```
What Toggl workspaces do I have access to?
```
- No parameters required
- Returns all workspaces with IDs, names, and metadata
- Use this first to discover workspace IDs for other operations
### 6. User Project Visibility
List projects visible to the authenticated user.
**Tool:** `TOGGL_GET_USER_PROJECTS`
```
Show me all projects I can see across my workspaces
```
- Returns projects the authenticated user has access to
- Use alongside `TOGGL_GET_PROJECTS` for workspace-scoped views
---
## 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
- **Tags use names, not IDs:** `TOGGL_CREATE_TIME_ENTRY` accepts tag names as strings in the `tags` array, unlike many APIs that use IDs. Use `TOGGL_GET_TAGS` to verify available tag names.
- **`created_with` is required:** Every time entry must include `created_with` (e.g., `"api_client"`). Missing this field causes silent failures.
- **Duration is in seconds:** The `duration` parameter on time entries is in seconds, not hours. 1 hour = 3600 seconds.
- **`since` timestamp restriction:** The `since` filter on `TOGGL_GET_PROJECTS` only allows timestamps within the last 3 months. Older queries will be rejected.
- **Premium features gated:** Custom colors, templates, fixed fees, and hourly rates on projects require a premium Toggl plan. Non-premium accounts will get errors when using these fields.
- **Workspace ID required everywhere:** Nearly all Toggl tools require `workspace_id`. Always call `TOGGL_GET_USER_WORKSPACES` first to resolve it.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Toggl-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `toggl` |
| 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` |
| Tool Slug | Description |
|---|---|
| `TOGGL_CREATE_TIME_ENTRY` | Create a time entry or running timer (requires `workspace_id`, `created_with`, `start`) |
| `TOGGL_PATCH_STOP_TIME_ENTRY` | Stop a running time entry (requires `workspace_id`, `time_entry_id`) |
| `TOGGL_GET_PROJECTS` | List projects in a workspace with pagination |
| `TOGGL_GET_PROJECT_DETAILS` | Get details for a specific project |
| `TOGGL_CREATE_PROJECT` | Create a new project (requires `workspace_id`, `name`) |
| `TOGGL_GET_LIST_CLIENTS` | List clients with status/name filters (requires `workspace_id`) |
| `TOGGL_CREATE_CLIENT` | Create a new client (requires `workspace_id`, `name`) |
| `TOGGL_GET_TAGS` | List all tags in a workspace (requires `workspace_id`) |
| `TOGGL_GET_WORKSPACE_PREFERENCES` | Get workspace settings (requires `workspace_id`) |
| `TOGGL_GET_USER_WORKSPACES` | List all workspaces for the authenticated user |
| `TOGGL_GET_USER_PROJECTS` | List projects visible to the authenticated user |
---
*Powered by [Composio](https://composio.dev)*

182
uploadcare-automation/SKILL.md
View File

@@ -1,91 +1,153 @@
---
name: uploadcare-automation
description: "Automate Uploadcare tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Uploadcare Automation
description: "Automate Uploadcare file management including listing, storing, inspecting, downloading, and organizing file groups through natural language commands"
requires:
mcp: [rube]
mcp:
- rube
---
# Uploadcare Automation via Rube MCP
# Uploadcare Automation
Automate Uploadcare operations through Composio's Uploadcare toolkit via Rube MCP.
Automate Uploadcare file handling workflows -- list project files, permanently store uploads, retrieve file metadata, get download URLs, and manage file groups -- all through natural language.
**Toolkit docs**: [composio.dev/toolkits/uploadcare](https://composio.dev/toolkits/uploadcare)
**Toolkit docs:** [composio.dev/toolkits/uploadcare](https://composio.dev/toolkits/uploadcare)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Uploadcare connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `uploadcare`
- 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. Add the Rube MCP server to your environment: `https://rube.app/mcp`
2. Connect your Uploadcare account when prompted (API key auth via Composio)
3. Start issuing natural language commands for Uploadcare automation
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `uploadcare`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. List Project Files
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Uploadcare operations", known_fields: ""}]
session: {generate_id: true}
```
Browse uploaded files in your Uploadcare project with filtering, sorting, and pagination.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `UPLOADCARE_LIST_FILES`
## Core Workflow Pattern
Key parameters:
- `stored` -- filter by storage status: `"true"` for stored, `"false"` for unstored
- `removed` -- filter by removal status: `"true"` for removed, `"false"` for active
- `ordering` -- sort by `datetime_uploaded` (ascending) or `-datetime_uploaded` (descending)
- `limit` -- files per page, 1-1000 (default 100)
- `offset` -- zero-based pagination offset
- `from_date` -- ISO 8601 timestamp to filter files uploaded after this date
- `to_date` -- ISO 8601 timestamp to filter files uploaded before this date
- `include` -- set to `"total"` to include total file count in response
### Step 1: Discover Available Tools
Example prompt:
> "List the 50 most recently uploaded stored files in my Uploadcare project"
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Uploadcare task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. Store a File Permanently
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["uploadcare"]
session_id: "your_session_id"
```
Mark an uploaded file as permanently stored. By default, Uploadcare files are temporary and will be deleted after 24 hours unless stored.
### Step 3: Execute Tools
**Tool:** `UPLOADCARE_STORE_FILE`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
Key parameters:
- `uuid` -- UUID of the file to store (required); must be in `8-4-4-4-12` hex format (e.g., `3e55317b-23d1-4f35-9b4c-b9accb7b53f4`)
> Always store files after upload to prevent automatic deletion.
Example prompt:
> "Permanently store the file with UUID 3e55317b-23d1-4f35-9b4c-b9accb7b53f4"
---
### 3. Get File Metadata
Retrieve detailed information about a specific file including size, MIME type, CDN URL, image dimensions, and more.
**Tool:** `UPLOADCARE_GET_FILE_INFO`
Key parameters:
- `uuid` -- the UUID of the file to inspect (required); format: `8-4-4-4-12` hex
Returns: filename, size, MIME type, CDN URL, upload date, storage status, image info (dimensions, color mode), and more.
Example prompt:
> "Get the metadata and dimensions for file 3e0923f2-e05a-4b37-9f0d-343b981c9d70"
---
### 4. Get a Temporary Download URL
Retrieve a temporary direct download link for a specific file.
**Tool:** `UPLOADCARE_GET_FILE_DOWNLOAD_URL`
Key parameters:
- `file_id` -- the unique file identifier (required)
Returns a time-limited URL that can be used for direct file download.
Example prompt:
> "Get a download link for file 3e0923f2-e05a-4b37-9f0d-343b981c9d70"
---
### 5. Browse File Groups
List file groups in your project. Groups are collections of files uploaded together.
**Tool:** `UPLOADCARE_LIST_GROUPS`
Key parameters:
- `limit` -- groups per page, 1-1000 (default 20)
- `offset` -- zero-based pagination offset (default 0)
- `ordering` -- sort by `datetime_created` (ascending) or `-datetime_created` (descending)
Example prompt:
> "List my 10 most recent file groups"
---
### 6. File Lifecycle Workflow
Combine tools for end-to-end file management:
1. **Upload**: Files are uploaded via Uploadcare's upload API or widget (outside this toolkit)
2. **Store**: `UPLOADCARE_STORE_FILE` -- mark files as permanent to prevent auto-deletion
3. **Inspect**: `UPLOADCARE_GET_FILE_INFO` -- verify metadata, check dimensions and MIME type
4. **Share**: `UPLOADCARE_GET_FILE_DOWNLOAD_URL` -- generate a temporary download link
5. **Browse**: `UPLOADCARE_LIST_FILES` -- audit all files with status and date filters
6. **Groups**: `UPLOADCARE_LIST_GROUPS` -- review batch uploads
Example prompt:
> "Store file abc-123, then get its metadata and a download link"
---
## 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
| Pitfall | Details |
|---------|---------|
| Auto-deletion of unstored files | Uploaded files are temporary by default and deleted after 24 hours -- always call `UPLOADCARE_STORE_FILE` to persist them |
| UUID format strict | File UUIDs must be in exact `8-4-4-4-12` hex format (e.g., `3e55317b-23d1-4f35-9b4c-b9accb7b53f4`); invalid formats will be rejected |
| Filter values are strings | The `stored` and `removed` parameters accept string values `"true"` or `"false"`, not booleans |
| Temporary download URLs | URLs from `UPLOADCARE_GET_FILE_DOWNLOAD_URL` are time-limited and will expire |
| Pagination is offset-based | Use `offset` + `limit` for pagination; there are no cursor-based pagination tokens |
| No upload tool | File uploads happen through Uploadcare's upload API or widget, not through this toolkit -- these tools manage already-uploaded files |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Uploadcare-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `uploadcare` |
| 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` |
| Action | Tool Slug | Key Params |
|--------|-----------|------------|
| List files | `UPLOADCARE_LIST_FILES` | `stored`, `ordering`, `limit`, `offset` |
| Store file | `UPLOADCARE_STORE_FILE` | `uuid` |
| Get file info | `UPLOADCARE_GET_FILE_INFO` | `uuid` |
| Get download URL | `UPLOADCARE_GET_FILE_DOWNLOAD_URL` | `file_id` |
| List groups | `UPLOADCARE_LIST_GROUPS` | `limit`, `offset`, `ordering` |
---
*Powered by [Composio](https://composio.dev)*

103
wave-accounting-automation/SKILL.md
View File

@@ -1,91 +1,40 @@
---
name: wave-accounting-automation
description: "Automate Wave Accounting tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Wave Accounting Automation
description: "Wave Accounting toolkit is not currently available as a native integration. No Wave-specific tools were found in the Composio platform. This skill is a placeholder pending future integration."
category: accounting
requires:
mcp: [rube]
mcp:
- rube
---
# Wave Accounting Automation via Rube MCP
# Wave Accounting Automation
Automate Wave Accounting operations through Composio's Wave Accounting toolkit via Rube MCP.
> **Note:** The Wave Accounting toolkit (`wave_accounting`) does not currently have native tools available in the Composio platform. Searches for Wave Accounting-specific tools return results from other accounting/invoicing platforms (Stripe, Zoho Invoice) instead.
**Toolkit docs**: [composio.dev/toolkits/wave_accounting](https://composio.dev/toolkits/wave_accounting)
**Toolkit docs:** [composio.dev/toolkits/wave_accounting](https://composio.dev/toolkits/wave_accounting)
## Prerequisites
---
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Wave Accounting connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `wave_accounting`
- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
## Status
This integration is **not yet available** with native Wave Accounting tools. When Wave Accounting tools become available in Composio, this skill file will be updated with real tool slugs, workflows, and pitfalls.
For accounting and invoicing automation needs, consider these alternatives that are available today:
- **Stripe** -- Payment processing, invoicing, and subscription management
- **Zoho Invoice** -- Invoice creation, payment tracking, and contact management
- **QuickBooks** -- Full accounting suite with invoicing and expense tracking
- **FreshBooks** -- Cloud accounting with time tracking and invoicing
---
## 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 `wave_accounting`
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: "Wave Accounting 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 Wave Accounting task"}]
session: {id: "existing_session_id"}
```
### Step 2: Check Connection
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["wave_accounting"]
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 Wave Accounting-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `wave_accounting` |
| 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` |
1. Add the Composio MCP server to your client configuration:
```
https://rube.app/mcp
```
2. Check back for Wave Accounting integration availability.
---
*Powered by [Composio](https://composio.dev)*

205
webex-automation/SKILL.md
View File

@@ -1,91 +1,176 @@
---
name: webex-automation
description: "Automate Webex tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Webex Automation
description: "Automate Cisco Webex messaging, rooms, teams, webhooks, and people management through natural language commands"
requires:
mcp: [rube]
mcp:
- rube
---
# Webex Automation via Rube MCP
# Webex Automation
Automate Webex operations through Composio's Webex toolkit via Rube MCP.
Automate Cisco Webex collaboration workflows -- send messages, manage rooms and teams, configure webhooks, and look up people -- all through natural language.
**Toolkit docs**: [composio.dev/toolkits/webex](https://composio.dev/toolkits/webex)
**Toolkit docs:** [composio.dev/toolkits/webex](https://composio.dev/toolkits/webex)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Webex connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `webex`
- 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. Add the Rube MCP server to your environment: `https://rube.app/mcp`
2. Connect your Webex account when prompted (OAuth flow via Composio)
3. Start issuing natural language commands for Webex automation
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `webex`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Send a Message to a Room or Person
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Webex operations", known_fields: ""}]
session: {generate_id: true}
```
Post plain text, markdown, file attachments, or Adaptive Cards to any Webex room or directly to a person.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `WEBEX_MESSAGING_CREATE_MESSAGE`
## Core Workflow Pattern
Key parameters:
- `roomId` -- target room ID (use `WEBEX_MESSAGING_LIST_ROOMS` to find it)
- `toPersonEmail` -- send a private 1:1 message instead (mutually exclusive with `roomId`)
- `text` -- plain text content (max 7439 bytes)
- `markdown` -- markdown-formatted content (takes precedence over `text`)
- `files` -- list of public URLs for file attachments (one file per message)
- `attachments` -- Adaptive Card JSON (one card per message)
- `parentId` -- reply to a specific message as a threaded response
### Step 1: Discover Available Tools
Example prompt:
> "Send a markdown message to room Y2lz... saying **Deploy completed** with a link to the release notes"
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Webex task"}]
session: {id: "existing_session_id"}
```
---
### Step 2: Check Connection
### 2. List and Discover Rooms
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["webex"]
session_id: "your_session_id"
```
Browse all rooms you belong to, filtered by type, team, or sorted by activity.
### Step 3: Execute Tools
**Tool:** `WEBEX_MESSAGING_LIST_ROOMS`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
Key parameters:
- `type` -- filter by `direct` (1:1) or `group`
- `teamId` -- limit to rooms in a specific team
- `sortBy` -- sort by `id`, `lastactivity`, or `created`
- `max` -- limit results (1-1000, default 100)
Follow-up with `WEBEX_MESSAGING_GET_ROOM_DETAILS` to get full metadata for a specific room including title, type, lock status, creator, and timestamps.
Example prompt:
> "List my 10 most recently active group rooms in Webex"
---
### 3. Manage Webhooks for Event-Driven Automation
Create webhooks to receive real-time HTTP POST notifications when Webex resources change.
**Tool:** `WEBEX_WEBHOOKS_CREATE_WEBHOOK`
Key parameters:
- `name` -- human-friendly webhook name (required)
- `targetUrl` -- URL that receives POST notifications (required)
- `resource` -- what to monitor: `messages`, `rooms`, `memberships`, `meetings`, `recordings`, `meetingParticipants`, `telephony_calls`, etc. (required)
- `event` -- trigger type: `created`, `updated`, `deleted`, `started`, `ended`, `joined`, `left` (required)
- `filter` -- scope notifications (e.g., `roomId=<id>` or `hostEmail=<email>`)
- `secret` -- optional HMAC secret for payload signature verification
- `ownedBy` -- `creator` for personal or `org` for organization-wide webhooks
Supporting tools:
- `WEBEX_LIST_WEBHOOKS` -- list all registered webhooks with optional `max` and `ownedBy` filters
- `WEBEX_WEBHOOKS_GET_WEBHOOK` -- inspect a specific webhook by `webhookId`
Example prompt:
> "Create a webhook called 'New Messages' that POSTs to https://my-app.com/hook whenever a message is created in room Y2lz..."
---
### 4. Manage Team Memberships
Add people to Webex teams and optionally grant moderator privileges.
**Tool:** `WEBEX_MESSAGING_CREATE_TEAM_MEMBERSHIP`
Key parameters:
- `teamId` -- the team to add the person to (required)
- `personEmail` -- email of the person to add
- `personId` -- Webex person ID (alternative to email)
- `isModerator` -- set to `true` for moderator access (default `false`)
Use `WEBEX_LIST_TEAMS` to discover available teams first.
Example prompt:
> "Add alice@example.com as a moderator to team Y2lz..."
---
### 5. Audit Room Memberships
Check who is in a room, verify a specific person's membership, or list memberships across teams.
**Tool:** `WEBEX_MESSAGING_LIST_MEMBERSHIPS`
Key parameters:
- `roomId` -- list all members of a specific room
- `personEmail` -- check if a person is a member (requires `roomId`)
- `personId` -- check by Webex person ID (requires `roomId`)
- `teamId` -- filter by team association
- `max` -- limit results
Example prompt:
> "List all members of room Y2lz... and tell me who the moderators are"
---
### 6. Search and Look Up People
Look up people in your Webex organization by email, display name, or ID.
**Tool:** `WEBEX_PEOPLE_LIST_PEOPLE`
Use to resolve names to person IDs before sending direct messages or adding team members.
Example prompt:
> "Find the Webex person ID for bob@company.com"
---
## 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
| Pitfall | Details |
|---------|---------|
| Webhook auto-disable | Target URL must respond with HTTP 2xx; 100 failures in 5 minutes disables the webhook automatically |
| Message size limit | Both `text` and `markdown` have a 7439-byte maximum |
| One file per message | The `files` array accepts a list but only one attachment is actually supported per message |
| One card per message | Only one Adaptive Card attachment is supported per message |
| Mutually exclusive targets | `roomId` and `toPersonEmail`/`toPersonId` cannot be used together when sending messages |
| Room update requires title | `WEBEX_UPDATE_ROOM` always requires the `title` parameter, even when only changing lock status or team |
| orgPublicSpaces conflicts | Cannot combine `orgPublicSpaces` with `teamId`, `type`, or `sortBy` when listing rooms |
| Webhook read scope | Creating a webhook requires `read` scope on the monitored resource type |
| Membership filter requires roomId | `personEmail` and `personId` filters in list memberships require `roomId` unless you are a Compliance Officer |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Webex-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `webex` |
| 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` |
| Action | Tool Slug | Key Params |
|--------|-----------|------------|
| Send message | `WEBEX_MESSAGING_CREATE_MESSAGE` | `roomId`, `text`/`markdown`, `toPersonEmail` |
| List rooms | `WEBEX_MESSAGING_LIST_ROOMS` | `type`, `sortBy`, `max` |
| Get room details | `WEBEX_MESSAGING_GET_ROOM_DETAILS` | `roomId` |
| Update room | `WEBEX_UPDATE_ROOM` | `roomId`, `title` |
| Delete message | `WEBEX_MESSAGING_DELETE_MESSAGE` | `messageId` |
| Get message details | `WEBEX_MESSAGING_GET_MESSAGE_DETAILS` | `messageId` |
| Create webhook | `WEBEX_WEBHOOKS_CREATE_WEBHOOK` | `name`, `targetUrl`, `resource`, `event` |
| List webhooks | `WEBEX_LIST_WEBHOOKS` | `max`, `ownedBy` |
| Get webhook | `WEBEX_WEBHOOKS_GET_WEBHOOK` | `webhookId` |
| Add team member | `WEBEX_MESSAGING_CREATE_TEAM_MEMBERSHIP` | `teamId`, `personEmail`, `isModerator` |
| List memberships | `WEBEX_MESSAGING_LIST_MEMBERSHIPS` | `roomId`, `personEmail`, `max` |
| List people | `WEBEX_PEOPLE_LIST_PEOPLE` | email, displayName, ID filters |
| List teams | `WEBEX_LIST_TEAMS` | `max` |
---
*Powered by [Composio](https://composio.dev)*

158
workday-automation/SKILL.md
View File

@@ -1,91 +1,145 @@
---
name: workday-automation
description: "Automate Workday tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Workday Automation
description: "Automate HR operations in Workday -- manage workers, time off requests, absence balances, and employee data through natural language commands."
requires:
mcp: [rube]
mcp:
- rube
---
# Workday Automation via Rube MCP
# Workday Automation
Automate Workday operations through Composio's Workday toolkit via Rube MCP.
Automate your Workday HR operations directly from Claude Code. Look up workers, create time off requests, check absence balances, and validate time off eligibility -- all without leaving your terminal.
**Toolkit docs**: [composio.dev/toolkits/workday](https://composio.dev/toolkits/workday)
**Toolkit docs:** [composio.dev/toolkits/workday](https://composio.dev/toolkits/workday)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Workday connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `workday`
- 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. Add the Rube MCP server to your Claude Code config with URL: `https://rube.app/mcp`
2. When prompted, authenticate your Workday account through the connection link provided
3. Start automating your HR workflows with natural language
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `workday`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Search and List Workers
Retrieve worker information with search and pagination.
**Tool:** `WORKDAY_LIST_WORKERS`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Workday operations", known_fields: ""}]
session: {generate_id: true}
Search for workers named "Sarah" and include terminated employees
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
Key parameters:
- `search` -- search by name or worker ID (case-insensitive, space-delimited for OR search)
- `includeTerminatedWorkers` -- include terminated workers in results
- `limit` (default 20, max 100) / `offset` -- pagination controls
## Core Workflow Pattern
### 2. Create Time Off Requests
### Step 1: Discover Available Tools
Submit time off requests for workers with full business process support.
**Tool:** `WORKDAY_CREATE_TIME_OFF_REQUEST`
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Workday task"}]
session: {id: "existing_session_id"}
Create a vacation request for worker abc123 for March 15-17, 2026 (8 hours each day)
```
### Step 2: Check Connection
Key parameters:
- `ID` (required) -- Workday worker ID
- `businessProcessParameters` (required) -- must include `action` with `id` field (use `"d9e4223e446c11de98360015c5e6daf6"` for submit action)
- `days` (required) -- array of time off entries, each with:
- `date` (required) -- date in `yyyy-mm-dd` format
- `timeOffType` (required) -- object with `id` of the eligible absence type
- `dailyQuantity` -- hours or days quantity
- `comment`, `start`, `end`, `position`, `reason` -- optional fields
- `businessProcessParameters.comment` -- optional business process comment
### 3. Check Time Off Eligibility
Validate which dates a worker can take off before submitting a request.
**Tool:** `WORKDAY_GET_WORKER_VALID_TIME_OFF_DATES`
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["workday"]
session_id: "your_session_id"
Check if worker abc123 is eligible to take time off on March 15, 2026
```
### Step 3: Execute Tools
Key parameters:
- `ID` (required) -- Workday worker ID
- `date` -- specific date to validate (`yyyy-mm-dd`)
- `position` -- filter by specific position ID
- `timeOff` -- filter by specific time off plan/type ID
- `limit` (max 100) / `offset` -- pagination
### 4. View Absence Balances
Check remaining time off balances for workers across all plans.
**Tool:** `WORKDAY_LIST_ABSENCE_BALANCES`
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Show me absence balances for all workers in the organization
```
- Retrieves balances for time off plans and leave of absence types
- Can be filtered by worker ID, category, and effective date
### 5. Get Current User Profile
Retrieve the authenticated worker's profile information.
**Tool:** `WORKDAY_GET_CURRENT_USER`
```
Show me my Workday profile information
```
- No parameters required
- Returns the authenticated worker's profile
- Use this first to get the worker ID for subsequent operations
### 6. View Time Off History
Retrieve time off details and history for a specific worker.
**Tool:** `WORKDAY_GET_WORKER_TIME_OFF_DETAILS`
```
Show me the time off history for worker abc123
```
- Retrieves a collection of time off details for the specified worker
- Useful for auditing time off usage and remaining balances
---
## 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
- **Worker ID resolution:** Always call `WORKDAY_GET_CURRENT_USER` or `WORKDAY_LIST_WORKERS` first to resolve Workday worker IDs. Worker IDs are Workday-specific UUIDs, not employee numbers.
- **Time off type IDs must be valid:** The `timeOffType.id` in `WORKDAY_CREATE_TIME_OFF_REQUEST` must reference a valid eligible absence type for that worker. Use the "Get Worker Eligible Absence Types" flow to discover valid type IDs.
- **Submit action ID:** The `businessProcessParameters.action.id` should be `"d9e4223e446c11de98360015c5e6daf6"` for the submit action. Using an incorrect ID will cause the business process to fail.
- **Date format:** All date fields use `yyyy-mm-dd` format. ISO 8601 with timestamps is not accepted for date-only fields.
- **Pagination limits:** The maximum `limit` is 100 across all Workday endpoints. Default is 20. Always paginate for complete datasets.
- **Business process approval:** Creating a time off request initiates the business process but does not guarantee approval. The request enters the normal approval workflow.
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Workday-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `workday` |
| 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` |
| Tool Slug | Description |
|---|---|
| `WORKDAY_LIST_WORKERS` | Search and list workers with staffing info |
| `WORKDAY_GET_CURRENT_USER` | Get the authenticated worker's profile |
| `WORKDAY_CREATE_TIME_OFF_REQUEST` | Submit a time off request (requires `ID`, `businessProcessParameters`, `days`) |
| `WORKDAY_GET_WORKER_VALID_TIME_OFF_DATES` | Check time off date eligibility (requires `ID`) |
| `WORKDAY_LIST_ABSENCE_BALANCES` | Retrieve absence balances across time off plans |
| `WORKDAY_GET_WORKER_TIME_OFF_DETAILS` | Get time off history for a worker |
---
*Powered by [Composio](https://composio.dev)*

219
xero-automation/SKILL.md
View File

@@ -1,91 +1,208 @@
---
name: xero-automation
description: "Automate Xero tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Xero Automation
description: "Xero Automation: manage invoices, contacts, payments, bank transactions, and accounts in Xero for cloud-based bookkeeping"
requires:
mcp: [rube]
---
# Xero Automation via Rube MCP
# Xero Automation
Automate Xero operations through Composio's Xero toolkit via Rube MCP.
Automate Xero accounting operations including managing invoices, contacts, payments, bank transactions, and chart of accounts for small business bookkeeping.
**Toolkit docs**: [composio.dev/toolkits/xero](https://composio.dev/toolkits/xero)
**Toolkit docs:** [composio.dev/toolkits/xero](https://composio.dev/toolkits/xero)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Xero connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `xero`
- 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.
This skill requires the **Rube MCP server** connected at `https://rube.app/mcp`.
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `xero`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows
Before executing any tools, ensure an active connection exists for the `xero` toolkit. If no connection is active, initiate one via `RUBE_MANAGE_CONNECTIONS`.
## Tool Discovery
**Multi-tenant:** If you manage multiple Xero organizations, first call `XERO_GET_CONNECTIONS` to list active tenants and obtain the correct `tenant_id` for subsequent calls.
Always discover available tools before executing workflows:
---
## Core Workflows
### 1. List and Filter Invoices
Retrieve invoices with filtering by status, contact, date range, and pagination.
**Tool:** `XERO_LIST_INVOICES`
**Key Parameters:**
- `Statuses` -- Comma-separated status filter: `"DRAFT"`, `"SUBMITTED"`, `"AUTHORISED"`, `"PAID"`
- `ContactIDs` -- Comma-separated Contact IDs to filter by
- `InvoiceIDs` -- Comma-separated Invoice IDs to filter by
- `where` -- OData-style filter, e.g., `"Status==\"AUTHORISED\" AND Total>100"`
- `order` -- Sort expression, e.g., `"Date DESC"`, `"InvoiceNumber ASC"`
- `page` -- Page number for pagination
- `If-Modified-Since` -- UTC timestamp; returns only invoices modified since this date
- `tenant_id` -- Xero organization ID (uses first tenant if omitted)
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Xero operations", known_fields: ""}]
session: {generate_id: true}
Tool: XERO_LIST_INVOICES
Arguments:
Statuses: "AUTHORISED,PAID"
order: "Date DESC"
page: 1
```
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
---
## Core Workflow Pattern
### 2. Manage Contacts
### Step 1: Discover Available Tools
Retrieve and search contacts for use in invoices and transactions.
**Tool:** `XERO_GET_CONTACTS`
**Key Parameters:**
- `searchTerm` -- Case-insensitive search across Name, FirstName, LastName, Email, ContactNumber
- `ContactID` -- Fetch a single contact by ID
- `where` -- OData filter, e.g., `"ContactStatus==\"ACTIVE\""`
- `page`, `pageSize` -- Pagination controls
- `order` -- Sort, e.g., `"UpdatedDateUTC DESC"`
- `includeArchived` -- Include archived contacts when `true`
- `summaryOnly` -- Lightweight response when `true`
**Example:**
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Xero task"}]
session: {id: "existing_session_id"}
Tool: XERO_GET_CONTACTS
Arguments:
searchTerm: "acme"
page: 1
pageSize: 25
```
### Step 2: Check Connection
> **Note:** On high-volume accounts, some `where` filters (e.g., `IsCustomer`, `IsSupplier`) may be rejected by Xero. Fall back to `searchTerm` or pagination.
---
### 3. Create Payments
Link an invoice to a bank account by creating a payment record.
**Tool:** `XERO_CREATE_PAYMENT`
**Key Parameters:**
- `InvoiceID` (required) -- Xero Invoice ID the payment applies to
- `AccountID` (required) -- Bank account ID for the payment
- `Amount` (required) -- Payment amount (number)
- `Date` -- Payment date in `YYYY-MM-DD` format
- `Reference` -- Payment reference or description
- `CurrencyRate` -- Exchange rate for foreign currency payments
**Example:**
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["xero"]
session_id: "your_session_id"
Tool: XERO_CREATE_PAYMENT
Arguments:
InvoiceID: "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
AccountID: "b2c3d4e5-f6a7-8901-bcde-f12345678901"
Amount: 1500.00
Date: "2026-02-11"
Reference: "Payment for INV-0042"
```
### Step 3: Execute Tools
---
### 4. Create Bank Transactions
Record spend (payments out) or receive (money in) bank transactions.
**Tool:** `XERO_CREATE_BANK_TRANSACTION`
**Key Parameters:**
- `Type` (required) -- `"SPEND"` (payment out) or `"RECEIVE"` (money in)
- `ContactID` (required) -- Xero Contact ID
- `BankAccountCode` (required) -- Bank account code from chart of accounts
- `LineItems` (required) -- Array of line items, each with:
- `Description` (required) -- Line item description
- `UnitAmount` (required) -- Unit price
- `AccountCode` (required) -- Account code for categorization
- `Quantity` -- Quantity (default 1)
- `TaxType` -- Tax type: `"OUTPUT"`, `"INPUT"`, `"NONE"`
- `Date` -- Transaction date in `YYYY-MM-DD` format
- `Reference` -- Transaction reference
- `Status` -- `"AUTHORISED"` or `"DELETED"`
- `CurrencyCode` -- e.g., `"USD"`, `"EUR"`
**Example:**
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
Tool: XERO_CREATE_BANK_TRANSACTION
Arguments:
Type: "SPEND"
ContactID: "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
BankAccountCode: "090"
LineItems: [
{
"Description": "Office supplies",
"UnitAmount": 75.00,
"AccountCode": "429",
"Quantity": 1,
"TaxType": "INPUT"
}
]
Date: "2026-02-11"
Reference: "Feb office supplies"
```
---
### 5. List Payments and Bank Transactions
Review existing payments and bank transaction history.
**Tools:**
- `XERO_LIST_PAYMENTS` -- List payments linking invoices to bank transactions
- `XERO_LIST_BANK_TRANSACTIONS` -- List spend/receive bank transactions
**Common Parameters:**
- `where` -- OData filter, e.g., `"Status==\"AUTHORISED\""`
- `order` -- Sort expression, e.g., `"Date DESC"`
- `page` -- Page number for pagination
- `If-Modified-Since` -- Incremental updates since timestamp
- `tenant_id` -- Organization ID
---
### 6. View Chart of Accounts and Connections
**Tools:**
- `XERO_LIST_ACCOUNTS` -- Retrieve all account codes for categorizing transactions
- `XERO_GET_CONNECTIONS` -- List active Xero tenant connections
- `XERO_LIST_ATTACHMENTS` -- List attachments on an entity (invoice, contact, etc.)
---
## 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
| Pitfall | Detail |
|---------|--------|
| **Multi-tenant routing** | If `tenant_id` is omitted, the first connected tenant is used. Always verify the correct tenant with `XERO_GET_CONNECTIONS` when managing multiple organizations. |
| **High-volume filter rejection** | On large accounts, some `where` filters like `IsCustomer`/`IsSupplier` may be rejected. Fall back to `searchTerm` with pagination. |
| **OData filter syntax** | Use double-equals (`==`) in OData filters, e.g., `Status==\"AUTHORISED\"`. Single `=` causes errors. |
| **Pagination required** | Most list endpoints paginate results. Always check for additional pages and continue fetching until complete. |
| **Date format** | All dates must be in `YYYY-MM-DD` format. Timestamps for `If-Modified-Since` must be full ISO 8601 UTC datetime. |
| **Bank account codes** | `BankAccountCode` in bank transactions must match a valid code from the chart of accounts. Use `XERO_LIST_ACCOUNTS` to discover valid codes. |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Xero-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `xero` |
| 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` |
| Tool Slug | Description |
|-----------|-------------|
| `XERO_LIST_INVOICES` | List invoices with filtering and pagination |
| `XERO_GET_CONTACTS` | Retrieve and search contacts |
| `XERO_CREATE_PAYMENT` | Create a payment linking invoice to bank account |
| `XERO_CREATE_BANK_TRANSACTION` | Record a spend or receive bank transaction |
| `XERO_LIST_PAYMENTS` | List payment records |
| `XERO_LIST_BANK_TRANSACTIONS` | List bank transactions |
| `XERO_LIST_ACCOUNTS` | Retrieve chart of accounts |
| `XERO_GET_CONNECTIONS` | List active Xero tenant connections |
| `XERO_LIST_ATTACHMENTS` | List attachments on an entity |
---
*Powered by [Composio](https://composio.dev)*

229
zoho-books-automation/SKILL.md
View File

@@ -1,91 +1,200 @@
---
name: zoho-books-automation
description: "Automate Zoho Books tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Zoho Books Automation
description: "Automate Zoho Books accounting workflows including invoice creation, bill management, contact lookup, payment tracking, and multi-organization support through natural language commands"
requires:
mcp: [rube]
mcp:
- rube
---
# Zoho Books Automation via Rube MCP
# Zoho Books Automation
Automate Zoho Books operations through Composio's Zoho Books toolkit via Rube MCP.
Automate Zoho Books accounting workflows -- create and manage invoices, track bills and payments, look up contacts, export PDFs, and handle multi-organization setups -- all through natural language.
**Toolkit docs**: [composio.dev/toolkits/zoho_books](https://composio.dev/toolkits/zoho_books)
**Toolkit docs:** [composio.dev/toolkits/zoho_books](https://composio.dev/toolkits/zoho_books)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Zoho Books connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `zoho_books`
- 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. Add the Rube MCP server to your environment: `https://rube.app/mcp`
2. Connect your Zoho Books account when prompted (OAuth flow via Composio)
3. Start issuing natural language commands for Zoho Books automation
1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `zoho_books`
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
## Core Workflows
Always discover available tools before executing workflows:
### 1. Discover Organizations
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "Zoho Books operations", known_fields: ""}]
session: {generate_id: true}
```
Retrieve all organizations for the authenticated user. This is a prerequisite since `organization_id` is required by nearly every other endpoint.
This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
**Tool:** `ZOHO_BOOKS_LIST_ORGANIZATIONS`
## Core Workflow Pattern
No parameters required. Returns organization IDs, names, and metadata.
### Step 1: Discover Available Tools
> Always call this first to obtain the `organization_id` needed by all other Zoho Books tools.
```
RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Zoho Books task"}]
session: {id: "existing_session_id"}
```
Example prompt:
> "List my Zoho Books organizations"
### Step 2: Check Connection
---
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["zoho_books"]
session_id: "your_session_id"
```
### 2. Create and Manage Invoices
### Step 3: Execute Tools
Create invoices with line items, manage existing invoices, and export them as PDFs.
```
RUBE_MULTI_EXECUTE_TOOL
tools: [{
tool_slug: "TOOL_SLUG_FROM_SEARCH",
arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"
```
**Create:** `ZOHO_BOOKS_CREATE_INVOICE`
Key parameters:
- `organization_id` -- target organization (required)
- `customer_id` -- customer to bill (required)
- `line_items` -- array of line items (required), each with:
- `item_id` or `name` -- reference existing item or create ad-hoc line
- `quantity`, `rate` -- amount details
- `description`, `tax_id`, `discount` -- optional details
- `date` / `due_date` -- dates in `YYYY-MM-DD` format
- `invoice_number` -- custom number (set `ignore_auto_number_generation=true`)
- `discount` / `discount_type` -- invoice-level discount (`entity_level` or `item_level`)
- `notes` / `terms` -- printed on the invoice
- `send` -- email the invoice immediately after creation
- `payment_terms` -- number of days for payment
**List:** `ZOHO_BOOKS_LIST_INVOICES`
Key parameters:
- `organization_id` (required)
- `status` -- `sent`, `draft`, `overdue`, `paid`, `void`, `unpaid`, `partially_paid`, `viewed`
- `customer_id` / `customer_name` -- filter by customer
- `date_start` / `date_end` -- date range filter (`YYYY-MM-DD`)
- `search_text` -- search invoice number, reference, or customer name
- `sort_column` / `sort_order` -- sort by `date`, `due_date`, `total`, `balance`, etc.
- `page` / `per_page` -- pagination (max 200 per page)
**Get details:** `ZOHO_BOOKS_GET_INVOICE` -- fetch by `invoice_id` with `accept` format: `json`, `pdf`, or `html`
**Delete:** `ZOHO_BOOKS_DELETE_INVOICE` -- remove by `invoice_id`
**Bulk export:** `ZOHO_BOOKS_BULK_EXPORT_INVOICES_PDF` -- merge up to 25 invoices into a single PDF
**Bulk print:** `ZOHO_BOOKS_BULK_PRINT_INVOICES` -- generate a combined print-ready PDF for up to 25 invoices
Example prompt:
> "Create an invoice for customer 1234567890 with 2 line items: 10 units of Widget A at $25 each, and 5 units of Widget B at $50 each, due in 30 days"
---
### 3. Track and Manage Bills
List, view, and update vendor bills with comprehensive filtering.
**List:** `ZOHO_BOOKS_LIST_BILLS`
Key parameters:
- `organization_id` (required)
- `status` -- `paid`, `open`, `overdue`, `void`, `partially_paid`
- `vendor_id` / `vendor_name_contains` -- filter by vendor
- `bill_number` / `bill_number_contains` -- filter by bill number
- `date_start` / `date_end` -- date range filter
- `total_greater_than` / `total_less_than` -- amount range filters
- `sort_column` / `sort_order` -- sort by `vendor_name`, `bill_number`, `date`, `due_date`, `total`, etc.
- `page` / `per_page` -- pagination (max 200)
**Get details:** `ZOHO_BOOKS_GET_BILL` -- fetch full bill by `bill_id` and `organization_id`
**Update:** `ZOHO_BOOKS_UPDATE_BILL` -- modify existing bill (requires `bill_id`, `organization_id`, `vendor_id`, `bill_number`)
Example prompt:
> "List all overdue bills for my organization, sorted by due date"
---
### 4. Look Up Contacts
Search and filter contacts (customers and vendors) for use in invoices and bills.
**Tool:** `ZOHO_BOOKS_LIST_CONTACTS`
Key parameters:
- `organization_id` (required)
- `contact_type` -- `customer` or `vendor`
- `contact_name_contains` / `contact_name_startswith` -- name filters
- `email_contains` / `email_startswith` -- email filters
- `company_name_contains` -- company name filter
- `filter_by` -- status filter: `Status.Active`, `Status.Inactive`, `Status.Duplicate`, etc.
- `search_text` -- search by contact name or notes (max 100 chars)
- `sort_column` -- sort by `contact_name`, `email`, `outstanding_receivable_amount`, `created_time`, etc.
- `page` / `per_page` -- pagination (max 200)
Example prompt:
> "Find all active customers whose company name contains 'Acme'"
---
### 5. Track Invoice Payments
List all payments recorded against a specific invoice.
**Tool:** `ZOHO_BOOKS_LIST_INVOICE_PAYMENTS`
Key parameters:
- `invoice_id` -- the invoice to check (required)
- `organization_id` -- the organization (required)
Returns all payment transactions applied to the invoice including amounts, dates, and payment methods.
Example prompt:
> "Show all payments recorded against invoice 451025000000123045"
---
### 6. Full Invoicing Workflow
Combine tools for end-to-end invoice management:
1. **Organization**: `ZOHO_BOOKS_LIST_ORGANIZATIONS` -- get `organization_id`
2. **Contacts**: `ZOHO_BOOKS_LIST_CONTACTS` -- find or verify `customer_id`
3. **Create**: `ZOHO_BOOKS_CREATE_INVOICE` -- create invoice with line items
4. **Review**: `ZOHO_BOOKS_GET_INVOICE` -- fetch invoice details or PDF
5. **Track**: `ZOHO_BOOKS_LIST_INVOICE_PAYMENTS` -- monitor payment status
6. **Export**: `ZOHO_BOOKS_BULK_EXPORT_INVOICES_PDF` -- batch export for records
Example prompt:
> "Find the customer ID for 'Acme Corp', create an invoice for them with consulting services, and then get the PDF"
---
## 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
| Pitfall | Details |
|---------|---------|
| Organization ID always required | Nearly every endpoint requires `organization_id` -- always call `ZOHO_BOOKS_LIST_ORGANIZATIONS` first |
| Line items required for invoices | `ZOHO_BOOKS_CREATE_INVOICE` requires at least one line item with either `item_id` or `name` |
| Invoice ID format | Use the numeric `invoice_id` from the invoice object (e.g., `7472322000000264123`), not the encoded ID from `invoice_url` |
| Bulk limits | Both `ZOHO_BOOKS_BULK_EXPORT_INVOICES_PDF` and `ZOHO_BOOKS_BULK_PRINT_INVOICES` accept a maximum of 25 invoice IDs |
| Pagination max 200 | All list endpoints cap at 200 records per page -- iterate pages for complete results |
| Bill update requires all fields | `ZOHO_BOOKS_UPDATE_BILL` requires `bill_id`, `organization_id`, `vendor_id`, and `bill_number` even for partial updates |
| Date format | All date parameters use `YYYY-MM-DD` format |
| response_option undocumented | `ZOHO_BOOKS_LIST_INVOICES` has an undocumented `response_option` parameter (0=full, 1=full+totals, 2=counts only) that may change without notice |
---
## Quick Reference
| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Zoho Books-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `zoho_books` |
| 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` |
| Action | Tool Slug | Key Params |
|--------|-----------|------------|
| List organizations | `ZOHO_BOOKS_LIST_ORGANIZATIONS` | (none) |
| Create invoice | `ZOHO_BOOKS_CREATE_INVOICE` | `organization_id`, `customer_id`, `line_items` |
| List invoices | `ZOHO_BOOKS_LIST_INVOICES` | `organization_id`, `status`, `date_start` |
| Get invoice | `ZOHO_BOOKS_GET_INVOICE` | `invoice_id`, `organization_id`, `accept` |
| Delete invoice | `ZOHO_BOOKS_DELETE_INVOICE` | `invoice_id`, `organization_id` |
| Bulk export PDF | `ZOHO_BOOKS_BULK_EXPORT_INVOICES_PDF` | `organization_id`, `invoice_ids` |
| Bulk print | `ZOHO_BOOKS_BULK_PRINT_INVOICES` | `organization_id`, `invoice_ids` |
| List bills | `ZOHO_BOOKS_LIST_BILLS` | `organization_id`, `status`, `vendor_id` |
| Get bill | `ZOHO_BOOKS_GET_BILL` | `bill_id`, `organization_id` |
| Update bill | `ZOHO_BOOKS_UPDATE_BILL` | `bill_id`, `organization_id`, `vendor_id` |
| List contacts | `ZOHO_BOOKS_LIST_CONTACTS` | `organization_id`, `contact_type`, `search_text` |
| List payments | `ZOHO_BOOKS_LIST_INVOICE_PAYMENTS` | `invoice_id`, `organization_id` |
---
*Powered by [Composio](https://composio.dev)*

122
zoho-desk-automation/SKILL.md
View File

@@ -1,91 +1,57 @@
---
name: zoho-desk-automation
description: "Automate Zoho Desk tasks via Rube MCP (Composio). Always search tools first for current schemas."
name: Zoho Desk Automation
description: "Zoho Desk automation via Rube MCP -- toolkit not currently available in Composio; no ZOHO_DESK_ tools found"
requires:
mcp: [rube]
mcp:
- rube
---
# Zoho Desk Automation via Rube MCP
# Zoho Desk Automation
Automate Zoho Desk operations through Composio's Zoho Desk toolkit via Rube MCP.
> **Status: Toolkit Not Available** -- RUBE_SEARCH_TOOLS returned no `zoho_desk`-specific tools. The Zoho Desk toolkit is not currently available in Composio's tool catalog. Searches returned tools from unrelated helpdesk and CRM toolkits instead.
**Toolkit docs**: [composio.dev/toolkits/zoho_desk](https://composio.dev/toolkits/zoho_desk)
**Toolkit docs:** [composio.dev/toolkits/zoho_desk](https://composio.dev/toolkits/zoho_desk)
## Prerequisites
- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Zoho Desk connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `zoho_desk`
- 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 `zoho_desk`
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: "Zoho Desk 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 Zoho Desk task"}]
session: {id: "existing_session_id"}
```
### Step 2: Check Connection
```
RUBE_MANAGE_CONNECTIONS
toolkits: ["zoho_desk"]
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 Zoho Desk-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `zoho_desk` |
| 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` |
1. Add the Rube MCP server to your environment: `https://rube.app/mcp`
2. Check availability by calling `RUBE_SEARCH_TOOLS` with Zoho Desk-related queries
3. If `ZOHO_DESK_*` tools appear in the future, connect via `RUBE_MANAGE_CONNECTIONS` with toolkit `zoho_desk`
---
## Current Status
As of the last tool discovery scan, no `ZOHO_DESK_*` tool slugs were returned by RUBE_SEARCH_TOOLS. Queries for Zoho Desk ticket management, contacts, agents, and departments all returned tools from other toolkits:
- Ticket creation queries returned **Freshdesk** (`FRESHDESK_CREATE_TICKET`), **HubSpot** (`HUBSPOT_CREATE_TICKET`), and **Zendesk** (`ZENDESK_CREATE_ZENDESK_TICKET`) tools
- Contact listing queries returned **Zoho Invoice** (`ZOHO_INVOICE_LIST_CONTACTS`) tools
- Agent/department queries returned **Zoho CRM** (`ZOHO_GET_ZOHO_USERS`) tools
This indicates the `zoho_desk` toolkit either has no tools registered or is not yet integrated into the Composio platform.
---
## Alternatives
If you need helpdesk and support ticket automation, consider these available toolkits:
| Need | Alternative Toolkit | Example Tools |
|------|-------------------|---------------|
| Ticket management | Freshdesk | `FRESHDESK_CREATE_TICKET`, `FRESHDESK_UPDATE_TICKET` |
| Ticket management | Zendesk | `ZENDESK_CREATE_ZENDESK_TICKET` |
| Ticket management | HubSpot | `HUBSPOT_CREATE_TICKET`, `HUBSPOT_LIST_TICKETS` |
| CRM records | Zoho CRM | `ZOHO_CREATE_ZOHO_RECORD`, `ZOHO_GET_ZOHO_USERS` |
| Contact management | Zoho Invoice | `ZOHO_INVOICE_LIST_CONTACTS` |
---
## When Tools Become Available
Once Zoho Desk tools are added to Composio, this skill should be updated with real tool slugs, schemas, and pitfalls following the same pattern as other automation skills in this collection.
---
*Powered by [Composio](https://composio.dev)*